@oh-my-pi/pi-coding-agent 15.7.6 → 15.8.2

package/src/cli/session-picker.ts

@@ -1,23 +1,43 @@
 import { ProcessTerminal, TUI } from "@oh-my-pi/pi-tui";
+import { logger } from "@oh-my-pi/pi-utils";
 import { SessionSelectorComponent } from "../modes/components/session-selector";
-import type { SessionInfo } from "../session/session-manager";
+import { HistoryStorage } from "../session/history-storage";
+import { type SessionInfo, SessionManager } from "../session/session-manager";
 import { FileSessionStorage } from "../session/session-storage";
 
-/** Show TUI session selector and return selected session path or null if cancelled */
-export async function selectSession(sessions: SessionInfo[]): Promise<string | null> {
-	const { promise, resolve } = Promise.withResolvers<string | null>();
+/**
+ * Show the TUI session selector and return the selected session, or null if
+ * cancelled. Tab toggles between current-folder and all-projects scope; the
+ * all-projects list is loaded lazily via `SessionManager.listAll`.
+ */
+export async function selectSession(
+	sessions: SessionInfo[],
+	options?: { allSessions?: SessionInfo[]; startInAllScope?: boolean },
+): Promise<SessionInfo | null> {
+	const { promise, resolve } = Promise.withResolvers<SessionInfo | null>();
 	const ui = new TUI(new ProcessTerminal());
 	let resolved = false;
 	const storage = new FileSessionStorage();
 
+	// Rank sessions with prompt-history matches too, recovering prompts the 4KB
+	// session-list prefix never sees. Best-effort: a missing/locked history.db
+	// must not break the picker.
+	let historyMatcher: ((query: string) => string[]) | undefined;
+	try {
+		const history = HistoryStorage.open();
+		historyMatcher = (query: string) => history.matchingSessionIds(query);
+	} catch (error) {
+		logger.warn("History storage unavailable for session ranking", { error: String(error) });
+	}
+
 	const showSelector = () => {
 		const selector = new SessionSelectorComponent(
 			sessions,
-			(path: string) => {
+			(session: SessionInfo) => {
 				if (!resolved) {
 					resolved = true;
 					ui.stop();
-					resolve(path);
+					resolve(session);
 				}
 			},
 			() => {
@@ -34,10 +54,16 @@ export async function selectSession(sessions: SessionInfo[]): Promise<string | n
 					process.exit(0);
 				}
 			},
-			async (session: SessionInfo) => {
-				// Delete handler - SessionList will show confirmation internally
-				await storage.deleteSessionWithArtifacts(session.path);
-				return true;
+			{
+				onDelete: async (session: SessionInfo) => {
+					// Delete handler - SessionList will show confirmation internally
+					await storage.deleteSessionWithArtifacts(session.path);
+					return true;
+				},
+				historyMatcher,
+				loadAllSessions: () => SessionManager.listAll(storage),
+				allSessions: options?.allSessions,
+				startInAllScope: options?.startInAllScope,
 			},
 		);
 		return selector;

package/src/cli/update-cli.ts

@@ -14,6 +14,18 @@ import { theme } from "../modes/theme/theme";
 
 const REPO = "can1357/oh-my-pi";
 const PACKAGE = "@oh-my-pi/pi-coding-agent";
+/**
+ * Official npm registry origin.
+ *
+ * Pinned across both the version check and the bun install step so the two
+ * agree on which catalog they are talking to. A user's bun may be pointed at
+ * an unofficial mirror (corporate proxy, Taobao, etc.) that lags the upstream
+ * registry by minutes-to-hours, in which case `getLatestRelease` would resolve
+ * a version the mirror has not yet replicated and the install would fail with
+ * `No version matching "X" found for specifier "<pkg>" (but package exists)`.
+ * See #1686.
+ */
+const NPM_REGISTRY = "https://registry.npmjs.org/";
 
 interface ReleaseInfo {
 	tag: string;
@@ -130,7 +142,7 @@ async function resolveUpdateTarget(): Promise<UpdateTarget> {
  * Uses npm instead of GitHub API to avoid unauthenticated rate limiting.
  */
 async function getLatestRelease(): Promise<ReleaseInfo> {
-	const response = await fetch(`https://registry.npmjs.org/${PACKAGE}/latest`);
+	const response = await fetch(`${NPM_REGISTRY}${PACKAGE}/latest`);
 	if (!response.ok) {
 		throw new Error(`Failed to fetch release info: ${response.statusText}`);
 	}
@@ -292,12 +304,33 @@ export async function replaceBinaryForUpdate(options: BinaryReplacementOptions):
 	}
 }
 
+/**
+ * Build the bun argv used to globally install a specific omp version.
+ *
+ * The version is selected by hitting {@link NPM_REGISTRY} directly in
+ * {@link getLatestRelease}, so the install MUST observe the same catalog:
+ *
+ * - `--registry=${NPM_REGISTRY}` pins the install to the official registry
+ *   regardless of the user's bunfig/`.npmrc`. A mirror (corporate proxy,
+ *   Taobao, …) that hasn't yet replicated the release would otherwise reject
+ *   a version the upstream registry already advertises.
+ * - `--no-cache` tells bun to ignore its on-disk manifest snapshot so it
+ *   re-fetches metadata from that registry on every invocation.
+ *
+ * Together these two flags make `omp update` produce exactly the registry
+ * lookup the version check just performed. See #1686.
+ */
+export function buildBunInstallArgs(expectedVersion: string): string[] {
+	return ["install", "-g", "--no-cache", `--registry=${NPM_REGISTRY}`, `${PACKAGE}@${expectedVersion}`];
+}
+
 /**
  * Update via bun package manager.
  */
 async function updateViaBun(expectedVersion: string): Promise<void> {
 	console.log(chalk.dim("Updating via bun..."));
-	const result = await $`bun install -g ${PACKAGE}@${expectedVersion}`.nothrow();
+	const args = buildBunInstallArgs(expectedVersion);
+	const result = await $`bun ${args}`.nothrow();
 	if (result.exitCode !== 0) {
 		throw new Error(`bun install failed with exit code ${result.exitCode}`);
 	}

package/src/commands/launch.ts

@@ -90,6 +90,9 @@ export default class Index extends Command {
 			description: `Set thinking level: ${THINKING_EFFORTS.join(", ")}`,
 			options: [...THINKING_EFFORTS],
 		}),
+		"hide-thinking": Flags.boolean({
+			description: "Hide thinking blocks in TUI output (display only, does not disable model thinking)",
+		}),
 		hook: Flags.string({
 			description: "Load a hook/extension file (can be used multiple times)",
 			multiple: true,

package/src/config/keybindings.ts

@@ -32,6 +32,7 @@ interface AppKeybindings {
 	"app.message.followUp": true;
 	"app.message.dequeue": true;
 	"app.clipboard.pasteImage": true;
+	"app.clipboard.pasteTextRaw": true;
 	"app.clipboard.copyLine": true;
 	"app.clipboard.copyPrompt": true;
 	"app.session.new": true;
@@ -57,6 +58,13 @@ declare module "@oh-my-pi/pi-tui" {
 	interface Keybindings extends AppKeybindings {}
 }
 
+/**
+ * Resolve default image-paste shortcuts for the current terminal platform.
+ */
+export function getDefaultPasteImageKeys(platform: NodeJS.Platform = process.platform): KeyId[] {
+	return platform === "win32" ? ["ctrl+v", "alt+v"] : ["ctrl+v"];
+}
+
 /**
  * All keybindings definitions: TUI + app-specific.
  */
@@ -119,9 +127,13 @@ export const KEYBINDINGS = {
 		description: "Dequeue message",
 	},
 	"app.clipboard.pasteImage": {
-		defaultKeys: process.platform === "win32" ? "alt+v" : "ctrl+v",
+		defaultKeys: getDefaultPasteImageKeys(),
 		description: "Paste image from clipboard",
 	},
+	"app.clipboard.pasteTextRaw": {
+		defaultKeys: ["ctrl+shift+v", "alt+shift+v"],
+		description: "Paste text from clipboard as raw text (no collapse)",
+	},
 	"app.clipboard.copyLine": {
 		defaultKeys: "alt+shift+l",
 		description: "Copy current line",
@@ -214,6 +226,7 @@ const KEYBINDING_NAME_MIGRATIONS = {
 	followUp: "app.message.followUp",
 	dequeue: "app.message.dequeue",
 	pasteImage: "app.clipboard.pasteImage",
+	pasteTextRaw: "app.clipboard.pasteTextRaw",
 	copyLine: "app.clipboard.copyLine",
 	copyPrompt: "app.clipboard.copyPrompt",
 	newSession: "app.session.new",

package/src/config/model-registry.ts

@@ -53,6 +53,17 @@ function discoveryDefaultMaxTokens(api: Api | undefined): number {
 	return api === "anthropic-messages" ? DISCOVERY_DEFAULT_MAX_TOKENS_ANTHROPIC : DISCOVERY_DEFAULT_MAX_TOKENS;
 }
 
+const SPECIAL_MODEL_MANAGER_PROVIDER_IDS: readonly string[] = [
+	"google-antigravity",
+	"google-gemini-cli",
+	"openai-codex",
+];
+
+const STARTUP_MODEL_CACHE_PROVIDER_IDS: readonly string[] = [
+	...PROVIDER_DESCRIPTORS.map(descriptor => descriptor.providerId),
+	...SPECIAL_MODEL_MANAGER_PROVIDER_IDS,
+];
+
 import { registerOAuthProvider, unregisterOAuthProviders } from "@oh-my-pi/pi-ai/utils/oauth";
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/utils/oauth/types";
 import { isRecord, logger } from "@oh-my-pi/pi-utils";
@@ -1133,28 +1144,28 @@ export class ModelRegistry {
 		const configuredDiscoveryProviders = new Set(this.#discoverableProviders.map(provider => provider.provider));
 		const cachedModels: Model<Api>[] = [];
 		const authoritativeFreshProviders = new Set<string>();
-		for (const descriptor of PROVIDER_DESCRIPTORS) {
-			if (configuredDiscoveryProviders.has(descriptor.providerId)) {
+		for (const providerId of STARTUP_MODEL_CACHE_PROVIDER_IDS) {
+			if (configuredDiscoveryProviders.has(providerId)) {
 				continue;
 			}
-			const cache = readModelCache<Api>(descriptor.providerId, 24 * 60 * 60 * 1000, Date.now, this.#cacheDbPath);
+			const cache = readModelCache<Api>(providerId, 24 * 60 * 60 * 1000, Date.now, this.#cacheDbPath);
 			if (!cache) {
 				continue;
 			}
 			if (cache.fresh && cache.authoritative) {
-				authoritativeFreshProviders.add(descriptor.providerId);
+				authoritativeFreshProviders.add(providerId);
 			}
 			const models = cache.models.map(model =>
-				model.provider === descriptor.providerId ? model : { ...model, provider: descriptor.providerId },
+				model.provider === providerId ? model : { ...model, provider: providerId },
 			);
-			const providerOverride = this.#providerOverrides.get(descriptor.providerId);
+			const providerOverride = this.#providerOverrides.get(providerId);
 			const withTransport = providerOverride
 				? models.map(model => this.#applyProviderTransportOverride(model, providerOverride))
 				: models;
 			const withCompat = providerOverride?.compat
 				? withTransport.map(model => ({ ...model, compat: mergeCompat(model.compat, providerOverride.compat) }))
 				: withTransport;
-			cachedModels.push(...this.#applyProviderModelOverrides(descriptor.providerId, withCompat));
+			cachedModels.push(...this.#applyProviderModelOverrides(providerId, withCompat));
 		}
 		return { models: cachedModels, authoritativeFreshProviders };
 	}

package/src/config/settings-schema.ts

@@ -2894,7 +2894,7 @@ export const SETTINGS_SCHEMA = {
 					label: "Auto",
 					description: "Preferred web-search provider",
 				},
-				{ value: "exa", label: "Exa", description: "Uses Exa API when EXA_API_KEY is set; falls back to Exa MCP" },
+				{ value: "exa", label: "Exa", description: "Requires EXA_API_KEY" },
 				{ value: "brave", label: "Brave", description: "Requires BRAVE_API_KEY" },
 				{ value: "jina", label: "Jina", description: "Requires JINA_API_KEY" },
 				{ value: "kimi", label: "Kimi", description: "Requires MOONSHOT_SEARCH_API_KEY or MOONSHOT_API_KEY" },
@@ -2920,7 +2920,7 @@ export const SETTINGS_SCHEMA = {
 				},
 				{ value: "zai", label: "Z.AI", description: "Calls Z.AI webSearchPrime MCP" },
 				{ value: "tavily", label: "Tavily", description: "Requires TAVILY_API_KEY" },
-				{ value: "kagi", label: "Kagi", description: "Requires KAGI_API_KEY and Kagi Search API beta access" },
+				{ value: "kagi", label: "Kagi", description: "Requires KAGI_API_KEY (Kagi V1 Search API)" },
 				{ value: "synthetic", label: "Synthetic", description: "Requires SYNTHETIC_API_KEY" },
 				{ value: "parallel", label: "Parallel", description: "Requires PARALLEL_API_KEY" },
 				{ value: "searxng", label: "SearXNG", description: "Requires SEARXNG_ENDPOINT or searxng.endpoint" },

package/src/config/settings.ts

@@ -365,6 +365,29 @@ export class Settings {
 		return cloned;
 	}
 
+	/**
+	 * Re-scope this instance to a new working directory *in place*: reload the
+	 * project layer (`.claude/settings.yml` etc.) from `cwd`, re-resolve
+	 * path-scoped settings against it, and re-fire side-effect hooks (theme,
+	 * symbols, tab width, …). Global settings and runtime overrides are preserved.
+	 *
+	 * Unlike {@link cloneForCwd}, this mutates the live instance, so every holder
+	 * (the `settings` proxy, the active session, controllers) observes the new
+	 * project scope without swapping references — used when the process changes
+	 * directory mid-run (`/move`, cross-project resume). No-op when `cwd` is
+	 * already the current scope.
+	 */
+	async reloadForCwd(cwd: string): Promise<void> {
+		const normalized = path.normalize(cwd);
+		if (normalized === this.#cwd) return;
+		this.#cwd = normalized;
+		if (this.#persist) {
+			this.#project = await this.#loadProjectSettings();
+		}
+		this.#rebuildMerged();
+		this.#fireAllHooks();
+	}
+
 	// ─────────────────────────────────────────────────────────────────────────
 	// Accessors
 	// ─────────────────────────────────────────────────────────────────────────

package/src/discovery/builtin-rules/index.ts

@@ -17,6 +17,7 @@ import rsResultType from "./rs-result-type.md" with { type: "text" };
 import tsBareCatch from "./ts-bare-catch.md" with { type: "text" };
 import tsImportType from "./ts-import-type.md" with { type: "text" };
 import tsNoAny from "./ts-no-any.md" with { type: "text" };
+import tsNoDeprecatedLeftovers from "./ts-no-deprecated-leftovers.md" with { type: "text" };
 import tsNoDynamicImport from "./ts-no-dynamic-import.md" with { type: "text" };
 import tsNoReturnType from "./ts-no-return-type.md" with { type: "text" };
 import tsNoTinyFunctions from "./ts-no-tiny-functions.md" with { type: "text" };
@@ -40,6 +41,7 @@ export const BUILTIN_RULE_SOURCES: readonly BuiltinRuleSource[] = [
 	{ name: "ts-bare-catch", content: tsBareCatch },
 	{ name: "ts-import-type", content: tsImportType },
 	{ name: "ts-no-any", content: tsNoAny },
+	{ name: "ts-no-deprecated-leftovers", content: tsNoDeprecatedLeftovers },
 	{ name: "ts-no-dynamic-import", content: tsNoDynamicImport },
 	{ name: "ts-no-return-type", content: tsNoReturnType },
 	{ name: "ts-no-tiny-functions", content: tsNoTinyFunctions },

package/src/discovery/builtin-rules/ts-no-deprecated-leftovers.md

@@ -0,0 +1,44 @@
+---
+description: "Do not leave `@deprecated` shims behind after refactors — update call sites and remove the old API"
+condition: "@deprecated"
+scope: "tool:edit(*.ts), tool:edit(*.tsx), tool:write(*.ts), tool:write(*.tsx)"
+---
+
+Do not use `@deprecated` as a substitute for finishing a refactor. If an API is obsolete inside the code you control, update every call site and remove the old name in the same change.
+
+## Why
+
+- Deprecated aliases keep two contracts alive.
+- Future maintainers must preserve behavior nobody should call.
+- Tests can pass while production code keeps using the old path.
+- The next refactor has to unwind both the real API and the compatibility layer.
+
+## Avoid
+
+```typescript
+// Bad — leaves a stale compatibility name instead of finishing the cutover.
+/** @deprecated Use loadSettings instead. */
+export const loadConfig = loadSettings;
+
+// Bad — preserves an obsolete wrapper after callers can be updated.
+/** @deprecated Use createClient instead. */
+export function makeClient(options: ClientOptions): Client {
+	return createClient(options);
+}
+```
+
+## Use
+
+```typescript
+// Update all imports and call sites to the durable name.
+export function loadSettings(path: string): Settings { ... }
+export function createClient(options: ClientOptions): Client { ... }
+```
+
+## Exceptions
+
+- Public package APIs with a documented migration window.
+- Third-party declarations where the deprecated marker reflects an external contract.
+- Tests that intentionally verify deprecated API behavior during a supported transition.
+
+If an exception applies, state the external compatibility requirement. Otherwise, finish the refactor and delete the deprecated symbol.

package/src/discovery/claude-plugins.ts

@@ -99,10 +99,8 @@ async function resolvePluginDir(
 async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 	const items: Skill[] = [];
 	const warnings: string[] = [];
-
 	const { roots, warnings: rootWarnings } = await listClaudePluginRoots(ctx.home, ctx.cwd);
 	warnings.push(...rootWarnings);
-
 	const results = await Promise.all(
 		roots.map(async root => {
 			const { dir: skillsDir, warning } = await resolvePluginDir(root, ["skills"], "skills");
@@ -114,16 +112,16 @@ async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 			return { root, result, warning };
 		}),
 	);
-
-	for (const { root, result, warning } of results) {
+	for (const { result, warning } of results) {
 		if (warning) warnings.push(warning);
-		for (const skill of result.items) {
-			if (root.plugin) skill.name = `${root.plugin}:${skill.name}`;
-			items.push(skill);
-		}
+		// Intentionally do NOT prefix skill names with `root.plugin`.
+		// The `plugin:name` format breaks skill:// URL parsing (colons are
+		// ambiguous with port separators) and is unintuitive for callers.
+		// Dedup-by-key in the capability layer already handles name collisions
+		// across providers using priority ordering.
+		items.push(...result.items);
 		if (result.warnings) warnings.push(...result.warnings);
 	}
-
 	return { items, warnings };
 }
 

package/src/edit/index.ts

@@ -24,6 +24,7 @@ import applyPatchGrammar from "./modes/apply-patch.lark" with { type: "text" };
 import { executePatchSingle, type PatchEditEntry, type PatchParams, patchEditSchema } from "./modes/patch";
 import { executeReplaceSingle, type ReplaceEditEntry, type ReplaceParams, replaceEditSchema } from "./modes/replace";
 import { type EditToolDetails, type EditToolPerFileResult, getLspBatchRequest, type LspBatchRequest } from "./renderer";
+import { EDIT_MODE_STRATEGIES } from "./streaming";
 
 export * from "@oh-my-pi/hashline";
 export { DEFAULT_EDIT_MODE, type EditMode, normalizeEditMode } from "../utils/edit-mode";
@@ -360,6 +361,15 @@ export class EditTool implements AgentTool<TInput> {
 		return "apply_patch";
 	}
 
+	/**
+	 * Normalize streamed args into the source text this edit introduces, so
+	 * stream matchers (TTSR rules) run against real file content instead of the
+	 * mode-specific patch grammar.
+	 */
+	matcherDigest(args: unknown): string | undefined {
+		return EDIT_MODE_STRATEGIES[this.mode].matcherDigest(args);
+	}
+
 	async execute(
 		_toolCallId: string,
 		params: EditParams,

package/src/edit/streaming.ts

@@ -69,6 +69,14 @@ export interface EditStreamingStrategy<Args = unknown> {
 	 * compute returned `null` because args are still too partial).
 	 */
 	renderStreamingFallback(args: Args, uiTheme: Theme): string;
+	/**
+	 * Project the (potentially partial) args onto the plain text the edit
+	 * introduces into files — added lines without patch grammar — so stream
+	 * matchers (TTSR rules) can run source-level patterns against real content
+	 * instead of the mode-specific wire format. Returns `undefined` when the
+	 * args don't yet carry any content.
+	 */
+	matcherDigest(args: Args): string | undefined;
 }
 
 // -----------------------------------------------------------------------------
@@ -161,6 +169,28 @@ function groupApplyPatchEntriesByPath(entries: readonly ApplyPatchEntry[]): Map<
 	return groups;
 }
 
+/**
+ * Extract the lines a patch-style payload adds (`+` prefix, excluding `+++ `
+ * file headers), stripped of the prefix. When the text carries no added lines,
+ * returns the whole text if `fallbackToWhole` (full-content payloads such as a
+ * `create` op), otherwise an empty string (grammar-only payloads).
+ */
+function extractAddedLines(text: string, fallbackToWhole: boolean): string {
+	let added: string | undefined;
+	let lineStart = 0;
+	while (lineStart <= text.length) {
+		let lineEnd = text.indexOf("\n", lineStart);
+		if (lineEnd === -1) lineEnd = text.length;
+		if (text.charCodeAt(lineStart) === 43 /* + */ && !text.startsWith("+++ ", lineStart)) {
+			const line = text.slice(lineStart + 1, lineEnd);
+			added = added === undefined ? line : `${added}\n${line}`;
+		}
+		lineStart = lineEnd + 1;
+	}
+	if (added === undefined) return fallbackToWhole ? text : "";
+	return added;
+}
+
 // -----------------------------------------------------------------------------
 // Strategies
 // -----------------------------------------------------------------------------
@@ -196,6 +226,16 @@ const replaceStrategy: EditStreamingStrategy<ReplaceArgs> = {
 	renderStreamingFallback() {
 		return "";
 	},
+	matcherDigest(args) {
+		const edits = args?.edits;
+		if (!Array.isArray(edits)) return undefined;
+		let digest: string | undefined;
+		for (const edit of edits) {
+			if (typeof edit?.new_text !== "string") continue;
+			digest = digest === undefined ? edit.new_text : `${digest}\n${edit.new_text}`;
+		}
+		return digest;
+	},
 };
 
 interface PatchArgs {
@@ -225,6 +265,19 @@ const patchStrategy: EditStreamingStrategy<PatchArgs> = {
 	renderStreamingFallback() {
 		return "";
 	},
+	matcherDigest(args) {
+		const edits = args?.edits;
+		if (!Array.isArray(edits)) return undefined;
+		let digest: string | undefined;
+		for (const edit of edits) {
+			if (typeof edit?.diff !== "string") continue;
+			// `create` ops carry full file content in `diff` with no +/- markers;
+			// pass that content through whole.
+			const added = extractAddedLines(edit.diff, true);
+			digest = digest === undefined ? added : `${digest}\n${added}`;
+		}
+		return digest;
+	},
 };
 
 interface HashlineArgs {
@@ -378,6 +431,12 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 		// than a sigil dump.
 		return "";
 	},
+	matcherDigest(args) {
+		const input = args?.input;
+		if (typeof input !== "string") return undefined;
+		// Body rows are `+TEXT`; headers and op lines are grammar, never content.
+		return extractAddedLines(input, false);
+	},
 };
 
 interface ApplyPatchArgs {
@@ -430,6 +489,12 @@ const applyPatchStrategy: EditStreamingStrategy<ApplyPatchArgs> = {
 	renderStreamingFallback() {
 		return "";
 	},
+	matcherDigest(args) {
+		const input = args?.input;
+		if (typeof input !== "string") return undefined;
+		// Envelope markers and `@@` hunk headers are grammar, never content.
+		return extractAddedLines(input, false);
+	},
 };
 export const EDIT_MODE_STRATEGIES: Record<EditMode, EditStreamingStrategy<unknown>> = {
 	replace: replaceStrategy as EditStreamingStrategy<unknown>,

package/src/eval/__tests__/agent-bridge.test.ts

@@ -106,6 +106,7 @@ function singleResult(options: ExecutorOptions, overrides: Partial<SingleResult>
 function makeEvalSession(
 	tempDir: TempDir,
 	prefix: string,
+	settings?: Settings,
 ): { session: ToolSession; sessionFile: string; sessionId: string } {
 	const sessionFile = path.join(tempDir.path(), "session.jsonl");
 	const artifactsDir = sessionFile.slice(0, -6);
@@ -113,6 +114,7 @@ function makeEvalSession(
 		cwd: tempDir.path(),
 		sessionFile,
 		artifactsDir,
+		settings,
 		outputManager: new AgentOutputManager(() => artifactsDir),
 	});
 	return { session, sessionFile, sessionId: `${prefix}:${crypto.randomUUID()}` };
@@ -261,9 +263,15 @@ describe("agent() through eval runtimes", () => {
 		expect(JSON.parse(result.output.trim())).toEqual(["hello from agent", { ok: true, n: 3 }]);
 	});
 
-	it("runs JavaScript parallel() with bounded concurrency while preserving order", async () => {
+	it("bounds JavaScript parallel() by the task.maxConcurrency setting while preserving order", async () => {
 		using tempDir = TempDir.createSync("@omp-eval-agent-js-parallel-");
-		const { session, sessionFile, sessionId } = makeEvalSession(tempDir, "js-agent-parallel");
+		const settings = Settings.isolated({
+			"async.enabled": false,
+			"task.isolation.mode": "none",
+			"task.enableLsp": true,
+			"task.maxConcurrency": 2,
+		});
+		const { session, sessionFile, sessionId } = makeEvalSession(tempDir, "js-agent-parallel", settings);
 		mockAgents();
 		let inFlight = 0;
 		let maxInFlight = 0;
@@ -279,7 +287,7 @@ describe("agent() through eval runtimes", () => {
 		});
 
 		const result = await executeJs(
-			'const values = await parallel(["a", "b", "c", "d"].map(name => () => agent(name)), { concurrency: 2 }); return JSON.stringify(values);',
+			'const values = await parallel(["a", "b", "c", "d"].map(name => () => agent(name))); return JSON.stringify(values);',
 			{ cwd: tempDir.path(), sessionId, session, sessionFile },
 		);
 
@@ -300,7 +308,7 @@ describe("agent() through eval runtimes", () => {
 			return singleResult(options, { output: options.assignment ?? "" });
 		});
 
-		const result = await executeJs('await parallel([() => agent("ok"), () => agent("bad")], { concurrency: 2 });', {
+		const result = await executeJs('await parallel([() => agent("ok"), () => agent("bad")]);', {
 			cwd: tempDir.path(),
 			sessionId,
 			session,
@@ -343,6 +351,52 @@ describe("agent() through eval runtimes", () => {
 		expect(result.output.trim()).toBe("hello from python");
 	});
 
+	it("bounds Python parallel() by the task.maxConcurrency setting while preserving order", async () => {
+		using tempDir = TempDir.createSync("@omp-eval-agent-py-parallel-");
+		const settings = Settings.isolated({
+			"async.enabled": false,
+			"task.isolation.mode": "none",
+			"task.enableLsp": true,
+			"task.maxConcurrency": 2,
+		});
+		const { session, sessionFile, sessionId } = makeEvalSession(tempDir, "py-agent-parallel", settings);
+		mockAgents();
+		let inFlight = 0;
+		let maxInFlight = 0;
+		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
+			inFlight++;
+			maxInFlight = Math.max(maxInFlight, inFlight);
+			try {
+				await Bun.sleep(options.assignment === "a" ? 30 : 10);
+				return singleResult(options, { output: options.assignment ?? "" });
+			} finally {
+				inFlight--;
+			}
+		});
+
+		const probe = await executePython('print("probe")', {
+			cwd: tempDir.path(),
+			sessionId: `${sessionId}:probe`,
+			sessionFile,
+			kernelMode: "per-call",
+		});
+		if (probe.exitCode === undefined && probe.cancelled) {
+			expect(probe.output).toBe("");
+			return;
+		}
+		expect(probe.exitCode).toBe(0);
+
+		const result = await executePython(
+			'import json\nprint(json.dumps(parallel([lambda n=n: agent(n) for n in ["a", "b", "c", "d"]])))',
+			{ cwd: tempDir.path(), sessionId, sessionFile, kernelMode: "per-call", toolSession: session },
+		);
+
+		expect(result.exitCode).toBe(0);
+		expect(JSON.parse(result.output.trim())).toEqual(["a", "b", "c", "d"]);
+		expect(maxInFlight).toBeGreaterThan(1);
+		expect(maxInFlight).toBeLessThanOrEqual(2);
+	});
+
 	it("streams enriched agent progress through onStatus before the cell finishes", async () => {
 		using tempDir = TempDir.createSync("@omp-eval-agent-progress-");
 		const { session, sessionFile, sessionId } = makeEvalSession(tempDir, "js-agent-progress");

package/src/eval/concurrency-bridge.ts

@@ -0,0 +1,34 @@
+/**
+ * Host-side handler for the eval `parallel()` / `pipeline()` worker pool.
+ *
+ * The pool ceiling is not a kernel-side knob: it tracks the `task.maxConcurrency`
+ * setting so an eval fan-out runs as wide as a `task` tool batch would. `0` means
+ * unbounded — run every item at once, exactly like `task.maxConcurrency = 0`.
+ */
+import type { ToolSession } from "../tools";
+import type { JsStatusEvent } from "./js/shared/types";
+
+/** Synthetic bridge name reserved for the parallel-pool ceiling across both runtimes. */
+export const EVAL_CONCURRENCY_BRIDGE_NAME = "__concurrency__";
+
+export interface EvalConcurrencyBridgeOptions {
+	session: ToolSession;
+	signal?: AbortSignal;
+	emitStatus?: (event: JsStatusEvent) => void;
+}
+
+export interface EvalConcurrencyResult {
+	/** Worker-pool ceiling; `0` means unbounded (run every item at once). */
+	limit: number;
+}
+
+/**
+ * Resolve the worker-pool ceiling for an eval cell's `parallel()`/`pipeline()`
+ * helpers from the live `task.maxConcurrency` setting. Negative/non-finite
+ * values collapse to `0` (unbounded), matching the `task` tool's own handling.
+ */
+export function runEvalConcurrency(_args: unknown, options: EvalConcurrencyBridgeOptions): EvalConcurrencyResult {
+	const raw = options.session.settings.get("task.maxConcurrency");
+	const limit = Number.isFinite(raw) ? Math.trunc(raw) : 0;
+	return { limit: limit > 0 ? limit : 0 };
+}