github-router 0.3.150 → 0.3.152

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

@@ -1176,35 +1176,172 @@ var ArtifactError = class extends Error {
 		this.detail = args.detail;
 	}
 };
+const AWAIT_DEFAULT_TIMEOUT_MS = 25e3;
+const AWAIT_ABORT_MARGIN_MS = 5e3;
+const DEFAULT_RETRY_BASE_MS = 250;
+const TRANSIENT_RETRIES = 2;
+const DEFAULT_RETRYABLE_CODES = new Set(["UNREACHABLE", "TIMEOUT"]);
+const AWAIT_RETRYABLE_CODES = new Set(["UNREACHABLE"]);
 var ArtifactClient = class {
 	baseUrl;
 	token;
 	sessionId;
 	fetchFn;
 	insecureTLS;
+	retryBaseMs;
 	constructor(options) {
 		this.baseUrl = options.baseUrl.replace(/\/+$/, "");
 		this.token = options.token;
 		this.sessionId = options.sessionId;
 		this.fetchFn = options.fetchFn ?? globalThis.fetch.bind(globalThis);
 		this.insecureTLS = options.insecureTLS ?? false;
+		this.retryBaseMs = options.retryBaseMs ?? DEFAULT_RETRY_BASE_MS;
 	}
-	open(file, signal) {
-		return this.request("POST", `/api/artifact/${encodeURIComponent(this.sessionId)}/open`, { file }, signal);
+	/**
+	* Open (or replace) the review for this session. `mode` is advisory metadata
+	* forwarded to the server (forward-compat: ignored if unknown); the actual
+	* interactivity comes from the served HTML's `data-aod-*` markup. Retried on a
+	* transient failure with a STABLE idempotency key so a retry-after-success does
+	* not double-open.
+	*/
+	open(file, opts = {}) {
+		const idempotencyKey = opts.idempotencyKey ?? randomUUID();
+		const body = { file };
+		if (opts.mode) body.mode = opts.mode;
+		return this.withRetry(() => this.requestOnce({
+			method: "POST",
+			pathname: this.path("/open"),
+			body,
+			signal: opts.signal,
+			idempotencyKey
+		}), TRANSIENT_RETRIES, opts.signal);
 	}
-	poll(timeoutMsHint, signal) {
-		return this.request("GET", `/api/artifact/${encodeURIComponent(this.sessionId)}/poll`, void 0, signal, timeoutMsHint);
+	/**
+	* Replace the current review's content. Exactly one of `file` | `html` (the
+	* caller-facing tool enforces that). `html` is written by the SERVER to the
+	* review's existing sandboxed file, so `html` with no existing review is an
+	* INVALID_REQUEST from the server. Retried with a stable idempotency key.
+	*/
+	update(opts) {
+		const idempotencyKey = opts.idempotencyKey ?? randomUUID();
+		const body = {};
+		if (opts.file !== void 0) body.file = opts.file;
+		if (opts.html !== void 0) body.html = opts.html;
+		return this.withRetry(() => this.requestOnce({
+			method: "POST",
+			pathname: this.path("/update"),
+			body,
+			signal: opts.signal,
+			idempotencyKey,
+			allowEmptyJson: true
+		}), TRANSIENT_RETRIES, opts.signal);
+	}
+	/** Force a reload from disk (no content change). Single-shot (idempotent, cheap). */
+	refresh(signal) {
+		return this.requestOnce({
+			method: "POST",
+			pathname: this.path("/refresh"),
+			signal,
+			allowEmptyJson: true
+		});
+	}
+	/** Hide the panel UI while keeping the review alive. Single-shot; server idempotent. */
+	dismiss(signal) {
+		return this.requestOnce({
+			method: "POST",
+			pathname: this.path("/dismiss"),
+			signal,
+			allowEmptyJson: true
+		});
+	}
+	/**
+	* Typed drain (contract v2.2 §1/§2). Long-holds up to the server cap, returns
+	* events with `id > cursor` plus the new high-water `cursor`. Idempotent by
+	* (cursor, event.id): re-calling with the same cursor replays the same window
+	* from the server's bounded buffer, so a lost cursor (compaction) is
+	* recoverable. Retried on a transient network failure (the cursor makes retry
+	* safe — no double-consumption).
+	*/
+	awaitEvents(opts = {}) {
+		const serverTimeoutMs = typeof opts.timeoutMs === "number" && Number.isFinite(opts.timeoutMs) && opts.timeoutMs > 0 ? opts.timeoutMs : AWAIT_DEFAULT_TIMEOUT_MS;
+		const clientTimeoutMs = serverTimeoutMs + AWAIT_ABORT_MARGIN_MS;
+		return this.withRetry(() => this.requestOnce({
+			method: "GET",
+			pathname: this.path("/await"),
+			query: {
+				cursor: opts.cursor,
+				timeoutMs: String(serverTimeoutMs)
+			},
+			signal: opts.signal,
+			timeoutMsHint: clientTimeoutMs
+		}), TRANSIENT_RETRIES, opts.signal, AWAIT_RETRYABLE_CODES);
 	}
+	/** Free-text agent->human reply. SINGLE-SHOT (not retried): a retry-after-success
+	*  would render a duplicate chat bubble server-side. */
 	agentReply(text, signal) {
-		return this.request("POST", `/api/artifact/${encodeURIComponent(this.sessionId)}/agent-reply`, { text }, signal, void 0, true);
+		return this.requestOnce({
+			method: "POST",
+			pathname: this.path("/agent-reply"),
+			body: { text },
+			signal,
+			allowEmptyJson: true
+		});
+	}
+	/**
+	* End the review. Retried with a stable idempotency key; a NOT_FOUND (the
+	* review is already ended — whether by a prior call or by a retry landing after
+	* the first attempt succeeded) is mapped to a successful `{ ok, status:"ended" }`
+	* rather than surfaced as a 404 (contract v2.2 §1.1).
+	*/
+	async end(signal) {
+		const idempotencyKey = randomUUID();
+		try {
+			return await this.withRetry(() => this.requestOnce({
+				method: "POST",
+				pathname: this.path("/end"),
+				signal,
+				idempotencyKey,
+				allowEmptyJson: true
+			}), TRANSIENT_RETRIES, signal);
+		} catch (err) {
+			if (err instanceof ArtifactError && err.code === "NOT_FOUND") return {
+				ok: true,
+				status: "ended"
+			};
+			throw err;
+		}
 	}
-	end(signal) {
-		return this.request("POST", `/api/artifact/${encodeURIComponent(this.sessionId)}/end`, void 0, signal, void 0, true);
+	/**
+	* FROZEN legacy long-poll (contract v2.2 §1). Old payload shape,
+	* comment-equivalent only. New agents use `awaitEvents`. Single request per
+	* call (the caller-facing tool owns the bounded re-poll budget).
+	*/
+	poll(timeoutMsHint, signal) {
+		return this.requestOnce({
+			method: "GET",
+			pathname: this.path("/poll"),
+			signal,
+			timeoutMsHint
+		});
 	}
-	async request(method, pathname, body, signal, timeoutMsHint, allowEmptyJson = false) {
+	path(suffix) {
+		return `/api/artifact/${encodeURIComponent(this.sessionId)}${suffix}`;
+	}
+	async withRetry(fn, retries, signal, retryableCodes = DEFAULT_RETRYABLE_CODES) {
+		let attempt = 0;
+		for (;;) try {
+			return await fn();
+		} catch (err) {
+			attempt += 1;
+			if (!(err instanceof ArtifactError && err.retryable && retryableCodes.has(err.code)) || attempt > retries || signal?.aborted) throw err;
+			const base = this.retryBaseMs;
+			await sleep$1(base <= 0 ? 0 : Math.round(base * 2 ** (attempt - 1) * (.5 + Math.random() * .5)), signal);
+		}
+	}
+	async requestOnce(o) {
 		let url;
 		try {
-			url = new URL(pathname, `${this.baseUrl}/`);
+			url = new URL(o.pathname, `${this.baseUrl}/`);
 		} catch (err) {
 			throw new ArtifactError({
 				code: "UNREACHABLE",
@@ -1213,48 +1350,73 @@ var ArtifactClient = class {
 				detail: err
 			});
 		}
-		const timeout = combineSignalAndTimeout(signal, timeoutMsHint);
-		let response;
+		if (o.query) {
+			for (const [key, value] of Object.entries(o.query)) if (value !== void 0) url.searchParams.set(key, value);
+		}
+		const timeout = combineSignalAndTimeout(o.signal, o.timeoutMsHint);
 		try {
+			const headers = { Authorization: `Bearer ${this.token}` };
+			if (o.body !== void 0) headers["Content-Type"] = "application/json";
+			if (o.idempotencyKey) headers["Idempotency-Key"] = o.idempotencyKey;
 			const init = {
-				method,
-				headers: {
-					Authorization: `Bearer ${this.token}`,
-					...body === void 0 ? {} : { "Content-Type": "application/json" }
-				},
-				body: body === void 0 ? void 0 : JSON.stringify(body),
+				method: o.method,
+				headers,
+				body: o.body === void 0 ? void 0 : JSON.stringify(o.body),
 				redirect: "error",
 				signal: timeout.signal
 			};
 			if (this.insecureTLS) applyInsecureTls(init);
-			response = await this.fetchFn(url.toString(), init);
+			const response = await this.fetchFn(url.toString(), init);
+			if (!response.ok) throw await mapHttpError$1(response);
+			let text;
+			try {
+				text = await response.text();
+			} catch (err) {
+				if (isAbortLike$2(err)) throw mapNetworkError$1(err);
+				throw new ArtifactError({
+					code: "INVALID_RESPONSE",
+					message: "artifact API response body could not be read",
+					retryable: false,
+					detail: err
+				});
+			}
+			if (!text && o.allowEmptyJson) return {};
+			try {
+				return JSON.parse(text);
+			} catch (err) {
+				throw new ArtifactError({
+					code: "INVALID_RESPONSE",
+					message: "artifact API returned a non-JSON response",
+					retryable: false,
+					detail: err
+				});
+			}
 		} catch (err) {
+			if (err instanceof ArtifactError) throw err;
 			throw mapNetworkError$1(err);
 		} finally {
 			timeout.cleanup();
 		}
-		if (!response.ok) throw await mapHttpError$1(response);
-		const text = await response.text().catch((err) => {
-			throw new ArtifactError({
-				code: "INVALID_RESPONSE",
-				message: "artifact API response body could not be read",
-				retryable: false,
-				detail: err
-			});
-		});
-		if (!text && allowEmptyJson) return {};
-		try {
-			return JSON.parse(text);
-		} catch (err) {
-			throw new ArtifactError({
-				code: "INVALID_RESPONSE",
-				message: "artifact API returned a non-JSON response",
-				retryable: false,
-				detail: err
-			});
-		}
 	}
 };
+function sleep$1(ms, signal) {
+	if (ms <= 0) return Promise.resolve();
+	return new Promise((resolve, reject) => {
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(new DOMException("retry backoff aborted", "AbortError"));
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		if (signal?.aborted) {
+			onAbort();
+			return;
+		}
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
 function combineSignalAndTimeout(signal, timeoutMsHint) {
 	const timeoutMs = typeof timeoutMsHint === "number" && Number.isFinite(timeoutMsHint) && timeoutMsHint > 0 ? timeoutMsHint : void 0;
 	if (timeoutMs === void 0) return {
@@ -1311,6 +1473,13 @@ async function mapHttpError$1(response) {
 		status: response.status,
 		detail
 	});
+	if (response.status === 400 && detailToCode(detail)?.toUpperCase() === "INVALID_REQUEST") return new ArtifactError({
+		code: "INVALID_REQUEST",
+		message: `artifact API rejected the request (400)${suffix}`,
+		retryable: false,
+		status: response.status,
+		detail
+	});
 	return new ArtifactError({
 		code: "UPSTREAM_ERROR",
 		message: `artifact API returned HTTP ${response.status}${suffix}`,
@@ -1355,6 +1524,18 @@ function detailToMessage$1(detail) {
 	}
 	if (typeof record.message === "string") return record.message;
 }
+/** Extract a machine `code` from an upstream error body (`{error:{code}}` or
+*  `{code}`) so a tagged 400 can be classified (INVALID_REQUEST). */
+function detailToCode(detail) {
+	if (typeof detail !== "object" || detail === null) return void 0;
+	const record = detail;
+	const error = record.error;
+	if (typeof error === "object" && error !== null) {
+		const code = error.code;
+		if (typeof code === "string") return code;
+	}
+	if (typeof record.code === "string") return record.code;
+}
 function isAbortLike$2(err) {
 	return err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
 }
@@ -1383,27 +1564,86 @@ function tool(toolNameHttp, description, inputSchema, handler) {
 	};
 }
 const ARTIFACT_TOOLS = Object.freeze([
-	tool("artifact_open", "Open a workspace file in ai-or-die's Artifact review panel for human review. 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) => {
+	tool("artifact_open", "Open a workspace file in ai-or-die's Artifact review panel for human review. Pass mode:\"interactive\" when the HTML carries data-aod-* action controls. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({
+		file: stringProp$2("Workspace-relative or absolute file path to show in the Artifact panel."),
+		mode: enumProp(["static", "interactive"], "Advisory. \"interactive\" signals the HTML contains data-aod-* action controls the panel should wire; \"static\" (default) is a read-and-annotate artifact.")
+	}, ["file"]), async (args, signal) => {
 		const env = readArtifactEnv();
 		if (!env) return missingEnvResult();
 		const file = requiredString$2(args, "file");
+		const mode = optionalEnum(args, "mode", ["static", "interactive"]);
+		const response = await clientFromEnv(env).open(file, {
+			mode,
+			signal
+		});
 		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."
+			viewUrl: response.viewUrl,
+			sessionId: response.sessionId,
+			key: response.key,
+			next_step: "Tell the user to review at the Artifact panel, then call artifact_await to receive their feedback."
 		});
 	}),
-	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) => {
+	tool("artifact_update", "Replace the current Artifact review's content in place. Provide EXACTLY ONE of file (a workspace file path) or html (raw HTML the server writes to the review's sandboxed file). html requires an already-open review. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({
+		file: stringProp$2("Workspace-relative or absolute file path to become the review's new content."),
+		html: stringProp$2("Raw HTML to write into the review's existing sandboxed file, then reload."),
+		idempotencyKey: stringProp$2("Optional stable key so a retried update is de-duplicated by the server.")
+	}, []), async (args, signal) => {
 		const env = readArtifactEnv();
 		if (!env) return missingEnvResult();
-		return ok$2(formatPollResponse(await pollUntilReady(clientFromEnv(env), signal)));
+		const file = optionalString$2(args, "file");
+		const html = optionalString$2(args, "html");
+		if (file === void 0 === (html === void 0)) throw new ArtifactToolInputError("INVALID_ARGUMENT", "artifact_update requires EXACTLY ONE of arguments.file or arguments.html");
+		const idempotencyKey = optionalString$2(args, "idempotencyKey");
+		return ok$2({
+			...await clientFromEnv(env).update({
+				file,
+				html,
+				idempotencyKey,
+				signal
+			}),
+			ok: true,
+			next_step: "The panel now shows the updated content. Call artifact_await for further feedback."
+		});
+	}),
+	tool("artifact_refresh", "Force the ai-or-die Artifact panel to reload the current artifact from disk (no content change). Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({}, []), async (_args, signal) => {
+		const env = readArtifactEnv();
+		if (!env) return missingEnvResult();
+		return ok$2({
+			...await clientFromEnv(env).refresh(signal),
+			ok: true,
+			next_step: "The panel reloaded the artifact. Call artifact_await for feedback."
+		});
+	}),
+	tool("artifact_await", "Wait for the human's next Artifact review events (typed drain: comments AND structured action-button/checkbox events) and return them with a cursor. Pass the returned cursor on the next call to receive only newer events. Supersedes artifact_poll. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({
+		cursor: stringProp$2("High-water cursor from the previous artifact_await response. Omit on the first call."),
+		timeoutMs: numberProp$2("Optional server long-hold budget in ms (default ~25000).")
+	}, []), async (args, signal) => {
+		const env = readArtifactEnv();
+		if (!env) return missingEnvResult();
+		const cursor = optionalString$2(args, "cursor");
+		const timeoutMs = optionalNumber$2(args, "timeoutMs");
+		return ok$2(formatAwaitResponse(await clientFromEnv(env).awaitEvents({
+			cursor,
+			timeoutMs,
+			signal
+		})));
+	}),
+	tool("artifact_dismiss", "Hide the ai-or-die Artifact panel UI while keeping the review alive (queued feedback preserved, channel open, re-openable). Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({}, []), async (_args, signal) => {
+		const env = readArtifactEnv();
+		if (!env) return missingEnvResult();
+		return ok$2({
+			...await clientFromEnv(env).dismiss(signal),
+			ok: true,
+			next_step: "The panel is hidden but the review is still live. Re-open the artifact or call artifact_await when ready."
+		});
 	}),
 	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$2(args, "text");
 		return ok$2({
-			ok: true,
 			...await clientFromEnv(env).agentReply(text, signal),
+			ok: true,
 			next_step: "Wait for further human review, or continue if the review loop is complete."
 		});
 	}),
@@ -1411,10 +1651,15 @@ const ARTIFACT_TOOLS = Object.freeze([
 		const env = readArtifactEnv();
 		if (!env) return missingEnvResult();
 		return ok$2({
-			ok: true,
 			...await clientFromEnv(env).end(signal),
+			ok: true,
 			next_step: "Artifact review loop ended."
 		});
+	}),
+	tool("artifact_poll", "FROZEN legacy alias for artifact_await (old payload, human comments only, no structured actions). New agents should call artifact_await instead. Only works inside an ai-or-die tab-backed Claude session.", objectSchema$2({ timeoutMs: numberProp$2("Optional per-call budget hint in ms (advisory).") }, []), async (_args, signal) => {
+		const env = readArtifactEnv();
+		if (!env) return missingEnvResult();
+		return ok$2(formatPollResponse(await pollUntilReady(clientFromEnv(env), signal)));
 	})
 ]);
 function readArtifactEnv() {
@@ -1489,6 +1734,30 @@ function formatPollResponse(response) {
 		next_step: response.next_step ?? defaultPollNextStep(response.status)
 	});
 }
+/**
+* Shape the typed drain for the model: pass events through verbatim (unknown
+* `kind`s preserved — the model ignores what it does not understand), echo the
+* cursor to thread into the next call, and pick a next_step from the events.
+*/
+function formatAwaitResponse(response) {
+	const events$1 = Array.isArray(response.events) ? response.events : [];
+	const status = typeof response.status === "string" ? response.status : void 0;
+	return definedObject$1({
+		events: events$1,
+		status,
+		cursor: response.cursor,
+		next_step: awaitNextStep(status ?? "", events$1)
+	});
+}
+function awaitNextStep(status, events$1) {
+	if ((status ?? "").toLowerCase() === "ended") return "The review has ended. No further feedback will arrive.";
+	if (events$1.length === 0) return "No feedback yet. Call artifact_await again, passing the returned cursor.";
+	const hasAction = events$1.some((e) => e.kind === "action");
+	const hasComment = events$1.some((e) => e.kind === "comment");
+	if (hasAction && hasComment) return "Act on the action events (buttons/checkboxes) and the comments, reply with artifact_reply, then call artifact_await with the returned cursor.";
+	if (hasAction) return "The human triggered action controls. Act on them, optionally artifact_reply, then call artifact_await with the returned cursor.";
+	return "Apply the human comments, call artifact_reply with a concise summary, then artifact_await with the returned cursor.";
+}
 function defaultPollNextStep(status) {
 	return isWaitingStatus(status) ? "No human feedback is ready yet. Call artifact_poll again." : "Apply the human Artifact review feedback, then call artifact_reply with a concise summary.";
 }
@@ -1501,6 +1770,24 @@ function requiredString$2(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;
 }
+function optionalString$2(args, key) {
+	const value = args[key];
+	if (value === void 0 || value === null) return void 0;
+	if (typeof value !== "string" || value.trim() === "") throw new ArtifactToolInputError("INVALID_ARGUMENT", `arguments.${key} must be a non-empty string when provided`);
+	return value;
+}
+function optionalNumber$2(args, key) {
+	const value = args[key];
+	if (value === void 0 || value === null) return void 0;
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) throw new ArtifactToolInputError("INVALID_ARGUMENT", `arguments.${key} must be a positive number when provided`);
+	return value;
+}
+function optionalEnum(args, key, allowed) {
+	const value = optionalString$2(args, key);
+	if (value === void 0) return void 0;
+	if (!allowed.includes(value)) throw new ArtifactToolInputError("INVALID_ARGUMENT", `arguments.${key} must be one of ${allowed.join(", ")}`);
+	return value;
+}
 var ArtifactToolInputError = class extends Error {
 	code;
 	constructor(code, message) {
@@ -1565,6 +1852,19 @@ function stringProp$2(description) {
 		description
 	};
 }
+function numberProp$2(description) {
+	return {
+		type: "number",
+		description
+	};
+}
+function enumProp(values, description) {
+	return {
+		type: "string",
+		enum: [...values],
+		description
+	};
+}
 
 //#endregion
 //#region src/lib/fleet/mesh-egress-agent.ts
@@ -2673,6 +2973,464 @@ var MergedFleetRegistry = class {
 	}
 };
 
+//#endregion
+//#region src/lib/fleet/driver.ts
+/** ai-or-die named keys (raw:false maps these; never a literal "\r"). C4. */
+const SUBMIT_KEY = "enter";
+const INTERRUPT_KEY = "ctrl-c";
+/** The control events that RELIABLY mark a turn boundary (transcript-derived). */
+const TURN_SETTLE_KINDS = ["turn_ended", "waiting_input"];
+const DEFAULT_READY_POLL_MS = 500;
+const DEFAULT_TURN_POLL_MS = 25e3;
+const DEFAULT_PRIME_TIMEOUT_MS = 0;
+const DEFAULT_IDLE_WAIT_MS = 2e3;
+const DEFAULT_RECOVER_MS = 15e3;
+const DEFAULT_TAIL_LINES = 200;
+function realSleep(ms) {
+	if (ms <= 0) return Promise.resolve();
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** Map a named op to the ai-or-die named key. `submit` = Enter, `interrupt` = Ctrl-C.
+*  Callers send the returned key with raw:false so ai-or-die interprets the NAMED
+*  key — never a literal control byte. */
+function mapNamedKeyOp(op) {
+	switch (op) {
+		case "submit": return SUBMIT_KEY;
+		case "interrupt": return INTERRUPT_KEY;
+	}
+}
+function isNamedKeyOp(value) {
+	return value === "submit" || value === "interrupt";
+}
+/** Read `awaiting.kind` off a status defensively (the shape is `{ kind, ... }`). */
+function readAwaitingKind(status) {
+	const awaiting = status?.awaiting;
+	if (awaiting && typeof awaiting === "object") {
+		const kind = awaiting.kind;
+		if (typeof kind === "string" && kind.trim() !== "") return kind;
+	}
+}
+/**
+* Classify whether a free-text message may be submitted to a session RIGHT NOW.
+* Ready only when the session is idle or explicitly awaiting the next message.
+* A pending non-message prompt (plan_approval / choice_question / tool_approval /
+* trust_prompt) is `awaiting_other` — the caller should use `respond`, not a raw
+* message. `busy` / `terminal` are hard refusals; `unknown` carries no positive
+* evidence of a busy composer (the caller fails OPEN and lets the send surface its
+* own transport result).
+*/
+function classifyMessageReadiness(status) {
+	const interactionState = typeof status?.interactionState === "string" ? status.interactionState : void 0;
+	const awaitingKind = readAwaitingKind(status);
+	if (interactionState === "busy") return {
+		ready: false,
+		reason: "busy",
+		interactionState,
+		awaitingKind
+	};
+	if (interactionState === "exited" || interactionState === "crashed") return {
+		ready: false,
+		reason: "terminal",
+		interactionState
+	};
+	if (awaitingKind !== void 0 && awaitingKind !== "next_message") return {
+		ready: false,
+		reason: "awaiting_other",
+		interactionState,
+		awaitingKind
+	};
+	if (interactionState === "idle") return {
+		ready: true,
+		reason: "idle",
+		interactionState
+	};
+	if (awaitingKind === "next_message" || interactionState === "waiting_input") return {
+		ready: true,
+		reason: "awaiting_message",
+		interactionState,
+		awaitingKind
+	};
+	return {
+		ready: false,
+		reason: "unknown",
+		interactionState,
+		awaitingKind
+	};
+}
+/** A refusal reason with POSITIVE evidence the composer must not be typed into. */
+function isHardNotReady(reason) {
+	return reason === "busy" || reason === "awaiting_other" || reason === "terminal";
+}
+/**
+* Poll `/status` until the session is ready for a message or the wait budget is
+* spent. A status probe that THROWS fails OPEN (reports `unknown` and returns) so a
+* transient status hiccup never wedges a legitimate send — the send itself carries
+* ai-or-die's own submission signal.
+*/
+async function waitForMessageReady(client, localId, options = {}) {
+	const now = options.now ?? Date.now;
+	const sleep$2 = options.sleep ?? realSleep;
+	const waitMs = Math.max(0, options.waitMs ?? 0);
+	const pollMs = Math.max(1, options.pollMs ?? DEFAULT_READY_POLL_MS);
+	const deadline = now() + waitMs;
+	let last = {
+		ready: false,
+		reason: "unknown"
+	};
+	for (;;) {
+		let status;
+		try {
+			status = (await client.status(localId, options.signal)).status;
+		} catch {
+			return {
+				ready: false,
+				readiness: {
+					ready: false,
+					reason: "unknown"
+				},
+				statusError: true
+			};
+		}
+		last = classifyMessageReadiness(status);
+		if (last.ready) return {
+			ready: true,
+			readiness: last
+		};
+		const remaining = deadline - now();
+		if (remaining <= 0) return {
+			ready: false,
+			readiness: last
+		};
+		await sleep$2(Math.min(pollMs, remaining));
+	}
+}
+/**
+* Classify a batch of already-stamped events per session for the `await_turn`
+* summary. `turn_ended` -> completed, `waiting_input` -> awaiting_input (both
+* reliable / transcript-derived); a bare `became_idle` is surfaced as `idle_flicker`
+* with reliable:false so a caller NEVER mistakes the PTY heuristic for completion.
+* `became_busy` and other kinds are ignored (not a settle signal).
+*/
+function classifyTurnEvents(events$1) {
+	const rank = {
+		completed: 3,
+		awaiting_input: 2,
+		idle_flicker: 1
+	};
+	const best = /* @__PURE__ */ new Map();
+	for (const event of events$1) {
+		const sessionId = typeof event.sessionId === "string" ? event.sessionId : void 0;
+		const kind = typeof event.kind === "string" ? event.kind : void 0;
+		if (sessionId === void 0 || kind === void 0) continue;
+		let status;
+		if (kind === "turn_ended") status = "completed";
+		else if (kind === "waiting_input") status = "awaiting_input";
+		else if (kind === "became_idle") status = "idle_flicker";
+		if (status === void 0) continue;
+		const prior = best.get(sessionId);
+		if (prior === void 0 || rank[status] > rank[prior]) best.set(sessionId, status);
+	}
+	return [...best.entries()].map(([sessionId, status]) => ({
+		sessionId,
+		status,
+		reliable: status !== "idle_flicker"
+	}));
+}
+function pickSettleEvent(events$1, localId) {
+	let awaiting;
+	for (const event of events$1) {
+		if (event.sessionId !== localId) continue;
+		if (event.kind === "turn_ended") return event;
+		if (event.kind === "waiting_input" && awaiting === void 0) awaiting = event;
+	}
+	return awaiting;
+}
+/** Client-side backoff after a transient waitEvents failure so the loop cannot
+*  hot-spin (hammer the control plane) when polls fail fast (network down). */
+const TURN_POLL_ERROR_BACKOFF_MS = 250;
+/** Attempts to obtain a starting cursor before a drive send (see driveTask step 2). */
+const PRIME_CURSOR_ATTEMPTS = 3;
+/**
+* Obtain a starting `/events` cursor before sending, retrying a bounded number of
+* times. A cursor is what prevents a stale prior-turn `turn_ended` from satisfying
+* the post-send wait; a cursorless request may replay history. Retries are cheap
+* (a zero/short poll). Returns undefined only if every attempt fails (rare) or the
+* signal aborts — the caller then proceeds best-effort.
+*/
+async function primeTurnCursor(client, localId, timeoutMs, signal) {
+	for (let attempt = 0; attempt < PRIME_CURSOR_ATTEMPTS; attempt++) {
+		if (signal?.aborted) return void 0;
+		try {
+			return (await client.waitEvents({
+				sessionIds: [localId],
+				kinds: [...TURN_SETTLE_KINDS],
+				timeoutMs
+			}, signal)).cursor;
+		} catch {}
+	}
+}
+/**
+* Wait until the CURRENT turn actually ends (`turn_ended`) or the session is
+* awaiting input (`waiting_input`), long-polling `/events` filtered to those kinds
+* and advancing the server cursor across windows. Returns `{settled:false,
+* reason:"timeout"}` when neither fires within `timeoutMs`. It NEVER settles on
+* `became_idle`. Prime a cursor BEFORE the send (a zero/short poll) and pass it in
+* so a stale prior-turn event cannot satisfy the wait.
+*/
+async function waitForTurnSettled(client, localId, options) {
+	const now = options.now ?? Date.now;
+	const sleep$2 = options.sleep ?? realSleep;
+	const pollTimeoutMs = Math.max(1, options.pollTimeoutMs ?? DEFAULT_TURN_POLL_MS);
+	const budget = Number.isFinite(options.timeoutMs) ? Math.max(0, options.timeoutMs) : 0;
+	const deadline = now() + budget;
+	let cursor = options.cursor;
+	do {
+		if (options.signal?.aborted) return {
+			settled: false,
+			reason: "aborted",
+			cursor
+		};
+		const remaining = deadline - now();
+		const poll = remaining <= 0 ? 0 : Math.min(pollTimeoutMs, remaining);
+		let response;
+		try {
+			response = await client.waitEvents({
+				sessionIds: [localId],
+				kinds: [...TURN_SETTLE_KINDS],
+				timeoutMs: poll,
+				cursor
+			}, options.signal);
+		} catch {
+			if (options.signal?.aborted) return {
+				settled: false,
+				reason: "aborted",
+				cursor
+			};
+			if (now() >= deadline) return {
+				settled: false,
+				reason: "timeout",
+				cursor
+			};
+			await sleep$2(Math.min(TURN_POLL_ERROR_BACKOFF_MS, Math.max(0, deadline - now())));
+			continue;
+		}
+		cursor = response.cursor;
+		const hit = pickSettleEvent(response.events, localId);
+		if (hit) return {
+			settled: true,
+			reason: hit.kind === "turn_ended" ? "turn_ended" : "waiting_input",
+			cursor,
+			event: hit
+		};
+	} while (now() < deadline);
+	return {
+		settled: false,
+		reason: "timeout",
+		cursor
+	};
+}
+const OPERATOR_REPORT_HEADER = "=== OPERATOR REPORT ===";
+const OPERATOR_REPORT_FOOTER = "=== END OPERATOR REPORT ===";
+const OPERATOR_REPORT_LABELS = [
+	"REPORT_ID",
+	"STATE",
+	"SUMMARY",
+	"ASK",
+	"ARTIFACT"
+];
+/**
+* Parse the LAST OPERATOR REPORT trailer in a transcript tail into typed fields.
+* Robust to: no trailer (returns state:"unknown", found:false), a missing footer,
+* multi-line field values (a value runs until the next known label or the footer),
+* and case-insensitive labels. Lines before the first label are ignored.
+*/
+function parseOperatorReport(text) {
+	const raw = text ?? "";
+	const headerIdx = raw.lastIndexOf(OPERATOR_REPORT_HEADER);
+	if (headerIdx === -1) return {
+		state: "unknown",
+		raw,
+		found: false
+	};
+	let block = raw.slice(headerIdx + 23);
+	const footerIdx = block.indexOf(OPERATOR_REPORT_FOOTER);
+	if (footerIdx !== -1) block = block.slice(0, footerIdx);
+	const values = {};
+	let current;
+	for (const line of block.split(/\r?\n/)) {
+		const match = /^\s*([A-Za-z_]+)\s*:\s*(.*)$/.exec(line);
+		const label = match?.[1]?.toUpperCase();
+		if (match && label && OPERATOR_REPORT_LABELS.includes(label)) {
+			current = label;
+			values[current] = [match[2] ?? ""];
+		} else if (current) values[current].push(line);
+	}
+	const join$1 = (key) => {
+		const parts = values[key];
+		if (parts === void 0) return void 0;
+		const joined = parts.join("\n").trim();
+		if (joined === "") return void 0;
+		if (/^<[^>\n]*\s[^>\n]*>$/.test(joined)) return void 0;
+		return joined;
+	};
+	return {
+		state: join$1("STATE") ?? "unknown",
+		summary: join$1("SUMMARY"),
+		ask: join$1("ASK"),
+		artifact: join$1("ARTIFACT"),
+		reportId: join$1("REPORT_ID"),
+		raw,
+		found: true
+	};
+}
+/** The trailer instruction `drive_task` appends when `expectReport` is on, so a
+*  driven session ends its turn with a parseable {@link parseOperatorReport} block.
+*  When `reportId` is supplied it is embedded as a `REPORT_ID` line the session must
+*  copy verbatim, so the driver can confirm the parsed report is for THIS turn and not
+*  a stale prior-turn trailer still inside the transcript tail window. */
+function operatorReportInstruction(reportId) {
+	const lines = [
+		"",
+		reportId !== void 0 ? "When you have completely finished this task, end your FINAL message with EXACTLY this trailer. Copy the REPORT_ID line verbatim and fill in each other field:" : "When you have completely finished this task, end your FINAL message with EXACTLY this trailer, filling in each field:",
+		OPERATOR_REPORT_HEADER
+	];
+	if (reportId !== void 0) lines.push(`REPORT_ID: ${reportId}`);
+	lines.push("STATE: <done | blocked | needs_input | in_progress>", "SUMMARY: <1-3 sentence summary of what you did>", "ASK: <what you need from the operator, or 'none'>", "ARTIFACT: <path or URL to the primary artifact, or 'none'>", OPERATOR_REPORT_FOOTER);
+	return lines.join("\n");
+}
+function notReadyState(reason) {
+	switch (reason) {
+		case "busy": return "busy";
+		case "awaiting_other": return "awaiting_other";
+		case "terminal": return "dead";
+		default: return "unknown";
+	}
+}
+async function readTail(client, localId, lines, signal) {
+	try {
+		const response = await client.readSession(localId, lines, signal);
+		return typeof response.text === "string" ? response.text : "";
+	} catch {
+		return "";
+	}
+}
+/**
+* Drive one prompt on a session to completion and return the parsed operator report.
+* Flow: ensure the composer is idle (C1) -> send + surface whether the bytes reached
+* the composer (C2 `submitted`; a delivered-but-unconfirmed send still proceeds, since
+* the turn wait + timeout recovery covers the "nothing landed" case) -> wait for
+* `turn_ended`/`waiting_input` (C2) -> read the transcript tail -> parse the operator
+* report trailer -> if the turn did not settle in `timeoutMs`, AUTO-RECOVER via a
+* Ctrl-C interrupt (C4) rather than blocking (~10 min stop-hook hang), then re-wait
+* briefly and re-read. Robust to a busy session, a missing trailer (state:"unknown"),
+* and a hung stop hook.
+*/
+async function driveTask(deps) {
+	const { client, localId, prompt, timeoutMs, expectReport, idempotencyKey, interruptKey, reportId, signal } = deps;
+	const now = deps.now ?? Date.now;
+	const sleep$2 = deps.sleep ?? realSleep;
+	const tailLines = deps.tailLines ?? DEFAULT_TAIL_LINES;
+	const pollTimeoutMs = deps.pollTimeoutMs;
+	const readyResult = await waitForMessageReady(client, localId, {
+		waitMs: deps.idleWaitMs ?? DEFAULT_IDLE_WAIT_MS,
+		now,
+		sleep: sleep$2,
+		signal
+	});
+	if (!readyResult.ready && isHardNotReady(readyResult.readiness.reason)) return {
+		submitted: false,
+		delivered: false,
+		settled: "timeout",
+		state: notReadyState(readyResult.readiness.reason),
+		raw: "",
+		reportFound: false,
+		interrupted: false,
+		recovered: false,
+		notReady: true,
+		readiness: readyResult.readiness,
+		error: "not_ready"
+	};
+	let cursor = await primeTurnCursor(client, localId, deps.primeTimeoutMs ?? DEFAULT_PRIME_TIMEOUT_MS, signal);
+	const cursorPrimed = cursor !== void 0;
+	const message = expectReport ? `${prompt}\n${operatorReportInstruction(reportId)}` : prompt;
+	const send = await client.sendMessage(localId, {
+		message,
+		idempotencyKey,
+		awaitMs: 0
+	}, signal);
+	const submitted = send.submission?.status === "submitted";
+	if (send.delivered === false || send.delivery?.status === "failed" || send.delivery?.status === "error") return {
+		submitted: false,
+		delivered: false,
+		settled: "timeout",
+		state: "send_failed",
+		raw: "",
+		reportFound: false,
+		interrupted: false,
+		recovered: false,
+		cursorPrimed,
+		sendConfirmation: send.confirmation,
+		error: "delivery_failed"
+	};
+	let settle = await waitForTurnSettled(client, localId, {
+		timeoutMs,
+		pollTimeoutMs,
+		cursor,
+		now,
+		sleep: sleep$2,
+		signal
+	});
+	cursor = settle.cursor;
+	const isCurrentReport = (r) => expectReport && r.found && r.reportId !== void 0 && r.reportId === reportId;
+	let tail = signal?.aborted ? "" : await readTail(client, localId, tailLines, signal);
+	let report = parseOperatorReport(tail);
+	let interrupted = false;
+	let recovered = false;
+	const aborted = settle.reason === "aborted" || signal?.aborted === true;
+	if (!settle.settled && !aborted) {
+		interrupted = true;
+		await client.sendKeys(localId, {
+			keys: INTERRUPT_KEY,
+			idempotencyKey: interruptKey,
+			raw: false
+		}, signal).catch(() => {});
+		const recovery = await waitForTurnSettled(client, localId, {
+			timeoutMs: deps.recoverTimeoutMs ?? DEFAULT_RECOVER_MS,
+			pollTimeoutMs,
+			cursor,
+			now,
+			sleep: sleep$2,
+			signal
+		});
+		recovered = recovery.settled;
+		if (recovery.settled) settle = recovery;
+		const recoveredTail = await readTail(client, localId, tailLines, signal);
+		const recoveredReport = parseOperatorReport(recoveredTail);
+		if (recoveredTail !== "" && (isCurrentReport(recoveredReport) || !isCurrentReport(report))) {
+			tail = recoveredTail;
+			report = recoveredReport;
+		}
+	}
+	const settledReason = settle.settled ? settle.reason : settle.reason === "aborted" || signal?.aborted === true ? "aborted" : "timeout";
+	const settleDerivedState = settledReason === "waiting_input" ? "awaiting_input" : settledReason === "aborted" ? "aborted" : settledReason === "timeout" ? "timeout" : "unknown";
+	const reportCurrent = isCurrentReport(report);
+	return {
+		submitted,
+		delivered: true,
+		settled: settledReason,
+		state: settledReason === "waiting_input" ? "awaiting_input" : reportCurrent && report.state !== "unknown" ? report.state : settleDerivedState,
+		summary: reportCurrent ? report.summary : void 0,
+		ask: reportCurrent ? report.ask : void 0,
+		artifact: reportCurrent ? report.artifact : void 0,
+		raw: tail,
+		reportFound: reportCurrent,
+		interrupted,
+		recovered,
+		cursorPrimed,
+		sendConfirmation: send.confirmation
+	};
+}
+
 //#endregion
 //#region src/lib/fleet/tools.ts
 const FLEET_GROUP = "fleet";
@@ -2681,6 +3439,7 @@ const INSTANCE_PROBE_CACHE_TTL_MS = 5e3;
 const CAPABILITIES_CACHE_TTL_MS = 6e4;
 const AWAIT_TURN_DEFAULT_TIMEOUT_MS = 3e4;
 const AWAIT_TURN_TIMEOUT_SLACK_MS = 5e3;
+const DRIVE_TASK_DEFAULT_TIMEOUT_MS = 12e4;
 const LIST_INSTANCES_FANOUT_CONCURRENCY = 16;
 const AWAIT_TURN_FANOUT_CONCURRENCY = 256;
 const INSTANCE_PROBE_RATE_LIMIT_MAX_RETRIES = 1;
@@ -2874,22 +3633,47 @@ function createFleetTools(options = {}) {
 				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$1({
+		tool$1("send_message", "Send a message to a fleet session. By DEFAULT it first checks the session is idle / awaiting the next message and REFUSES (structured notReady, isError) rather than blind-type into a busy composer or a pending prompt — set requireIdle:false to force the legacy unconditional send, or waitForIdleMs to wait briefly for idle first. isError reflects DELIVERY: true when the message was not delivered (transport/precondition failure) OR refused as notReady. A delivered message whose confirmation did not arrive within awaitMs is NOT an error — it returns delivered:true with confirmationPending/confirmationTimedOut, because a long turn legitimately outruns awaitMs. The additive `submitted` field is true only when ai-or-die's submission sub-status proves the message reached the composer. Recommended pattern: send with awaitMs:0 for a fast delivery ack, then call await_turn (filtered to this sessionId) to observe the session's actual turn completion. The idempotencyKey makes a retried send safe (a retry never re-types the message).", objectSchema$1({
 			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.")
+			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."),
+			requireIdle: booleanProp("Default true: check status and refuse a busy/awaiting-prompt/dead session with a structured notReady result. Set false to force an unconditional send (unsafe: may type into a busy composer)."),
+			waitForIdleMs: numberProp$1("When requireIdle, wait up to this many ms for the session to become idle before deciding (default 0 = decide immediately).")
 		}, ["sessionId", "message"]), async (args, signal) => {
 			const { instance, localId, globalId } = await resolveSession(args);
 			const awaitMs = optionalNumber$1(args, "awaitMs");
-			const response = await clientFor(instance).sendMessage(localId, {
+			const requireIdle = optionalBoolean(args, "requireIdle") ?? true;
+			const client = clientFor(instance);
+			if (requireIdle) {
+				const readyResult = await waitForMessageReady(client, localId, {
+					waitMs: optionalNumber$1(args, "waitForIdleMs") ?? 0,
+					signal
+				});
+				if (!readyResult.ready && isHardNotReady(readyResult.readiness.reason)) {
+					const advise = readyResult.readiness.reason === "awaiting_other" ? " The session is awaiting a prompt — use `respond`, not a free-text message." : readyResult.readiness.reason === "terminal" ? " The session has exited." : " Wait for it to go idle (await_turn) or set requireIdle:false to force.";
+					return jsonResult$1({
+						resolvedInstance: publicInstance(instance),
+						sessionId: globalId,
+						delivered: false,
+						submitted: false,
+						notReady: true,
+						reason: readyResult.readiness.reason,
+						interactionState: readyResult.readiness.interactionState,
+						awaitingKind: readyResult.readiness.awaitingKind,
+						message: `not sent: session is not ready for a message (${readyResult.readiness.reason}).${advise}`
+					}, true);
+				}
+			}
+			const response = await client.sendMessage(localId, {
 				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 submitted = delivered && response.submission?.status === "submitted";
 			const confirmationTimedOut = delivered && !confirmed && (awaitMs !== void 0 && awaitMs > 0 || response.confirmationTimedOut === true);
 			const isError = !delivered;
 			return jsonResult$1({
@@ -2898,6 +3682,7 @@ function createFleetTools(options = {}) {
 				...response,
 				delivered,
 				confirmed,
+				submitted,
 				...confirmationTimedOut ? {
 					confirmationPending: true,
 					confirmationTimedOut: true
@@ -2905,23 +3690,41 @@ 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$1({
+		tool$1("send_keys", "Send key input to a fleet session. Prefer the higher-level `op`: 'submit' presses Enter and 'interrupt' sends Ctrl-C, each mapped to ai-or-die's NAMED key (never a literal control byte like \"\\r\"). Use `keys` only for literal input; `raw` is strictly for literal bytes. Provide exactly one of `op` or `keys`.", objectSchema$1({
 			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."),
+			op: stringProp$1("Higher-level named op: 'submit' (Enter) or 'interrupt' (Ctrl-C). Mapped to the ai-or-die named key with raw off. Do NOT also pass keys."),
+			keys: stringProp$1("Literal key sequence to send. Provide instead of op."),
 			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) => {
+			raw: booleanProp("Pass keys through as raw literal bytes when the instance supports it. Ignored when op is set.")
+		}, ["sessionId"]), async (args, signal) => {
 			const { instance, localId, globalId } = await resolveSession(args);
-			const raw = optionalBoolean(args, "raw");
+			const op = optionalString$1(args, "op");
+			const literalKeys = optionalString$1(args, "keys");
+			if (op !== void 0 && literalKeys !== void 0) throw new FleetToolInputError("INVALID_ARGUMENT", "provide either arguments.op or arguments.keys, not both");
+			if (op === void 0 && literalKeys === void 0) throw new FleetToolInputError("INVALID_ARGUMENT", "one of arguments.op or arguments.keys is required");
+			let keys;
+			let raw;
+			if (op !== void 0) {
+				if (!isNamedKeyOp(op)) throw new FleetToolInputError("INVALID_ARGUMENT", `arguments.op must be 'submit' or 'interrupt' (got ${JSON.stringify(op)})`);
+				keys = mapNamedKeyOp(op);
+				raw = false;
+			} else {
+				keys = literalKeys;
+				raw = optionalBoolean(args, "raw");
+			}
 			const response = await clientFor(instance).sendKeys(localId, {
-				keys: requiredString$1(args, "keys"),
+				keys,
 				idempotencyKey: optionalString$1(args, "idempotencyKey") ?? randomUUID(),
 				...raw === void 0 ? {} : { raw }
 			}, signal);
 			return ok$1({
 				resolvedInstance: publicInstance(instance),
 				sessionId: globalId,
+				...op === void 0 ? {} : {
+					op,
+					mappedKeys: keys
+				},
 				...response
 			});
 		}),
@@ -2956,15 +3759,18 @@ function createFleetTools(options = {}) {
 			start: booleanProp("Whether the remote instance should start the session immediately."),
 			readyTimeoutMs: numberProp$1("F17: bounded ms to wait for the agent to become driveable before returning. The response carries ready/bound/blocker."),
 			permissionMode: stringProp$1("F10 (claude only): permission mode the launched agent starts in — one of plan | acceptEdits | default | bypassPermissions. Rejected with BAD_REQUEST if unknown or if agentArgs also sets it."),
-			agentArgs: arrayProp("F10 (claude only): extra launcher args appended after the github-router prefix. Must NOT include --permission-mode or --dangerously-skip-permissions (use permissionMode) — rejected with BAD_REQUEST.")
+			agentArgs: arrayProp("F10 (claude only): extra launcher args appended after the github-router prefix. Must NOT include --permission-mode or --dangerously-skip-permissions (use permissionMode) — rejected with BAD_REQUEST."),
+			disableStopGate: booleanProp("C3 (claude only): disable the structural Stop-gate on the launched session by injecting --no-stop-gate into agentArgs, so a driven session's turn-end never hangs on a blocking Stop hook. Requires a remote github-router that understands the flag (uses the agent_args capability).")
 		}, ["instance", "agent"]), async (args, signal) => {
 			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");
+			const disableStopGate = optionalBoolean(args, "disableStopGate") === true;
+			const requestedAgentArgs = optionalStringArray(args, "agentArgs");
+			const agentArgs = disableStopGate ? [...requestedAgentArgs ?? [], "--no-stop-gate"] : requestedAgentArgs;
 			if (permissionMode !== void 0) await assertCapability(instance, "permission_mode", "permissionMode", signal);
-			if (agentArgs !== void 0) await assertCapability(instance, "agent_args", "agentArgs", signal);
+			if (agentArgs !== void 0) await assertCapability(instance, "agent_args", disableStopGate ? "disableStopGate" : "agentArgs", signal);
 			const response = await clientFor(instance).createSession(definedObject({
 				agent,
 				name: optionalString$1(args, "name"),
@@ -3052,10 +3858,12 @@ function createFleetTools(options = {}) {
 				instance: publicInstance(instance),
 				...gap
 			})));
+			const settled = classifyTurnEvents(events$1);
 			return ok$1({
 				resolvedInstances: target.instances.map(publicInstance),
 				events: events$1,
 				gaps,
+				...settled.length > 0 ? { settled } : {},
 				cursors: responses.map(({ instance, response }) => ({
 					instance: publicInstance(instance),
 					cursor: response.cursor
@@ -3064,6 +3872,31 @@ function createFleetTools(options = {}) {
 				...errors.length > 0 ? { errors } : {}
 			});
 		}),
+		tool$1("drive_task", "Drive one prompt on a session to completion and return the parsed operator report. Composes the reliable path: ensure the composer is idle (else return a structured busy/not-ready result), send and surface whether the message reached the composer (submitted; a delivered-but-unconfirmed send still proceeds), wait for the RELIABLE turn boundary (turn_ended / waiting_input — never the became_idle flicker), read the transcript tail, and parse the OPERATOR REPORT trailer into {state, summary, ask, artifact, raw}. A per-call REPORT_ID nonce is embedded in the trailer instruction and the parsed report is trusted ONLY when it echoes that nonce, so a stale prior-turn trailer left in the tail can never be returned as this turn's result. A reliable waiting_input outranks the model's self-reported STATE (a still-blocked session is never reported as done). If the turn does not end within timeoutMs (e.g. a blocking Stop hook that would otherwise hang ~10 min), it AUTO-RECOVERS with a Ctrl-C interrupt rather than blocking, then re-waits briefly and re-reads; a caller ABORT is distinct (settled:'aborted', state:'aborted') and never injects a Ctrl-C. Read `state` TOGETHER with `settled`/`interrupted`/`recovered`: state:'done' with settled:'timeout' + interrupted:true means the model reported done but the turn had to be interrupted to recover, so treat it as needs-verification rather than a clean completion; `submitted` is a best-effort positive signal that CAN be false even on a successful turn. Robust to a busy session (state:'busy'), a missing/stale/placeholder trailer (state falls back to the settle-derived value, reportFound:false), and a hung hook (interrupted:true, recovered:true/false). By default it appends the trailer instruction so the driven session emits a parseable report; set expectReport:false to send the prompt verbatim (a trailer left in the tail is then never trusted).", objectSchema$1({
+			sessionId: stringProp$1("Global session id in the form instanceId:localSessionId."),
+			instance: stringProp$1("Optional instance id/label; when supplied it must agree with sessionId."),
+			prompt: stringProp$1("The task/prompt to drive on the session."),
+			timeoutMs: numberProp$1(`Ms to wait for the turn to end before auto-recovering via interrupt (default ${DRIVE_TASK_DEFAULT_TIMEOUT_MS}). Set generously — exceeding it triggers a Ctrl-C recovery.`),
+			expectReport: booleanProp("Default true: append the OPERATOR REPORT trailer instruction so the driven session ends its turn with a parseable {state,summary,ask,artifact}. Set false to send the prompt verbatim.")
+		}, ["sessionId", "prompt"]), async (args, signal) => {
+			const { instance, localId, globalId } = await resolveSession(args);
+			const result = await driveTask({
+				client: clientFor(instance),
+				localId,
+				prompt: requiredString$1(args, "prompt"),
+				timeoutMs: optionalNumber$1(args, "timeoutMs") ?? DRIVE_TASK_DEFAULT_TIMEOUT_MS,
+				expectReport: optionalBoolean(args, "expectReport") ?? true,
+				idempotencyKey: randomUUID(),
+				interruptKey: randomUUID(),
+				reportId: randomUUID(),
+				signal
+			});
+			return jsonResult$1({
+				resolvedInstance: publicInstance(instance),
+				sessionId: globalId,
+				...result
+			}, result.error !== void 0);
+		}),
 		tool$1("read_file", "Read a file from one fleet instance via its existing /api/files/content endpoint.", objectSchema$1({
 			instance: stringProp$1("Instance id or label. Defaults to the registry default, or the sole instance."),
 			path: stringProp$1("Remote file path to read.")
@@ -24305,6 +25138,16 @@ function stopGateId(env = process.env) {
 	const v = (env.GH_ROUTER_STOP_GATE_ID ?? "").trim();
 	return v.length > 0 ? v : "default-ci";
 }
+/**
+* C3: whether the structural Stop-gate is disabled for THIS launch. True when the
+* `GH_ROUTER_DISABLE_STOP_GATE` env is set OR the `--no-stop-gate` launcher flag was
+* passed (`args["no-stop-gate"] === true`). A DRIVEN session sets the flag so a
+* blocking Stop hook never hangs its turn-end (~10 min) waiting on the fleet driver.
+* Pure so it is unit-testable without the live launch path.
+*/
+function stopGateDisabled(args, env = process.env) {
+	return parseBoolEnv(env.GH_ROUTER_DISABLE_STOP_GATE) === true || args["no-stop-gate"] === true;
+}
 /** True when a settings `Stop` entry already registers `command` (so the merge
 *  is idempotent across re-launches). */
 function entryHasCommand(entry, command) {
@@ -26346,5 +27189,5 @@ async function runStandInToolCall(args, signal) {
 }
 
 //#endregion
-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
+export { logStreamError as $, copilotBaseUrl as $t, BROWSE_DEFAULT_MODEL as A, UPSTREAM_FETCH_TIMEOUT_MS as At, toolbeltEnabled as B, cacheCopilotVersion as Bt, repoFingerprint as C, ArtifactClient as Ct, trustRepo as D, DEFAULT_CODEX_MODEL as Dt, stopReviewStateDir as E, DEFAULT_CLAUDE_MODEL_FALLBACKS as Et, appendPlanReminder as F, withInstallLock as Ft, searchWeb as G, resolveCodexModel as Gt, vscodeRipgrepPath as H, cacheVSCodeVersion as Ht, runWorkerAgent as I, setupCopilotToken as It, buildAdvisorStream as J, getModels as Jt, ADVISOR_INTERNAL_TOOL_NAME as K, resolveModel as Kt, withNoOutputRetry as L, setupGitHubAgentToken as Lt, IMPLEMENT_DEFAULT_MODEL as M, generateRandomPort as Mt, PLAN_DEFAULT_MODEL as N, pickClaudeDefault as Nt, resolveSealedGate as O, DEFAULT_CODEX_MODEL_FALLBACKS as Ot, REVIEW_DEFAULT_MODEL as P, getPackageVersion as Pt, isControllerClosedError as Q, GITHUB_API_BASE_URL as Qt, availableToolCommands as R, setupGitHubToken as Rt, isSubagentContext as S, shouldUseInsecureTls as St, stopGateEnabledForRepo as T, toolbeltPathOverride as Tt, TOOLBELT_TOOLS$1 as U, filterBetaHeader as Ut, toolbeltSkipSet as V, cacheModels as Vt, assetFor as W, isNullish as Wt, isAdvisorRequested as X, HTTPError as Xt, injectAdvisorTool as Y, fetchWithTransientRetry as Yt, buildOpenAIErrorEvent as Z, forwardError as Zt, stopReviewEnabled as _, provisionBrowserAssets as _t, buildPeerAwarenessSnippet as a, browserToolsEnabled as at, fileLastPromptStore as b, extractTarGzMember as bt, buildSessionBindHookCommand as c, workerToolsEnabled as ct, decideStopHook as d, getTokenCount as dt, copilotHeaders as en, readIteratorWithTimeout as et, fileBlockBudget as f, createResponses as ft, stopGateId as g, parseJsonOrDiagnose as gt, stopGateDisabled as h, readResponseBodyCapped as ht, buildAgentPrompt as i, agentToolsEnabled as it, DEFAULT_MODEL as j, UPSTREAM_INACTIVITY_TIMEOUT_MS as jt, liveExec as k, DEFAULT_PORT as kt, buildStopHookCommand as l, countTokens as lt, launchBaselineKey as m, MAX_RESPONSE_BODY_BYTES as mt, MCP_GROUPS as n, state as nn, handleMcpDelete as nt, personasFor as o, fleetToolsEnabled as ot, injectStopHookIntoSettingsFile as p, createChatCompletions as pt, ADVISOR_TOOL_INSTRUCTIONS as q, sleep as qt, assertMcpToolSurfaceConsistent as r, handleMcpPost as rt, buildArtifactOpenHookCommand as s, standInToolEnabled as st, GROUP_META as t, githubHeaders as tn, relayAnthropicStream as tt, captureLaunchBaseline as u, createMessages as ut, fileBaselineStore as v, hasSupportedBrowserInstalled as vt, repoRoot as w, collapsePathKeys as wt, fileReviewDebounce as x, extractZipMember as xt, fileFindingsStore as y, provisionAndIndexColbert as yt, buildToolbeltAwareness as z, tryRefreshAndRetry as zt };
+//# sourceMappingURL=peer-mcp-personas-BQVOxB1i.js.map