@oh-my-pi/pi-coding-agent 17.1.0 → 17.1.2

package/src/slash-commands/builtin-registry.ts

@@ -33,6 +33,7 @@ import { theme } from "../modes/theme/theme";
 import type { InteractiveModeContext } from "../modes/types";
 import { extractLastCodeBlock, extractLastCommand } from "../modes/utils/copy-targets";
 import type { AgentSession, FreshSessionResult } from "../session/agent-session";
+import type { SessionOAuthAccountList } from "../session/agent-session-types";
 import { COMPACT_MODES, parseCompactArgs } from "../session/compact-modes";
 import { resolveResumableSession } from "../session/session-listing";
 import { formatShakeSummary, type ShakeMode } from "../session/shake-types";
@@ -52,6 +53,7 @@ import { createMarketplaceManager } from "./helpers/marketplace-manager";
 import { handleMcpAcp } from "./helpers/mcp";
 import { commandConsumed, errorMessage, parseSlashCommand, parseSubcommand, usage } from "./helpers/parse";
 import { describeRedeemOutcome, type ResetUsageAccount, toResetUsageAccounts } from "./helpers/reset-usage";
+import { matchSessionPinAccounts, toSessionPinAccounts } from "./helpers/session-pin";
 import { handleSshAcp } from "./helpers/ssh";
 import { launchStatsDashboard, parseStatsDashboardArgs } from "./helpers/stats-dashboard";
 import { handleTodoAcp } from "./helpers/todo";
@@ -88,6 +90,26 @@ function formatFastModeStatus(session: AgentSession): string {
 	return session.isFastModeEnabled() ? "on" : "off";
 }
 
+/** `/computer status` label for the session-effective `computer.enabled` value. */
+function formatComputerUseStatus(session: AgentSession): string {
+	return session.settings.get("computer.enabled") ? "on" : "off";
+}
+
+/**
+ * Apply a session-scoped computer-use toggle: flip the active tool slate first
+ * (so a failed enable never leaves a stale settings override), then record the
+ * runtime override — never `settings.set`, which would persist to settings.json.
+ * Returns the operator feedback line.
+ */
+async function applyComputerUseToggle(session: AgentSession, enable: boolean): Promise<string> {
+	const applied = await session.setComputerToolEnabled(enable);
+	if (enable && !applied) {
+		return "Computer use is unavailable in this session.";
+	}
+	session.settings.override("computer.enabled", enable);
+	return `Computer use ${enable ? "enabled" : "disabled"} for this session.`;
+}
+
 const AUTOCOMPLETE_DETAIL_LIMIT = 48;
 
 function shortDetail(value: string, limit = AUTOCOMPLETE_DETAIL_LIMIT): string {
@@ -196,6 +218,74 @@ async function handleUsageResetCommand(
 	await output(describeRedeemOutcome(outcome, target.label));
 }
 
+async function handleSessionPinCommand(
+	arg: string,
+	session: AgentSession,
+	output: SlashCommandRuntime["output"],
+): Promise<void> {
+	if (session.isStreaming) {
+		await output("Cannot pin an account while the session is streaming.");
+		return;
+	}
+	let accountList: SessionOAuthAccountList | undefined;
+	try {
+		accountList = await session.listCurrentProviderOAuthAccounts();
+	} catch (error) {
+		await output(`Could not load provider accounts: ${errorMessage(error)}`);
+		return;
+	}
+	if (!accountList) {
+		await output("Select a model before pinning a provider account.");
+		return;
+	}
+	const provider = getOAuthProviders().find(candidate => candidate.id === accountList.provider);
+	const providerName = provider?.name ?? accountList.provider;
+	const accounts = toSessionPinAccounts(accountList.accounts);
+	if (accounts.length === 0) {
+		const source = session.modelRegistry.authStorage.describeCredentialSource(
+			accountList.provider,
+			session.sessionId,
+		);
+		await output(
+			source
+				? `No stored OAuth accounts for ${providerName}. Current auth comes from ${source}.`
+				: `No stored OAuth accounts for ${providerName}. Use /login to add one.`,
+		);
+		return;
+	}
+
+	const selector = arg.trim();
+	if (!selector) {
+		const lines = [`OAuth accounts for ${providerName}:`];
+		for (const account of accounts) {
+			lines.push(`${account.position + 1}. ${account.label}${account.active ? " (active)" : ""}`);
+		}
+		lines.push("", "Pin one with `/session pin <number|email|account id>`.");
+		await output(lines.join("\n"));
+		return;
+	}
+
+	const matches = matchSessionPinAccounts(accounts, selector);
+	if (matches.length === 0) {
+		await output(`No ${providerName} account matches "${selector}".`);
+		return;
+	}
+	if (matches.length > 1) {
+		await output(
+			`"${selector}" matches multiple ${providerName} accounts: ${matches
+				.map(account => `${account.position + 1}. ${account.label}`)
+				.join(", ")}. Use the account number.`,
+		);
+		return;
+	}
+	const account = matches[0];
+	if (!account || !session.pinCurrentProviderOAuthAccount(account.credentialId)) {
+		await output(`${account?.label ?? selector} is no longer available to pin.`);
+		return;
+	}
+	await output(`Pinned ${account.label} to this session for ${providerName}.`);
+}
+
 /** Parse the `/shake` subcommand into a {@link ShakeMode}; empty defaults to elide. */
 function parseShakeMode(args: string): ShakeMode | { error: string } {
 	const verb = args.trim().toLowerCase();
@@ -472,6 +562,49 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "computer",
+		description: "Toggle the native computer-use tool for this session",
+		acpDescription: "Toggle computer use",
+		acpInputHint: "[on|off|status]",
+		subcommands: [
+			{ name: "on", description: "Enable computer use for this session" },
+			{ name: "off", description: "Disable computer use for this session" },
+			{ name: "status", description: "Show computer use status" },
+		],
+		allowArgs: true,
+		getTuiAutocompleteDescription: runtime => `Computer: ${formatComputerUseStatus(runtime.ctx.session)}`,
+		handle: async (command, runtime) => {
+			const arg = command.args.trim().toLowerCase();
+			if (arg === "status") {
+				await runtime.output(`Computer use is ${formatComputerUseStatus(runtime.session)}.`);
+				return commandConsumed();
+			}
+			if (!arg || arg === "toggle" || arg === "on" || arg === "off") {
+				const enable = arg === "off" ? false : arg === "on" || !runtime.session.settings.get("computer.enabled");
+				await runtime.output(await applyComputerUseToggle(runtime.session, enable));
+				return commandConsumed();
+			}
+			return usage("Usage: /computer [on|off|status]", runtime);
+		},
+		handleTui: async (command, runtime) => {
+			const arg = command.args.trim().toLowerCase();
+			if (arg === "status") {
+				runtime.ctx.showStatus(`Computer use is ${formatComputerUseStatus(runtime.ctx.session)}.`);
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			if (!arg || arg === "toggle" || arg === "on" || arg === "off") {
+				const enable =
+					arg === "off" ? false : arg === "on" || !runtime.ctx.session.settings.get("computer.enabled");
+				runtime.ctx.showStatus(await applyComputerUseToggle(runtime.ctx.session, enable));
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			runtime.ctx.showStatus("Usage: /computer [on|off|status]");
+			runtime.ctx.editor.setText("");
+		},
+	},
 	{
 		name: "prewalk",
 		description: "Switch to a fast/cheap model at the next action (works even without --prewalk)",
@@ -981,15 +1114,21 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	{
 		name: "session",
 		description: "Session management commands",
-		acpDescription: "Show session information",
-		acpInputHint: "info|delete",
+		acpDescription: "Show or configure the current session",
+		acpInputHint: "[info|delete|pin [account]]",
 		subcommands: [
 			{ name: "info", description: "Show session info and stats" },
 			{ name: "delete", description: "Delete current session and return to selector" },
+			{
+				name: "pin",
+				description: "Pin the current provider to a stored OAuth account",
+				usage: "[account]",
+			},
 		],
 		allowArgs: true,
 		handle: async (command, runtime) => {
-			if (!command.args || command.args === "info") {
+			const { verb, rest } = parseSubcommand(command.args);
+			if (!verb || (verb === "info" && !rest)) {
 				await runtime.output(
 					[
 						`Session: ${runtime.session.sessionId}`,
@@ -999,7 +1138,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 				);
 				return commandConsumed();
 			}
-			if (command.args === "delete") {
+			if (verb === "delete" && !rest) {
 				if (runtime.session.isStreaming) return usage("Cannot delete the session while streaming.", runtime);
 				const sessionFile = runtime.sessionManager.getSessionFile();
 				if (!sessionFile) return usage("No session file to delete (in-memory session).", runtime);
@@ -1018,17 +1157,34 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 				);
 				return commandConsumed();
 			}
-			return usage("Usage: /session [info|delete]", runtime);
+			if (verb === "pin") {
+				await handleSessionPinCommand(rest, runtime.session, runtime.output);
+				return commandConsumed();
+			}
+			return usage("Usage: /session [info|delete|pin [account]]", runtime);
 		},
 		handleTui: async (command, runtime) => {
-			const sub = command.args.trim().toLowerCase() || "info";
-			if (sub === "delete") {
+			const { verb, rest } = parseSubcommand(command.args);
+			if (verb === "delete" && !rest) {
 				runtime.ctx.editor.setText("");
 				await runtime.ctx.handleSessionDeleteCommand();
 				return;
 			}
-			// Default: show session info
-			await runtime.ctx.handleSessionCommand();
+			if (verb === "pin") {
+				if (rest) {
+					await handleSessionPinCommand(rest, runtime.ctx.session, text => runtime.ctx.showStatus(text));
+					refreshStatusLine(runtime.ctx);
+				} else {
+					await runtime.ctx.showSessionPinSelector();
+				}
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			if (!verb || (verb === "info" && !rest)) {
+				await runtime.ctx.handleSessionCommand();
+			} else {
+				runtime.ctx.showStatus("Usage: /session [info|delete|pin [account]]");
+			}
 			runtime.ctx.editor.setText("");
 		},
 	},

package/src/slash-commands/helpers/session-pin.ts

@@ -0,0 +1,44 @@
+import type { OAuthAccountSummary } from "../../session/auth-storage";
+import { formatActiveAccountLabel } from "./active-oauth-account";
+
+/** Stored OAuth account rendered and matched by `/session pin`. */
+export interface SessionPinAccount extends OAuthAccountSummary {
+	label: string;
+}
+
+/** Add stable user-facing labels to provider account summaries. */
+export function toSessionPinAccounts(accounts: readonly OAuthAccountSummary[]): SessionPinAccount[] {
+	return accounts.map(account => {
+		const enterpriseUrl = account.enterpriseUrl?.trim();
+		return {
+			...account,
+			label: (formatActiveAccountLabel(account) ?? enterpriseUrl) || `OAuth credential #${account.credentialId}`,
+		};
+	});
+}
+
+/** Match a `/session pin` selector by 1-based position or exact account identity. */
+export function matchSessionPinAccounts(accounts: readonly SessionPinAccount[], selector: string): SessionPinAccount[] {
+	const wanted = selector.trim().toLowerCase();
+	if (!wanted) return [];
+	if (wanted === "active") return accounts.filter(account => account.active);
+
+	if (/^\d+$/.test(wanted)) {
+		const position = Number(wanted) - 1;
+		const positioned = accounts.find(account => account.position === position);
+		if (positioned) return [positioned];
+	}
+
+	return accounts.filter(account =>
+		[
+			account.label,
+			account.email,
+			account.accountId,
+			account.projectId,
+			account.enterpriseUrl,
+			account.orgId,
+			account.orgName,
+			`OAuth credential #${account.credentialId}`,
+		].some(value => value?.trim().toLowerCase() === wanted),
+	);
+}

package/src/stt/downloader.ts

@@ -4,7 +4,6 @@ import { getTinyModelsCacheDir } from "@oh-my-pi/pi-utils";
 import { sttClient } from "./asr-client";
 import type { SttProgressStatus } from "./asr-protocol";
 import { resolveSttModelSpec } from "./models";
-import { ensureRecorder } from "./recorder";
 
 export interface DownloadProgress {
 	stage: string;
@@ -129,7 +128,6 @@ export async function downloadSttModel(
 // ── Public API ─────────────────────────────────────────────────────
 
 export async function ensureSTTDependencies(options?: EnsureOptions): Promise<void> {
-	await ensureRecorder(progress => options?.onProgress?.(progress), options?.signal);
 	await downloadSttModel(
 		resolveSttModelSpec(options?.modelName).key,
 		progress => {

package/src/stt/index.ts

@@ -4,5 +4,3 @@ export * from "./downloader";
 export * from "./models";
 export * from "./stt-controller";
 export * from "./submit-trigger";
-export * from "./transcriber";
-export * from "./wav";

package/src/stt/stt-controller.ts

@@ -1,22 +1,10 @@
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { logger, Snowflake } from "@oh-my-pi/pi-utils";
+import { AudioCapture } from "@oh-my-pi/pi-natives";
+import { logger } from "@oh-my-pi/pi-utils";
 import { settings } from "../config/settings";
 import { type SttStreamHandle, sttClient } from "./asr-client";
 import { downloadSttModel, isSttModelCached } from "./downloader";
 import { resolveSttModelSpec } from "./models";
-import {
-	detectRecorder,
-	ensureRecorder,
-	type RecordingHandle,
-	type StreamingRecordingHandle,
-	startRecording,
-	startStreamingRecording,
-	verifyRecordingFile,
-} from "./recorder";
 import { evaluateSubmitTrigger } from "./submit-trigger";
-import { transcribe } from "./transcriber";
 
 export type SttState = "idle" | "recording" | "transcribing";
 
@@ -38,26 +26,34 @@ interface Editor {
 	deleteBeforeCursor(count: number): void;
 }
 
+interface CaptureHandle {
+	stop(): void;
+}
+
+type CaptureFactory = (onAudio: (error: Error | null, samples: Float32Array) => void) => CaptureHandle;
+
+/** Coordinates native microphone capture with incremental local transcription. */
 export class STTController {
 	#state: SttState = "idle";
 	#resolvedModelKey: string | null = null;
 	#toggling = false;
 	#stopAfterStart = false;
 	#disposed = false;
-
-	// Batch (single-shot) capture.
-	#recordingHandle: RecordingHandle | null = null;
-	#tempFile: string | null = null;
-	#transcriptionAbort: AbortController | null = null;
+	readonly #createCapture: CaptureFactory;
 
 	// Live streaming capture.
 	#stream: SttStreamHandle | null = null;
-	#streamRecorder: StreamingRecordingHandle | null = null;
+	#streamRecorder: CaptureHandle | null = null;
 	#streamEditor: Editor | null = null;
 	#streamCommitted = false;
 	#streamAbort: AbortController | null = null;
 	#streamUtterance = "";
 
+	/** Creates a controller; tests may replace the hardware capture boundary. */
+	constructor(createCapture: CaptureFactory = onAudio => new AudioCapture(16_000, onAudio)) {
+		this.#createCapture = createCapture;
+	}
+
 	get state(): SttState {
 		return this.#state;
 	}
@@ -79,7 +75,7 @@ export class STTController {
 					await this.#start(editor, options);
 					break;
 				case "recording":
-					await this.#stop(editor, options);
+					await this.#stop(options);
 					break;
 				case "transcribing":
 					options.showStatus("Transcription in progress...");
@@ -87,7 +83,7 @@ export class STTController {
 			}
 			if (this.#stopAfterStart && this.#state === "recording") {
 				this.#stopAfterStart = false;
-				await this.#stop(editor, options);
+				await this.#stop(options);
 			} else if (this.#state !== "recording") {
 				this.#stopAfterStart = false;
 			}
@@ -103,19 +99,13 @@ export class STTController {
 		// (with progress) instead of blocking silently at stop.
 		if (this.#resolvedModelKey === modelKey) return true;
 		try {
-			// Only clear the status line if we actually wrote to it: the cached
-			// fast path (recorder on PATH, model present) emits nothing, so an
-			// unconditional clear would be a stray write.
+			// Only clear the status line when preflight emitted progress; the
+			// cached-model fast path emits nothing.
 			let wroteStatus = false;
 			const status = (msg: string): void => {
 				wroteStatus = true;
 				options.showStatus(msg);
 			};
-			// A recorder is required to capture audio; startRecording /
-			// startStreamingRecording only *detect* a recorder and throw when none
-			// exists, so provision one here. Instant when sox/ffmpeg/arecord is on
-			// PATH — only a first-run static-ffmpeg download actually blocks.
-			await ensureRecorder(p => status(p.stage + (p.percent != null ? ` (${p.percent}%)` : "")));
 			// Loading the multi-hundred-MB speech model into the worker is what made
 			// the old "Checking STT dependencies…" step slow. Don't pay it before
 			// recording: when the weights are already cached, start now and warm the
@@ -157,30 +147,15 @@ export class STTController {
 
 	async #start(editor: Editor, options: ToggleOptions): Promise<void> {
 		if (!(await this.#ensureDeps(options))) return;
-		// Live transcription needs a recorder that can pipe PCM; the Windows
-		// PowerShell mci fallback records to a file, so it stays single-shot.
-		if (this.#recorderCanStream()) {
-			await this.#startStreaming(editor, options);
-			return;
-		}
-		await this.#startBatchRecording(options);
+		await this.#startStreaming(editor, options);
 	}
 
-	async #stop(editor: Editor, options: ToggleOptions): Promise<void> {
-		if (this.#stream) {
-			await this.#stopStreaming(options);
-			return;
-		}
-		await this.#stopBatch(editor, options);
+	async #stop(options: ToggleOptions): Promise<void> {
+		await this.#stopStreaming(options);
 	}
 
 	// ── Live streaming ──────────────────────────────────────────────
 
-	#recorderCanStream(): boolean {
-		const recorder = detectRecorder();
-		return recorder !== null && recorder.tool !== "powershell";
-	}
-
 	/** Segment text gets a leading space once a prior segment is committed, so
 	 *  phrases join naturally; the first phrase is inserted at the cursor as-is. */
 	#prefixed(text: string): string {
@@ -218,18 +193,38 @@ export class STTController {
 			},
 		});
 		this.#stream = stream;
-		let recorder: StreamingRecordingHandle | null = null;
+		let recorder: CaptureHandle;
 		try {
-			recorder = await startStreamingRecording(samples => stream.pushAudio(samples));
-		} catch (err) {
-			logger.warn("STT streaming recorder failed to start; falling back to batch recording", {
-				error: err instanceof Error ? err.message : String(err),
+			recorder = this.#createCapture((error, samples) => {
+				if (this.#disposed || this.#stream !== stream || this.#state !== "recording") return;
+				if (error) {
+					logger.error("Native microphone capture failed", { error: error.message });
+					const activeRecorder = this.#streamRecorder;
+					this.#streamRecorder = null;
+					try {
+						activeRecorder?.stop();
+					} catch (cause) {
+						logger.debug("stt: microphone cleanup failed", {
+							error: cause instanceof Error ? cause.message : String(cause),
+						});
+					}
+					this.#streamAbort?.abort(error);
+					stream.cancel();
+					this.#streamEditor?.clearVolatileText();
+					options.requestRender?.();
+					this.#cleanupStream();
+					this.#setState("idle", options);
+					options.showWarning(error.message);
+					return;
+				}
+				stream.pushAudio(samples);
 			});
-		}
-		if (!recorder) {
+		} catch (err) {
 			stream.cancel();
 			this.#cleanupStream();
-			await this.#startBatchRecording(options);
+			const msg = err instanceof Error ? err.message : "Failed to start microphone capture";
+			options.showWarning(msg);
+			logger.error("STT recording failed to start", { error: msg });
 			return;
 		}
 		this.#streamRecorder = recorder;
@@ -247,7 +242,7 @@ export class STTController {
 		this.#setState("transcribing", options);
 		// Stop the mic first so no further audio is fed, then flush the worker.
 		try {
-			await recorder?.stop();
+			recorder?.stop();
 		} catch (err) {
 			logger.debug("stt: streaming recorder stop failed", {
 				error: err instanceof Error ? err.message : String(err),
@@ -306,103 +301,19 @@ export class STTController {
 		this.#streamUtterance = "";
 	}
 
-	// ── Batch (single-shot) ─────────────────────────────────────────
-
-	async #startBatchRecording(options: ToggleOptions): Promise<void> {
-		const id = Snowflake.next();
-		this.#tempFile = path.join(os.tmpdir(), `omp-stt-${id}.wav`);
-		try {
-			this.#recordingHandle = await startRecording(this.#tempFile);
-			this.#setState("recording", options);
-			logger.debug("STT recording started", { tempFile: this.#tempFile });
-		} catch (err) {
-			this.#tempFile = null;
-			const msg = err instanceof Error ? err.message : "Failed to start recording";
-			options.showWarning(msg);
-			logger.error("STT recording failed to start", { error: msg });
-		}
-	}
-
-	async #stopBatch(editor: Editor, options: ToggleOptions): Promise<void> {
-		const handle = this.#recordingHandle;
-		const tempFile = this.#tempFile;
-		this.#recordingHandle = null;
-
-		if (!handle || !tempFile) {
-			this.#setState("idle", options);
-			return;
-		}
-
-		try {
-			await handle.stop();
-			// Validate the recording produced a usable file
-			await verifyRecordingFile(tempFile);
-			this.#setState("transcribing", options);
-
-			const sttSettings = {
-				modelName: settings.get("stt.modelName") as string | undefined,
-				language: settings.get("stt.language") as string | undefined,
-			};
-			this.#transcriptionAbort = new AbortController();
-			const text = await transcribe(tempFile, { ...sttSettings, signal: this.#transcriptionAbort.signal });
-			this.#transcriptionAbort = null;
-			if (this.#disposed) return;
-			if (text.length > 0) {
-				const trigger = settings.get("stt.submitTrigger");
-				const { submit, trimTrailing } = evaluateSubmitTrigger(text, trigger);
-				const textToInsert = trimTrailing > 0 ? text.slice(0, -trimTrailing) : text;
-				if (textToInsert.length > 0) {
-					editor.insertText(textToInsert);
-				}
-				options.showStatus("");
-				if (submit) {
-					editor.submit();
-				}
-			} else {
-				options.showStatus("No speech detected.");
-			}
-			if (!this.#disposed) this.#setState("idle", options);
-		} catch (err) {
-			if (this.#disposed) return;
-			if (err instanceof DOMException && err.name === "AbortError") {
-				this.#setState("idle", options);
-				return;
-			}
-			const msg = err instanceof Error ? err.message : "Transcription failed";
-			options.showWarning(msg);
-			logger.error("STT transcription failed", { error: msg });
-			this.#setState("idle", options);
-		} finally {
-			try {
-				await fs.rm(tempFile, { force: true });
-			} catch {
-				// best effort cleanup
-			}
-			this.#tempFile = null;
-		}
-	}
-
 	dispose(): void {
 		this.#disposed = true;
-		if (this.#transcriptionAbort) {
-			this.#transcriptionAbort.abort();
-			this.#transcriptionAbort = null;
-		}
 		if (this.#streamAbort) {
 			this.#streamAbort.abort();
 			this.#streamAbort = null;
 		}
 		this.#stream?.cancel();
-		this.#streamRecorder?.stop().catch(() => {});
-		this.#cleanupStream();
-		if (this.#recordingHandle) {
-			this.#recordingHandle.stop().catch(() => {});
-			this.#recordingHandle = null;
-		}
-		if (this.#tempFile) {
-			fs.rm(this.#tempFile, { force: true }).catch(() => {});
-			this.#tempFile = null;
+		try {
+			this.#streamRecorder?.stop();
+		} catch {
+			// best effort cleanup
 		}
+		this.#cleanupStream();
 		this.#state = "idle";
 		this.#resolvedModelKey = null;
 	}

package/src/system-prompt.ts

@@ -17,6 +17,7 @@ import { expandAtImports } from "./discovery/at-imports";
 import { loadSkills, type Skill } from "./extensibility/skills";
 import { hasObsidian } from "./internal-urls/vault-protocol";
 import activeRepoContextTemplate from "./prompts/system/active-repo-context.md" with { type: "text" };
+import computerSafetyPrompt from "./prompts/system/computer-safety.md" with { type: "text" };
 import customSystemPromptTemplate from "./prompts/system/custom-system-prompt.md" with { type: "text" };
 import defaultPersonality from "./prompts/system/personalities/default.md" with { type: "text" };
 import friendlyPersonality from "./prompts/system/personalities/friendly.md" with { type: "text" };
@@ -839,6 +840,9 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 	};
 	const rendered = prompt.render(resolvedCustomPrompt ? customSystemPromptTemplate : systemPromptTemplate, data);
 	const systemPrompt = [rendered];
+	if (toolNames.includes("computer")) {
+		systemPrompt.push(computerSafetyPrompt.trim());
+	}
 	// Custom prompt templates already render context files and append text; the
 	// project footer still carries environment, cwd, workspace, and dir-context.
 	const projectPrompt = prompt

package/src/task/executor.ts

@@ -46,7 +46,7 @@ import type { AuthStorage } from "../session/auth-storage";
 import { SKILL_PROMPT_MESSAGE_TYPE, USER_INTERRUPT_LABEL } from "../session/messages";
 import { SessionManager } from "../session/session-manager";
 import { truncateTail } from "../session/streaming-output";
-import type { ConfiguredThinkingLevel } from "../thinking";
+import { type ConfiguredThinkingLevel, resolveTaskEffortLevel, type TaskEffort } from "../thinking";
 import type { ContextFileEntry, ToolSession } from "../tools";
 import { resolveEvalBackends } from "../tools/eval-backends";
 import { isIrcEnabled } from "../tools/hub";
@@ -323,6 +323,8 @@ export interface ExecutorOptions {
 	 */
 	parentActiveModelPattern?: string;
 	thinkingLevel?: ConfiguredThinkingLevel;
+	/** Caller-requested coarse effort (`lo`/`med`/`hi`); maps onto the resolved model's supported thinking range and wins over {@link thinkingLevel}. */
+	effort?: TaskEffort;
 	/** Schema used to validate the final structured completion. */
 	outputSchema?: unknown;
 	/** Enforcement policy for {@link outputSchema}; defaults to legacy permissive behavior. */
@@ -2644,16 +2646,22 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			if (model?.contextWindow && model.contextWindow > 0) {
 				progress.contextWindow = model.contextWindow;
 			}
+			// Caller-requested coarse effort maps onto the resolved model's
+			// supported range; undefined (no effort, or no controllable effort
+			// surface) falls through to the normal selectors below.
+			const effortLevel = options.effort !== undefined ? resolveTaskEffortLevel(model, options.effort) : undefined;
 			if (model) {
-				progress.resolvedModel = explicitThinkingLevel
-					? formatModelSelectorValue(formatModelStringWithRouting(model), resolvedThinkingLevel)
-					: formatModelStringWithRouting(model);
+				const displayLevel = effortLevel ?? (explicitThinkingLevel ? resolvedThinkingLevel : undefined);
+				progress.resolvedModel =
+					displayLevel !== undefined
+						? formatModelSelectorValue(formatModelStringWithRouting(model), displayLevel)
+						: formatModelStringWithRouting(model);
 			}
-			// Precedence: explicit `:level` suffix on the resolved model pattern >
-			// agent-definition default (e.g. task's `auto`) > pattern-derived level.
-			const effectiveThinkingLevel = explicitThinkingLevel
-				? resolvedThinkingLevel
-				: (thinkingLevel ?? resolvedThinkingLevel);
+			// Precedence: caller `effort` > explicit `:level` suffix on the resolved
+			// model pattern > agent-definition default (e.g. task's `auto`) >
+			// pattern-derived level.
+			const effectiveThinkingLevel =
+				effortLevel ?? (explicitThinkingLevel ? resolvedThinkingLevel : (thinkingLevel ?? resolvedThinkingLevel));
 			resolvedAt = performance.now();
 			// Per-agent prewalk: the agent definition's `prewalk` frontmatter or the
 			// `task.agentPrewalk` settings override hands the subagent off to a