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

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;
@@ -122,6 +123,10 @@ export const KEYBINDINGS = {
 		defaultKeys: process.platform === "win32" ? "alt+v" : "ctrl+v",
 		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 +219,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/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/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/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 };
+}

package/src/eval/js/shared/prelude.txt

@@ -55,15 +55,24 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 		return hasOwn(o, "schema") ? JSON.parse(text) : text;
 	};
 
-	const normalizeConcurrency = value => {
-		const number = Number(value ?? 4);
-		if (!Number.isFinite(number)) return 4;
-		return Math.max(1, Math.min(16, Math.trunc(number)));
+	// Pool ceiling mirrors the task tool's `task.maxConcurrency` setting so an
+	// eval fan-out runs as wide as a `task` batch would. 0 (and any non-finite
+	// reply) means unbounded — run every item at once.
+	const __concurrencyLimit = async () => {
+		try {
+			const r = await globalThis.__omp_call_tool__("__concurrency__", {});
+			const n = Math.trunc(Number(r && typeof r === "object" ? r.limit : r));
+			return Number.isFinite(n) && n > 0 ? n : 0;
+		} catch {
+			return 0;
+		}
 	};
 
-	const __pool = async (items, limit, fn) => {
+	const __pool = async (items, fn) => {
 		const list = Array.from(items ?? []);
-		const concurrency = Math.min(normalizeConcurrency(limit), list.length);
+		if (list.length === 0) return [];
+		const limit = await __concurrencyLimit();
+		const concurrency = limit > 0 ? Math.min(limit, list.length) : list.length;
 		const results = new Array(list.length);
 		let next = 0;
 		const worker = async () => {
@@ -77,23 +86,17 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 		return results;
 	};
 
-	const parallel = async (thunks, opts = {}) =>
-		__pool(thunks, toOptions(opts).concurrency, (thunk, index) => {
+	const parallel = async thunks =>
+		__pool(thunks, (thunk, index) => {
 			if (typeof thunk !== "function") throw new TypeError("parallel() expects an iterable of functions");
 			return thunk(index);
 		});
 
-	const pipeline = async (items, ...stagesAndOptions) => {
-		let opts = {};
-		const last = stagesAndOptions.at(-1);
-		if (last && typeof last === "object" && !Array.isArray(last)) {
-			opts = last;
-			stagesAndOptions = stagesAndOptions.slice(0, -1);
-		}
+	const pipeline = async (items, ...stages) => {
 		let current = Array.from(items ?? []);
-		for (const stage of stagesAndOptions) {
+		for (const stage of stages) {
 			if (typeof stage !== "function") throw new TypeError("pipeline() stages must be functions");
-			current = await __pool(current, toOptions(opts).concurrency, stage);
+			current = await __pool(current, stage);
 		}
 		return current;
 	};

package/src/eval/js/tool-bridge.ts

@@ -3,6 +3,7 @@ import type { ToolSession } from "../../tools";
 import { ToolError } from "../../tools/tool-errors";
 import { EVAL_AGENT_BRIDGE_NAME, runEvalAgent } from "../agent-bridge";
 import { EVAL_BUDGET_BRIDGE_NAME, type EvalBudgetResult, runEvalBudget } from "../budget-bridge";
+import { EVAL_CONCURRENCY_BRIDGE_NAME, type EvalConcurrencyResult, runEvalConcurrency } from "../concurrency-bridge";
 import { EVAL_LLM_BRIDGE_NAME, runEvalLlm } from "../llm-bridge";
 import type { JsStatusEvent } from "./shared/types";
 
@@ -17,6 +18,7 @@ interface ToolBridgeOptions {
 type ToolValue =
 	| string
 	| EvalBudgetResult
+	| EvalConcurrencyResult
 	| {
 			text: string;
 			details?: unknown;
@@ -114,6 +116,9 @@ export async function callSessionTool(name: string, args: unknown, options: Tool
 	if (name === EVAL_BUDGET_BRIDGE_NAME) {
 		return await runEvalBudget(args, options);
 	}
+	if (name === EVAL_CONCURRENCY_BRIDGE_NAME) {
+		return runEvalConcurrency(args, options);
+	}
 	const tool = getTool(options.session, name);
 	const normalizedArgs = normalizeArgs(args);
 	const toolCallId = `js-${name}-${crypto.randomUUID()}`;

package/src/eval/py/prelude.py

@@ -503,27 +503,35 @@ if "__omp_prelude_loaded__" not in globals():
         text = res.get("text") if isinstance(res, dict) else res
         return json.loads(text) if schema is not None else text
 
-    def _normalize_concurrency(value):
-        """Clamp a concurrency hint to [1, 16], defaulting to 4 on bad input."""
+    def _concurrency_limit():
+        """Worker-pool ceiling from the host ``task.maxConcurrency`` setting.
+
+        An eval fan-out runs as wide as a ``task`` batch would. Returns ``0`` for
+        unbounded (run every item at once); falls back to ``0`` if the host
+        bridge is unreachable.
+        """
         try:
-            n = int(value)
-        except (TypeError, ValueError):
-            n = 4
-        return max(1, min(16, n))
+            snap = _bridge_call("__concurrency__", {}) or {}
+            n = int(snap.get("limit") or 0)
+        except Exception:
+            return 0
+        return n if n > 0 else 0
 
-    def _pool_map(items, fn, concurrency):
+    def _pool_map(items, fn):
         """Run ``fn`` over ``items`` through a bounded thread pool.
 
         Preserves input order, barriers until every task settles, and raises the
         lowest-index exception if any task failed. Each task runs inside a copy
         of the submitting thread's context so the ``_CURRENT_RID`` ContextVar
-        propagates and bridge calls (agent(), tool.*, etc.) keep working.
+        propagates and bridge calls (agent(), tool.*, etc.) keep working. The
+        pool width tracks ``task.maxConcurrency`` (0 = run every item at once).
         """
         import concurrent.futures, contextvars
         items = list(items)
         if not items:
             return []
-        workers = min(_normalize_concurrency(concurrency), len(items))
+        limit = _concurrency_limit()
+        workers = min(limit, len(items)) if limit > 0 else len(items)
         results = [None] * len(items)
         errors = {}
         with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as pool:
@@ -541,30 +549,30 @@ if "__omp_prelude_loaded__" not in globals():
             raise errors[min(errors)]
         return results
 
-    def parallel(thunks, *, concurrency=4):
+    def parallel(thunks):
         """Run zero-arg callables through a bounded pool, preserving input order.
 
         Barriers until all finish; re-raises the lowest-index exception if any
-        thunk raised.
+        thunk raised. Pool width tracks the task tool's ``task.maxConcurrency``.
         """
         thunks = list(thunks)
         for t in thunks:
             if not callable(t):
                 raise TypeError("parallel() expects an iterable of zero-arg callables")
-        return _pool_map(thunks, lambda t: t(), concurrency)
+        return _pool_map(thunks, lambda t: t())
 
-    def pipeline(items, *stages, concurrency=4):
+    def pipeline(items, *stages):
         """Map items left-to-right through one-arg stage callables.
 
         Every item clears stage N before any item enters stage N+1 (barrier per
         stage). Stage 1 receives the original item; later stages receive the
-        previous stage's result.
+        previous stage's result. Pool width tracks ``task.maxConcurrency``.
         """
         current = list(items)
         for stage in stages:
             if not callable(stage):
                 raise TypeError("pipeline() stages must be callables")
-            current = _pool_map(current, stage, concurrency)
+            current = _pool_map(current, stage)
         return current
 
     def log(message):