@oh-my-pi/pi-coding-agent 14.7.4 → 14.7.6

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 ## [Unreleased]
 
+## [14.7.6] - 2026-05-07
+### Changed
+
+- Changed the "Hide Thinking Blocks" setting (Ctrl+T) to also instruct the provider to omit thinking/reasoning summaries from responses, instead of just hiding them client-side. Anthropic sees `thinking.display = "omitted"` (where supported); OpenAI Responses / Azure / Codex requests drop `reasoning.summary` entirely.
+
+### Fixed
+
+- Fixed the `Hide Thinking Blocks` toggle so changing it updates the active session’s request settings immediately, ensuring new responses reflect the current hide-thinking preference
+- Fixed system prompt preparation to keep successful context data and only fall back to minimal defaults for preparation steps that fail
+- Fixed system prompt preparation timeout to apply per-step instead of all-or-nothing: a single slow step (e.g. `buildAgentsMdSearch` on a huge directory tree, `buildWorkspaceTree`, `loadProjectContextFiles`) now falls back to its own minimal default while the other steps still populate, and the warning names which steps timed out.
+- Fixed subagents re-running expensive workspace scans (`buildAgentsMdSearch`, `buildWorkspaceTree`) on every spawn: parents now forward their already-resolved `AGENTS.md` search and workspace tree to subagents through `createAgentSession`, matching how `contextFiles`, `skills`, and `promptTemplates` are already inherited. On large monorepos this removes seconds of redundant work per `task` invocation and prevents the per-subagent system-prompt timeout warnings.
+
+## [14.7.5] - 2026-05-07
+### Added
+
+- Added optional `/loop` limits: `/loop 10` stops after 10 auto-iterations, while duration forms such as `/loop 10m` and `/loop 10min` stop after the time limit.
+
+### Changed
+
+- Changed `/loop` to include the configured limit and remaining budget in the enabled status message
+
+### Fixed
+
+- Fixed `/loop` handling of malformed count or duration arguments by showing usage errors instead of enabling unbounded loop mode
+- Fixed inherited disabled macOS malloc stack logging variables leaking into shell sessions and spamming Bun subprocess output with `MallocStackLogging` warnings.
+
 ## [14.7.4] - 2026-05-07
 
 ### Breaking Changes

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "14.7.4",
+	"version": "14.7.6",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -46,12 +46,12 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/omp-stats": "14.7.4",
-		"@oh-my-pi/pi-agent-core": "14.7.4",
-		"@oh-my-pi/pi-ai": "14.7.4",
-		"@oh-my-pi/pi-natives": "14.7.4",
-		"@oh-my-pi/pi-tui": "14.7.4",
-		"@oh-my-pi/pi-utils": "14.7.4",
+		"@oh-my-pi/omp-stats": "14.7.6",
+		"@oh-my-pi/pi-agent-core": "14.7.6",
+		"@oh-my-pi/pi-ai": "14.7.6",
+		"@oh-my-pi/pi-natives": "14.7.6",
+		"@oh-my-pi/pi-tui": "14.7.6",
+		"@oh-my-pi/pi-utils": "14.7.6",
 		"@puppeteer/browsers": "^2.13.0",
 		"@sinclair/typebox": "^0.34.49",
 		"@types/turndown": "5.0.6",

package/src/cli.ts

@@ -1,5 +1,11 @@
 #!/usr/bin/env bun
-import { APP_NAME, MIN_BUN_VERSION, VERSION } from "@oh-my-pi/pi-utils";
+import { APP_NAME, MIN_BUN_VERSION, procmgr, VERSION } from "@oh-my-pi/pi-utils";
+
+// Strip macOS malloc-stack-logging env vars before any subprocess is spawned.
+// Otherwise every child bun process (subagents, plugin installs, ptree spawns,
+// etc.) prints a `MallocStackLogging: can't turn off …` warning to stderr.
+procmgr.scrubProcessEnv();
+
 /**
  * CLI entry point — registers all commands explicitly and delegates to the
  * lightweight CLI runner from pi-utils.

package/src/eval/js/context-manager.ts

@@ -1,5 +1,7 @@
 import * as fs from "node:fs";
+import { createRequire } from "node:module";
 import * as path from "node:path";
+import { pathToFileURL } from "node:url";
 import * as util from "node:util";
 import * as vm from "node:vm";
 
@@ -417,6 +419,8 @@ async function createVmState(
 		btoa,
 		Buffer,
 		process: createProcessSubset(cwd),
+		require: buildRequire(cwd),
+		createRequire,
 		fs,
 		fetch,
 		Blob,
@@ -478,13 +482,81 @@ async function runQueued<T>(state: VmContextState, work: () => Promise<T>): Prom
 	}
 }
 
+function buildRequire(cwd: string): NodeJS.Require {
+	// Anchor `require` resolution at the session cwd. The filename does not need to exist;
+	// Node only uses it as a base for module resolution.
+	return createRequire(pathToFileURL(path.join(cwd, "[eval]")).href);
+}
+
+// Static `import ... from "x"` is not valid inside vm.runInContext. Rewrite the common
+// forms to dynamic `await import(...)` so users can paste ESM-style imports verbatim.
+const STATIC_IMPORT_RE = /^[ \t]*import\b(?:[ \t]+([^'"\n]+?)[ \t]+from)?[ \t]*(['"])([^'"\n]+)\2[ \t]*;?[ \t]*$/gm;
+
+function splitTopLevel(clause: string): string[] {
+	const out: string[] = [];
+	let depth = 0;
+	let buf = "";
+	for (const ch of clause) {
+		if (ch === "{") depth++;
+		else if (ch === "}") depth--;
+		if (ch === "," && depth === 0) {
+			if (buf.trim()) out.push(buf.trim());
+			buf = "";
+		} else {
+			buf += ch;
+		}
+	}
+	if (buf.trim()) out.push(buf.trim());
+	return out;
+}
+
+function rewriteImportClause(clause: string, sourceLiteral: string): string {
+	let defaultName: string | undefined;
+	let namespaceName: string | undefined;
+	let namedBlock: string | undefined;
+	for (const part of splitTopLevel(clause)) {
+		if (part.startsWith("{")) {
+			namedBlock = part;
+		} else if (part.startsWith("*")) {
+			const m = part.match(/^\*\s+as\s+([A-Za-z_$][\w$]*)$/);
+			if (!m) return `await import(${sourceLiteral}); /* unrewritten import: ${clause} */`;
+			namespaceName = m[1];
+		} else if (/^[A-Za-z_$][\w$]*$/.test(part)) {
+			defaultName = part;
+		} else {
+			return `await import(${sourceLiteral}); /* unrewritten import: ${clause} */`;
+		}
+	}
+	if (namedBlock) {
+		const inner = namedBlock.slice(1, -1).trim();
+		const renamed = inner.replace(/([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*)/g, "$1: $2");
+		const props = defaultName ? `default: ${defaultName}, ${renamed}` : renamed;
+		return `const { ${props} } = await import(${sourceLiteral});`;
+	}
+	if (namespaceName && defaultName) {
+		return `const ${namespaceName} = await import(${sourceLiteral}); const ${defaultName} = ${namespaceName}.default;`;
+	}
+	if (namespaceName) return `const ${namespaceName} = await import(${sourceLiteral});`;
+	if (defaultName) return `const ${defaultName} = (await import(${sourceLiteral})).default;`;
+	return `await import(${sourceLiteral});`;
+}
+
+export function rewriteStaticImports(code: string): string {
+	return code.replace(STATIC_IMPORT_RE, (_match, clause: string | undefined, _quote, source: string) => {
+		const literal = JSON.stringify(source);
+		if (!clause) return `await import(${literal});`;
+		return rewriteImportClause(clause.trim(), literal);
+	});
+}
+
 function wrapCode(code: string): { source: string; asyncWrapped: boolean } {
-	const needsAsyncWrapper = /\bawait\b|\breturn\b/.test(code);
+	const rewritten = rewriteStaticImports(code);
+	const needsAsyncWrapper = /\bawait\b|\breturn\b/.test(rewritten);
 	if (!needsAsyncWrapper) {
-		return { source: code, asyncWrapped: false };
+		return { source: rewritten, asyncWrapped: false };
 	}
 	return {
-		source: `(async () => {\n${code}\n})()`,
+		source: `(async () => {\n${rewritten}\n})()`,
 		asyncWrapped: true,
 	};
 }

package/src/modes/controllers/input-controller.ts

@@ -701,6 +701,7 @@ export class InputController {
 	toggleThinkingBlockVisibility(): void {
 		this.ctx.hideThinkingBlock = !this.ctx.hideThinkingBlock;
 		settings.set("hideThinkingBlock", this.ctx.hideThinkingBlock);
+		this.ctx.session.agent.hideThinkingSummary = this.ctx.hideThinkingBlock;
 
 		// Rebuild chat from session messages
 		this.ctx.chatContainer.clear();

package/src/modes/controllers/selector-controller.ts

@@ -270,6 +270,7 @@ export class SelectorController {
 				break;
 			case "hideThinking":
 				this.ctx.hideThinkingBlock = value as boolean;
+				this.ctx.session.agent.hideThinkingSummary = value as boolean;
 				for (const child of this.ctx.chatContainer.children) {
 					if (child instanceof AssistantMessageComponent) {
 						child.setHideThinkingBlock(value as boolean);

package/src/modes/interactive-mode.ts

@@ -73,6 +73,15 @@ import { MCPCommandController } from "./controllers/mcp-command-controller";
 import { SelectorController } from "./controllers/selector-controller";
 import { SSHCommandController } from "./controllers/ssh-command-controller";
 import { TodoCommandController } from "./controllers/todo-command-controller";
+import {
+	consumeLoopLimitIteration,
+	createLoopLimitRuntime,
+	describeLoopLimit,
+	describeLoopLimitRuntime,
+	isLoopDurationExpired,
+	type LoopLimitRuntime,
+	parseLoopLimitArgs,
+} from "./loop-limit";
 import { OAuthManualInputManager } from "./oauth-manual-input";
 import { SessionObserverRegistry } from "./session-observer-registry";
 import type { Theme } from "./theme/theme";
@@ -158,6 +167,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	planModePlanFilePath: string | undefined = undefined;
 	loopModeEnabled = false;
 	loopPrompt: string | undefined = undefined;
+	loopLimit: LoopLimitRuntime | undefined = undefined;
 	#loopAutoSubmitTimer: NodeJS.Timeout | undefined;
 	todoPhases: TodoPhase[] = [];
 	hideThinkingBlock = false;
@@ -535,25 +545,35 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 
 	async #runLoopIteration(action: "prompt" | "compact" | "reset", prompt: string): Promise<void> {
+		if (!consumeLoopLimitIteration(this.loopLimit)) {
+			this.disableLoopMode("Loop limit reached. Loop mode disabled.");
+			return;
+		}
+
 		if (action === "compact") {
 			await this.handleCompactCommand();
 		} else if (action === "reset") {
 			await this.handleClearCommand();
 		}
 		if (!this.loopModeEnabled || !this.onInputCallback) return;
+		if (isLoopDurationExpired(this.loopLimit)) {
+			this.disableLoopMode("Loop time limit reached. Loop mode disabled.");
+			return;
+		}
 		this.onInputCallback(this.startPendingSubmission({ text: prompt }));
 	}
 
-	disableLoopMode(): void {
+	disableLoopMode(message = "Loop mode disabled."): void {
 		const wasEnabled = this.loopModeEnabled;
 		this.loopModeEnabled = false;
 		this.loopPrompt = undefined;
+		this.loopLimit = undefined;
 		this.#cancelLoopAutoSubmit();
 		this.statusLine.setLoopModeStatus(undefined);
 		this.updateEditorTopBorder();
 		this.ui.requestRender();
 		if (wasEnabled) {
-			this.showStatus("Loop mode disabled.");
+			this.showStatus(message);
 		}
 	}
 
@@ -567,18 +587,26 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#cancelLoopAutoSubmit();
 	}
 
-	async handleLoopCommand(): Promise<void> {
+	async handleLoopCommand(args = ""): Promise<void> {
 		if (this.loopModeEnabled) {
 			this.disableLoopMode();
 			return;
 		}
+		const parsedLimit = parseLoopLimitArgs(args);
+		if (typeof parsedLimit === "string") {
+			this.showError(parsedLimit);
+			return;
+		}
 		this.loopModeEnabled = true;
 		this.loopPrompt = undefined;
+		this.loopLimit = createLoopLimitRuntime(parsedLimit);
 		this.statusLine.setLoopModeStatus({ enabled: true });
 		this.updateEditorTopBorder();
 		this.ui.requestRender();
+		const limitSuffix = parsedLimit ? ` Limited to ${describeLoopLimit(parsedLimit)}.` : "";
+		const remainingSuffix = this.loopLimit ? ` ${describeLoopLimitRuntime(this.loopLimit)}.` : "";
 		this.showStatus(
-			"Loop mode enabled. Your next prompt will repeat after each turn. Esc cancels the current iteration; /loop again to disable.",
+			`Loop mode enabled.${limitSuffix}${remainingSuffix} Your next prompt will repeat after each turn. Esc cancels the current iteration; /loop again to disable.`,
 		);
 	}
 

package/src/modes/loop-limit.ts

@@ -0,0 +1,140 @@
+export type LoopLimitConfig =
+	| {
+			kind: "iterations";
+			iterations: number;
+	  }
+	| {
+			kind: "duration";
+			durationMs: number;
+	  };
+
+export type LoopLimitRuntime =
+	| {
+			kind: "iterations";
+			initial: number;
+			remaining: number;
+	  }
+	| {
+			kind: "duration";
+			durationMs: number;
+			deadlineMs: number;
+	  };
+
+const TIME_UNITS_MS = new Map<string, number>([
+	["s", 1_000],
+	["sec", 1_000],
+	["secs", 1_000],
+	["second", 1_000],
+	["seconds", 1_000],
+	["m", 60_000],
+	["min", 60_000],
+	["mins", 60_000],
+	["minute", 60_000],
+	["minutes", 60_000],
+	["h", 3_600_000],
+	["hr", 3_600_000],
+	["hrs", 3_600_000],
+	["hour", 3_600_000],
+	["hours", 3_600_000],
+]);
+
+export function parseLoopLimitArgs(args: string): LoopLimitConfig | undefined | string {
+	const trimmed = args.trim().toLowerCase();
+	if (!trimmed) return undefined;
+
+	const parts = trimmed.split(/\s+/);
+	if (parts.length > 2) {
+		return "Usage: /loop [count|duration]. Examples: /loop 10, /loop 10m, /loop 10min.";
+	}
+
+	if (parts.length === 2) {
+		return parseDurationParts(parts[0], parts[1]);
+	}
+
+	const token = parts[0];
+	const iterationMatch = /^(\d+)$/.exec(token);
+	if (iterationMatch) {
+		const iterations = Number(iterationMatch[1]);
+		if (!Number.isSafeInteger(iterations) || iterations <= 0) {
+			return "Loop count must be a positive integer.";
+		}
+		return { kind: "iterations", iterations };
+	}
+
+	const durationMatch = /^(\d+)([a-z]+)$/.exec(token);
+	if (durationMatch) {
+		return parseDurationParts(durationMatch[1], durationMatch[2]);
+	}
+
+	return "Usage: /loop [count|duration]. Examples: /loop 10, /loop 10m, /loop 10min.";
+}
+
+function parseDurationParts(amountText: string, unitText: string): LoopLimitConfig | string {
+	if (!/^\d+$/.test(amountText)) {
+		return "Loop duration must use a positive integer amount.";
+	}
+
+	const amount = Number(amountText);
+	if (!Number.isSafeInteger(amount) || amount <= 0) {
+		return "Loop duration must be positive.";
+	}
+
+	const unitMs = TIME_UNITS_MS.get(unitText);
+	if (unitMs === undefined) {
+		return "Loop duration unit must be seconds, minutes, or hours.";
+	}
+
+	return { kind: "duration", durationMs: amount * unitMs };
+}
+
+export function createLoopLimitRuntime(
+	config: LoopLimitConfig | undefined,
+	nowMs = Date.now(),
+): LoopLimitRuntime | undefined {
+	if (!config) return undefined;
+	if (config.kind === "iterations") {
+		return { kind: "iterations", initial: config.iterations, remaining: config.iterations };
+	}
+	return { kind: "duration", durationMs: config.durationMs, deadlineMs: nowMs + config.durationMs };
+}
+
+export function consumeLoopLimitIteration(limit: LoopLimitRuntime | undefined, nowMs = Date.now()): boolean {
+	if (!limit) return true;
+	if (limit.kind === "duration") {
+		return nowMs < limit.deadlineMs;
+	}
+	if (limit.remaining <= 0) return false;
+	limit.remaining -= 1;
+	return true;
+}
+
+export function isLoopDurationExpired(limit: LoopLimitRuntime | undefined, nowMs = Date.now()): boolean {
+	return limit?.kind === "duration" && nowMs >= limit.deadlineMs;
+}
+
+export function describeLoopLimit(config: LoopLimitConfig): string {
+	if (config.kind === "iterations") {
+		return `${config.iterations} ${config.iterations === 1 ? "iteration" : "iterations"}`;
+	}
+	return formatDuration(config.durationMs);
+}
+
+export function describeLoopLimitRuntime(limit: LoopLimitRuntime): string {
+	if (limit.kind === "iterations") {
+		return `${limit.remaining} of ${limit.initial} ${limit.initial === 1 ? "iteration" : "iterations"} remaining`;
+	}
+	return `${formatDuration(limit.durationMs)} limit`;
+}
+
+function formatDuration(durationMs: number): string {
+	if (durationMs % 3_600_000 === 0) {
+		const hours = durationMs / 3_600_000;
+		return `${hours} ${hours === 1 ? "hour" : "hours"}`;
+	}
+	if (durationMs % 60_000 === 0) {
+		const minutes = durationMs / 60_000;
+		return `${minutes} ${minutes === 1 ? "minute" : "minutes"}`;
+	}
+	const seconds = durationMs / 1_000;
+	return `${seconds} ${seconds === 1 ? "second" : "seconds"}`;
+}

package/src/modes/types.ts

@@ -24,6 +24,7 @@ import type { HookInputComponent } from "./components/hook-input";
 import type { HookSelectorComponent } from "./components/hook-selector";
 import type { StatusLineComponent } from "./components/status-line";
 import type { ToolExecutionHandle } from "./components/tool-execution";
+import type { LoopLimitRuntime } from "./loop-limit";
 import type { OAuthManualInputManager } from "./oauth-manual-input";
 import type { Theme } from "./theme/theme";
 
@@ -86,6 +87,7 @@ export interface InteractiveModeContext {
 	planModeEnabled: boolean;
 	loopModeEnabled: boolean;
 	loopPrompt?: string;
+	loopLimit?: LoopLimitRuntime;
 	planModePlanFilePath?: string;
 	hideThinkingBlock: boolean;
 	pendingImages: ImageContent[];
@@ -248,7 +250,7 @@ export interface InteractiveModeContext {
 	openExternalEditor(): void;
 	registerExtensionShortcuts(): void;
 	handlePlanModeCommand(initialPrompt?: string): Promise<void>;
-	handleLoopCommand(): Promise<void>;
+	handleLoopCommand(args?: string): Promise<void>;
 	disableLoopMode(): void;
 	pauseLoop(): void;
 	handleExitPlanModeTool(details: ExitPlanModeDetails): Promise<void>;

package/src/prompts/tools/read.md

@@ -50,7 +50,7 @@ For `.sqlite`, `.sqlite3`, `.db`, `.db3`:
 
 # URLs
 
-Extracts content from web pages, GitHub issues/PRs, Stack Overflow, Wikipedia, Reddit, NPM, arXiv, RSS/Atom feeds, JSON endpoints, PDFs at URLs, and similar text-based resources. Returns clean reader-mode text/markdown — no browser required. Use a `:raw` suffix for untouched HTML; `timeout` to override the default request timeout. URL line selectors require the `L` form, for example `https://example.com/page:L50-L60`.
+Extracts content from web pages, GitHub issues/PRs, Stack Overflow, Wikipedia, Reddit, NPM, arXiv, RSS/Atom feeds, JSON endpoints, PDFs at URLs, and similar text-based resources. Returns clean reader-mode text/markdown — no browser required. Use a `:raw` suffix for untouched HTML. URL line selectors mirror the file form (`:50`, `:50-100`, `:50+150`, `:raw`). If a URL would otherwise look like `host:port`, add a trailing slash before the selector (e.g. `https://example.com/:80`).
 </instruction>
 
 <critical>

package/src/sdk.ts

@@ -201,6 +201,10 @@ export interface CreateAgentSessionOptions {
 	rules?: Rule[];
 	/** Context files (AGENTS.md content). Default: discovered walking up from cwd */
 	contextFiles?: Array<{ path: string; content: string }>;
+	/** Pre-built AGENTS.md search (skips re-scanning the workspace; passed by parents to subagents). */
+	agentsMdSearch?: AgentsMdSearch;
+	/** Pre-built workspace tree (skips re-scanning; passed by parents to subagents). */
+	workspaceTree?: WorkspaceTree;
 	/** Prompt templates. Default: discovered from cwd/.omp/prompts/ + agentDir/prompts/ */
 	promptTemplates?: PromptTemplate[];
 	/** File-based slash commands. Default: discovered from commands/ directories */
@@ -687,11 +691,16 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	if (!options.modelRegistry) {
 		modelRegistry.refreshInBackground();
 	}
-	// Kick off AGENTS.md filesystem search in parallel — it is the slowest piece of buildSystemPrompt
-	// (~200ms on large repos) and only needs `cwd`, so it can overlap with everything that follows.
-	const agentsMdSearchPromise: Promise<AgentsMdSearch> = logger.time("buildAgentsMdSearch", buildAgentsMdSearch, cwd);
+	// Kick off AGENTS.md filesystem search and workspace tree in parallel — they are the slowest pieces of
+	// buildSystemPrompt (can be many seconds on large repos) and only need `cwd`, so they overlap with
+	// everything that follows. Subagents inherit the parent's resolved values via options.
+	const agentsMdSearchPromise: Promise<AgentsMdSearch> = options.agentsMdSearch
+		? Promise.resolve(options.agentsMdSearch)
+		: logger.time("buildAgentsMdSearch", buildAgentsMdSearch, cwd);
 	agentsMdSearchPromise.catch(() => {});
-	const workspaceTreePromise: Promise<WorkspaceTree> = logger.time("buildWorkspaceTree", buildWorkspaceTree, cwd);
+	const workspaceTreePromise: Promise<WorkspaceTree> = options.workspaceTree
+		? Promise.resolve(options.workspaceTree)
+		: logger.time("buildWorkspaceTree", buildWorkspaceTree, cwd);
 	workspaceTreePromise.catch(() => {});
 
 	// Independent discoveries that depend only on cwd/agentDir — kicked off in parallel and awaited
@@ -889,7 +898,11 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		return { ttsrManager, rulebookRules, alwaysApplyRules };
 	});
 
-	const contextFiles = await contextFilesPromise;
+	const [contextFiles, resolvedAgentsMdSearch, resolvedWorkspaceTree] = await Promise.all([
+		contextFilesPromise,
+		agentsMdSearchPromise,
+		workspaceTreePromise,
+	]);
 
 	let agent: Agent;
 	let session!: AgentSession;
@@ -973,6 +986,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			},
 			skipPythonPreflight: options.skipPythonPreflight,
 			contextFiles,
+			agentsMdSearch: resolvedAgentsMdSearch,
+			workspaceTree: resolvedWorkspaceTree,
 			skills,
 			eventBus,
 			outputSchema: options.outputSchema,
@@ -1637,6 +1652,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			presencePenalty: settings.get("presencePenalty") >= 0 ? settings.get("presencePenalty") : undefined,
 			repetitionPenalty: settings.get("repetitionPenalty") >= 0 ? settings.get("repetitionPenalty") : undefined,
 			serviceTier: initialServiceTier,
+			hideThinkingSummary: settings.get("hideThinkingBlock"),
 			kimiApiFormat: settings.get("providers.kimiApiFormat") ?? "anthropic",
 			preferWebsockets: preferOpenAICodexWebsockets,
 			getToolContext: tc => toolContextStore.getContext(tc),

package/src/session/agent-session.ts

@@ -6610,6 +6610,7 @@ export class AgentSession {
 			apiKey,
 			sessionId: this.sessionId,
 			reasoning: toReasoningEffort(this.thinkingLevel),
+			hideThinkingSummary: this.agent.hideThinkingSummary,
 			serviceTier: this.serviceTier,
 			signal: args.signal,
 			toolChoice: "none",

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

@@ -119,8 +119,10 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 		name: "loop",
 		description:
 			"Toggle loop mode. While enabled, the next prompt you send re-submits after every yield. Esc cancels the current iteration; /loop again to disable.",
-		handle: async (_command, runtime) => {
-			await runtime.ctx.handleLoopCommand();
+		inlineHint: "[count|duration]",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			await runtime.ctx.handleLoopCommand(command.args);
 			runtime.ctx.editor.setText("");
 		},
 	},

package/src/system-prompt.ts

@@ -449,106 +449,121 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 	} = options;
 	const resolvedCwd = cwd ?? getProjectDir();
 
-	const prepPromise = (() => {
-		const systemPromptCustomizationPromise = logger.time("loadSystemPromptFiles", loadSystemPromptFiles, {
-			cwd: resolvedCwd,
-		});
-		const contextFilesPromise = providedContextFiles
-			? Promise.resolve(providedContextFiles)
-			: logger.time("loadProjectContextFiles", loadProjectContextFiles, { cwd: resolvedCwd });
-		const agentsMdSearchPromise =
-			providedAgentsMdSearch !== undefined
-				? Promise.resolve(providedAgentsMdSearch)
-				: logger.time("buildAgentsMdSearch", buildAgentsMdSearch, resolvedCwd);
-		const workspaceTreePromise =
-			providedWorkspaceTree !== undefined
-				? Promise.resolve(providedWorkspaceTree)
-				: logger.time("buildWorkspaceTree", buildWorkspaceTree, resolvedCwd);
-		const skillsPromise: Promise<Skill[]> =
-			providedSkills !== undefined
-				? Promise.resolve(providedSkills)
-				: skillsSettings?.enabled !== false
-					? loadSkills({ ...skillsSettings, cwd: resolvedCwd }).then(result => result.skills)
-					: Promise.resolve([]);
-
-		return Promise.all([
+	const prepDefaults = {
+		resolvedCustomPrompt: undefined as string | undefined,
+		resolvedAppendPrompt: undefined as string | undefined,
+		systemPromptCustomization: null as string | null,
+		contextFiles: dedupeExactContextFiles(providedContextFiles ?? []),
+		agentsMdSearch: {
+			scopePath: ".",
+			limit: AGENTS_MD_LIMIT,
+			pattern: `AGENTS.md depth ${AGENTS_MD_MIN_DEPTH}-${AGENTS_MD_MAX_DEPTH}`,
+			files: [] as string[],
+		} satisfies AgentsMdSearch,
+		skills: providedSkills ?? ([] as Skill[]),
+		workspaceTree: {
+			rootPath: resolvedCwd,
+			rendered: "",
+			truncated: false,
+			totalLines: 0,
+		} satisfies WorkspaceTree,
+	};
+
+	const deadline = Bun.sleep(SYSTEM_PROMPT_PREP_TIMEOUT_MS).then(() => "__timeout__" as const);
+	const timedOut: string[] = [];
+	const failed: Array<{ name: string; error: unknown }> = [];
+
+	async function withDeadline<T>(name: string, work: Promise<T>, fallback: T): Promise<T> {
+		const tagged = work
+			.then(value => ({ kind: "ok" as const, value }))
+			.catch(error => ({ kind: "err" as const, error }));
+		const result = await Promise.race([tagged, deadline]);
+		if (result === "__timeout__") {
+			timedOut.push(name);
+			// Let the work continue in the background so its caches still warm; just log on completion.
+			void tagged.then(r => {
+				if (r.kind === "err") {
+					logger.warn("Background system prompt preparation step failed", { name, error: String(r.error) });
+				} else {
+					logger.debug("Background system prompt preparation step completed after timeout", { name });
+				}
+			});
+			return fallback;
+		}
+		if (result.kind === "err") {
+			failed.push({ name, error: result.error });
+			return fallback;
+		}
+		return result.value;
+	}
+
+	const systemPromptCustomizationPromise = logger.time("loadSystemPromptFiles", loadSystemPromptFiles, {
+		cwd: resolvedCwd,
+	});
+	const contextFilesPromise = providedContextFiles
+		? Promise.resolve(providedContextFiles)
+		: logger.time("loadProjectContextFiles", loadProjectContextFiles, { cwd: resolvedCwd });
+	const agentsMdSearchPromise =
+		providedAgentsMdSearch !== undefined
+			? Promise.resolve(providedAgentsMdSearch)
+			: logger.time("buildAgentsMdSearch", buildAgentsMdSearch, resolvedCwd);
+	const workspaceTreePromise =
+		providedWorkspaceTree !== undefined
+			? Promise.resolve(providedWorkspaceTree)
+			: logger.time("buildWorkspaceTree", buildWorkspaceTree, resolvedCwd);
+	const skillsPromise: Promise<Skill[]> =
+		providedSkills !== undefined
+			? Promise.resolve(providedSkills)
+			: skillsSettings?.enabled !== false
+				? loadSkills({ ...skillsSettings, cwd: resolvedCwd }).then(result => result.skills)
+				: Promise.resolve([]);
+
+	const [
+		resolvedCustomPrompt,
+		resolvedAppendPrompt,
+		systemPromptCustomization,
+		contextFiles,
+		agentsMdSearch,
+		skills,
+		workspaceTree,
+	] = await Promise.all([
+		withDeadline(
+			"customPrompt",
 			resolvePromptInput(customPrompt, "system prompt"),
+			prepDefaults.resolvedCustomPrompt,
+		),
+		withDeadline(
+			"appendSystemPrompt",
 			resolvePromptInput(appendSystemPrompt, "append system prompt"),
-			systemPromptCustomizationPromise,
-			contextFilesPromise,
-			agentsMdSearchPromise,
-			skillsPromise,
-			workspaceTreePromise,
-		]).then(
-			([
-				resolvedCustomPrompt,
-				resolvedAppendPrompt,
-				systemPromptCustomization,
-				contextFiles,
-				agentsMdSearch,
-				skills,
-				workspaceTree,
-			]) => ({
-				resolvedCustomPrompt,
-				resolvedAppendPrompt,
-				systemPromptCustomization,
-				contextFiles,
-				agentsMdSearch,
-				skills,
-				workspaceTree,
-			}),
-		);
-	})();
-
-	const prepResult = await Promise.race([
-		prepPromise
-			.then(value => ({ type: "ready" as const, value }))
-			.catch(error => ({ type: "error" as const, error })),
-		Bun.sleep(SYSTEM_PROMPT_PREP_TIMEOUT_MS).then(() => ({ type: "timeout" as const })),
+			prepDefaults.resolvedAppendPrompt,
+		),
+		withDeadline("loadSystemPromptFiles", systemPromptCustomizationPromise, prepDefaults.systemPromptCustomization),
+		withDeadline("loadProjectContextFiles", contextFilesPromise, prepDefaults.contextFiles).then(
+			dedupeExactContextFiles,
+		),
+		withDeadline("buildAgentsMdSearch", agentsMdSearchPromise, prepDefaults.agentsMdSearch),
+		withDeadline("loadSkills", skillsPromise, prepDefaults.skills),
+		withDeadline("buildWorkspaceTree", workspaceTreePromise, prepDefaults.workspaceTree),
 	]);
 
-	let resolvedCustomPrompt: string | undefined;
-	let resolvedAppendPrompt: string | undefined;
-	let systemPromptCustomization: string | null = null;
-	let contextFiles: Array<{ path: string; content: string; depth?: number }> = dedupeExactContextFiles(
-		providedContextFiles ?? [],
-	);
-	let agentsMdSearch: AgentsMdSearch = {
-		scopePath: ".",
-		limit: AGENTS_MD_LIMIT,
-		pattern: `AGENTS.md depth ${AGENTS_MD_MIN_DEPTH}-${AGENTS_MD_MAX_DEPTH}`,
-		files: [],
-	};
-	let workspaceTree: WorkspaceTree = {
-		rootPath: resolvedCwd,
-		rendered: "",
-		truncated: false,
-		totalLines: 0,
-	};
-	let skills: Skill[] = providedSkills ?? [];
-
-	if (prepResult.type === "timeout") {
-		logger.warn("System prompt preparation timed out; using minimal startup context", {
+	if (timedOut.length > 0) {
+		logger.warn("System prompt preparation steps timed out; using minimal fallback for those steps", {
 			cwd: resolvedCwd,
 			timeoutMs: SYSTEM_PROMPT_PREP_TIMEOUT_MS,
+			steps: timedOut,
 		});
 		process.stderr.write(
-			`Warning: system prompt preparation timed out after ${SYSTEM_PROMPT_PREP_TIMEOUT_MS}ms; using minimal startup context.\n`,
+			`Warning: system prompt preparation steps timed out after ${SYSTEM_PROMPT_PREP_TIMEOUT_MS}ms (${timedOut.join(", ")}); using minimal fallback for those steps.\n`,
 		);
-	} else if (prepResult.type === "error") {
-		logger.warn("System prompt preparation failed; using minimal startup context", {
-			cwd: resolvedCwd,
-			error: String(prepResult.error),
-		});
-		process.stderr.write("Warning: system prompt preparation failed; using minimal startup context.\n");
-	} else {
-		resolvedCustomPrompt = prepResult.value.resolvedCustomPrompt;
-		resolvedAppendPrompt = prepResult.value.resolvedAppendPrompt;
-		systemPromptCustomization = prepResult.value.systemPromptCustomization;
-		contextFiles = dedupeExactContextFiles(prepResult.value.contextFiles);
-		agentsMdSearch = prepResult.value.agentsMdSearch;
-		skills = prepResult.value.skills;
-		workspaceTree = prepResult.value.workspaceTree;
+	}
+	if (failed.length > 0) {
+		for (const { name, error } of failed) {
+			logger.warn("System prompt preparation step failed; using minimal fallback", {
+				cwd: resolvedCwd,
+				step: name,
+				error: String(error),
+			});
+		}
 	}
 
 	const date = new Date().toISOString().slice(0, 10);

package/src/task/executor.ts

@@ -28,11 +28,13 @@ import { createAgentSession, discoverAuthStorage } from "../sdk";
 import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
 import type { AuthStorage } from "../session/auth-storage";
 import { SessionManager } from "../session/session-manager";
+import type { AgentsMdSearch } from "../system-prompt";
 import { type ContextFileEntry, truncateTail } from "../tools";
 import { jtdToJsonSchema, normalizeSchema } from "../tools/jtd-to-json-schema";
 import { ToolAbortError } from "../tools/tool-errors";
 import type { EventBus } from "../utils/event-bus";
 import { buildNamedToolChoice } from "../utils/tool-choice";
+import type { WorkspaceTree } from "../workspace-tree";
 import { subprocessToolRegistry } from "./subprocess-tool-registry";
 import {
 	type AgentDefinition,
@@ -158,6 +160,8 @@ export interface ExecutorOptions {
 	contextFiles?: ContextFileEntry[];
 	skills?: Skill[];
 	promptTemplates?: PromptTemplate[];
+	agentsMdSearch?: AgentsMdSearch;
+	workspaceTree?: WorkspaceTree;
 	mcpManager?: MCPManager;
 	authStorage?: AuthStorage;
 	modelRegistry?: ModelRegistry;
@@ -967,6 +971,8 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				contextFiles: options.contextFiles,
 				skills: options.skills,
 				promptTemplates: options.promptTemplates,
+				agentsMdSearch: options.agentsMdSearch,
+				workspaceTree: options.workspaceTree,
 				systemPrompt: defaultPrompt => [
 					prompt.render(subagentSystemPromptTemplate, {
 						base: defaultPrompt.join("\n\n"),

package/src/task/index.ts

@@ -864,6 +864,8 @@ export class TaskTool implements AgentTool<TSchema, TaskToolDetails, Theme> {
 						mcpManager: this.session.mcpManager,
 						contextFiles,
 						skills: availableSkills,
+						agentsMdSearch: this.session.agentsMdSearch,
+						workspaceTree: this.session.workspaceTree,
 						promptTemplates,
 						localProtocolOptions,
 						parentHindsightSessionState: this.session.getHindsightSessionState?.(),
@@ -919,6 +921,8 @@ export class TaskTool implements AgentTool<TSchema, TaskToolDetails, Theme> {
 						mcpManager: this.session.mcpManager,
 						contextFiles,
 						skills: availableSkills,
+						agentsMdSearch: this.session.agentsMdSearch,
+						workspaceTree: this.session.workspaceTree,
 						promptTemplates,
 						localProtocolOptions,
 						parentHindsightSessionState: this.session.getHindsightSessionState?.(),

package/src/tools/fetch.ts

@@ -137,9 +137,10 @@ export function isReadableUrlPath(value: string): boolean {
 	return /^https?:\/\//i.test(value) || /^www\./i.test(value);
 }
 
-const URL_LINE_RANGE_RE = /^L?(\d+)(?:([-+])L?(\d+))?$/i;
-// Embedded URL selectors (after a `:` in the path) keep the explicit `L` prefix to avoid colliding with ports such as `https://example.com:50`.
-const URL_EMBEDDED_LINE_RANGE_RE = /^L\d+(?:[-+]L?\d+)?$/i;
+// URL line selectors mirror the file form: `:50`, `:50-100`, `:50+150`, `:raw`.
+// If a URL would otherwise look like `host:port`, add a trailing slash before the selector
+// (e.g. `https://example.com/:80` to read line 80 of the document at `https://example.com/`).
+const URL_LINE_RANGE_RE = /^(\d+)(?:([-+])(\d+))?$/;
 
 export interface ParsedReadUrlTarget {
 	path: string;
@@ -157,11 +158,11 @@ export function parseReadUrlTarget(readPath: string): ParsedReadUrlTarget | null
 
 	const selector = embedded?.sel;
 	const raw = selector === "raw";
-	const lineMatch = selector ? URL_LINE_RANGE_RE.exec(selector) : null;
+	const lineMatch = selector && selector !== "raw" ? URL_LINE_RANGE_RE.exec(selector) : null;
 	if (lineMatch) {
 		const startLine = Number.parseInt(lineMatch[1]!, 10);
 		if (startLine < 1) {
-			throw new ToolError("URL line selector 0 is invalid; lines are 1-indexed. Use :L1.");
+			throw new ToolError("URL line selector 0 is invalid; lines are 1-indexed. Use :1.");
 		}
 		const sep = lineMatch[2];
 		const rhs = lineMatch[3] ? Number.parseInt(lineMatch[3], 10) : undefined;
@@ -195,13 +196,13 @@ function tryExtractEmbeddedUrlSelector(readPath: string): { path: string; sel?:
 	}
 
 	const candidateSelector = readPath.slice(lastColonIndex + 1);
-	const isEmbeddedSelector = candidateSelector === "raw" || URL_EMBEDDED_LINE_RANGE_RE.test(candidateSelector);
-	if (!isEmbeddedSelector) {
+	const basePath = readPath.slice(0, lastColonIndex);
+	if (!isReadableUrlPath(basePath)) {
 		return null;
 	}
 
-	const basePath = readPath.slice(0, lastColonIndex);
-	if (!isReadableUrlPath(basePath)) {
+	const isEmbeddedSelector = candidateSelector === "raw" || URL_LINE_RANGE_RE.test(candidateSelector);
+	if (!isEmbeddedSelector) {
 		return null;
 	}
 

package/src/tools/index.ts

@@ -14,11 +14,13 @@ import type { PlanModeState } from "../plan-mode/state";
 import type { AgentRegistry } from "../registry/agent-registry";
 import type { CustomMessage } from "../session/messages";
 import type { ToolChoiceQueue } from "../session/tool-choice-queue";
+import type { AgentsMdSearch } from "../system-prompt";
 import { TaskTool } from "../task";
 import type { AgentOutputManager } from "../task/output-manager";
 import type { DiscoverableTool, DiscoverableToolSearchIndex } from "../tool-discovery/tool-index";
 import type { EventBus } from "../utils/event-bus";
 import { WebSearchTool } from "../web/search";
+import type { WorkspaceTree } from "../workspace-tree";
 import { AskTool } from "./ask";
 import { AstEditTool } from "./ast-edit";
 import { AstGrepTool } from "./ast-grep";
@@ -120,6 +122,10 @@ export interface ToolSession {
 	skipPythonPreflight?: boolean;
 	/** Pre-loaded context files (AGENTS.md, etc) */
 	contextFiles?: ContextFileEntry[];
+	/** Pre-loaded AGENTS.md search (forwarded to subagents to skip re-scanning) */
+	agentsMdSearch?: AgentsMdSearch;
+	/** Pre-loaded workspace tree (forwarded to subagents to skip re-scanning) */
+	workspaceTree?: WorkspaceTree;
 	/** Pre-loaded skills */
 	skills?: Skill[];
 	/** Pre-loaded prompt templates */