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

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):

package/src/export/ttsr.ts

@@ -339,7 +339,24 @@ export class TtsrManager {
 		const bufferKey = this.#bufferKey(context);
 		const nextBuffer = `${this.#buffers.get(bufferKey) ?? ""}${delta}`;
 		this.#buffers.set(bufferKey, nextBuffer);
+		return this.#matchBuffer(nextBuffer, context);
+	}
+
+	/**
+	 * Replace the scoped buffer with a tool-provided normalized snapshot and
+	 * return matching rules.
+	 *
+	 * Used for tools exposing `matcherDigest`: the digest is recomputed from the
+	 * full (partial) arguments on every delta, so it replaces the buffer instead
+	 * of being appended to it.
+	 */
+	checkSnapshot(snapshot: string, context: TtsrMatchContext): Rule[] {
+		const bufferKey = this.#bufferKey(context);
+		this.#buffers.set(bufferKey, snapshot);
+		return this.#matchBuffer(snapshot, context);
+	}
 
+	#matchBuffer(buffer: string, context: TtsrMatchContext): Rule[] {
 		const matches: Rule[] = [];
 		for (const [name, entry] of this.#rules) {
 			if (!this.#canTrigger(name)) {
@@ -351,7 +368,7 @@ export class TtsrManager {
 			if (!this.#matchesGlobalPaths(entry, context)) {
 				continue;
 			}
-			if (!this.#matchesCondition(entry, nextBuffer)) {
+			if (!this.#matchesCondition(entry, buffer)) {
 				continue;
 			}
 

package/src/extensibility/custom-commands/bundled/review/index.ts

@@ -7,7 +7,7 @@
  * 3. Review a specific commit
  * 4. Custom review instructions
  *
- * Runs git diff upfront, parses results, filters noise, and provides
+ * Runs VCS diffs upfront, parses results, filters noise, and provides
  * rich context for the orchestrating agent to distribute work across
  * multiple reviewer agents based on diff weight and locality.
  */
@@ -18,6 +18,7 @@ import reviewCustomRequestTemplate from "../../../../prompts/review-custom-reque
 import reviewHeadlessRequestTemplate from "../../../../prompts/review-headless-request.md" with { type: "text" };
 import reviewRequestTemplate from "../../../../prompts/review-request.md" with { type: "text" };
 import * as git from "../../../../utils/git";
+import * as jj from "../../../../utils/jj";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Types
@@ -37,6 +38,13 @@ interface DiffStats {
 	excluded: { path: string; reason: string; linesAdded: number; linesRemoved: number }[];
 }
 
+interface CurrentReviewDiff {
+	diffInstruction: string;
+	diffText: string;
+	emptyMessage?: string;
+	mode: string;
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Exclusion patterns for noise files
 // ─────────────────────────────────────────────────────────────────────────────
@@ -195,11 +203,20 @@ function getDiffPreview(hunks: string, maxLines: number): string {
 // Thresholds for diff inclusion
 const MAX_DIFF_CHARS = 50_000; // Don't include diff above this
 const MAX_FILES_FOR_INLINE_DIFF = 20; // Don't include diff if more files than this
+const DEFAULT_LARGE_DIFF_INSTRUCTION = "MUST run `git diff`/`git show` for assigned files";
+const GIT_UNCOMMITTED_DIFF_INSTRUCTION =
+	"MUST run both `git diff -- <path>` and `git diff --cached -- <path>` for assigned files";
+const JJ_UNCOMMITTED_DIFF_INSTRUCTION = "MUST run `jj --ignore-working-copy diff --git -- <path>` for assigned files";
 
 /**
  * Build the full review prompt with diff stats and distribution guidance.
  */
-function buildReviewPrompt(mode: string, stats: DiffStats, rawDiff: string, additionalInstructions?: string): string {
+function buildReviewPrompt(
+	mode: string,
+	stats: DiffStats,
+	rawDiff: string,
+	options: { additionalInstructions?: string; diffInstruction?: string } = {},
+): string {
 	const agentCount = getRecommendedAgentCount(stats);
 	const skipDiff = rawDiff.length > MAX_DIFF_CHARS || stats.files.length > MAX_FILES_FOR_INLINE_DIFF;
 	const totalLines = stats.totalAdded + stats.totalRemoved;
@@ -223,7 +240,8 @@ function buildReviewPrompt(mode: string, stats: DiffStats, rawDiff: string, addi
 		skipDiff,
 		rawDiff: rawDiff.trim(),
 		linesPerFile,
-		additionalInstructions,
+		additionalInstructions: options.additionalInstructions,
+		diffInstruction: options.diffInstruction ?? DEFAULT_LARGE_DIFF_INSTRUCTION,
 	});
 }
 
@@ -305,49 +323,32 @@ export class ReviewCommand implements CustomCommand {
 					`Reviewing changes between \`${baseBranch}\` and \`${currentBranch}\` (PR-style)`,
 					stats,
 					diffText,
-					extraInstructions,
+					{ additionalInstructions: extraInstructions },
 				);
 			}
 
 			case 2: {
-				// Uncommitted changes - combine staged and unstaged
-				const status = await getGitStatus(this.api);
-				if (!status.trim()) {
-					ctx.ui.notify("No uncommitted changes found", "warning");
-					return undefined;
-				}
-
-				let unstagedDiff: string;
-				let stagedDiff: string;
-				try {
-					[unstagedDiff, stagedDiff] = await Promise.all([
-						git.diff(this.api.cwd),
-						git.diff(this.api.cwd, { cached: true }),
-					]);
-				} catch (err) {
+				const reviewDiff = await getUncommittedReviewDiff(this.api).catch(err => {
 					ctx.ui.notify(`Failed to get diff: ${err instanceof Error ? err.message : String(err)}`, "error");
 					return undefined;
-				}
+				});
+				if (!reviewDiff) return undefined;
 
-				const combinedDiff = [unstagedDiff, stagedDiff].filter(Boolean).join("\n");
-
-				if (!combinedDiff.trim()) {
-					ctx.ui.notify("No diff content found", "warning");
+				if (!reviewDiff.diffText.trim()) {
+					ctx.ui.notify(reviewDiff.emptyMessage ?? "No diff content found", "warning");
 					return undefined;
 				}
 
-				const stats = parseDiff(combinedDiff);
+				const stats = parseDiff(reviewDiff.diffText);
 				if (stats.files.length === 0) {
 					ctx.ui.notify("No reviewable files (all changes filtered out)", "warning");
 					return undefined;
 				}
 
-				return buildReviewPrompt(
-					"Reviewing uncommitted changes (staged + unstaged)",
-					stats,
-					combinedDiff,
-					extraInstructions,
-				);
+				return buildReviewPrompt(reviewDiff.mode, stats, reviewDiff.diffText, {
+					additionalInstructions: extraInstructions,
+					diffInstruction: reviewDiff.diffInstruction,
+				});
 			}
 
 			case 3: {
@@ -383,11 +384,13 @@ export class ReviewCommand implements CustomCommand {
 					return undefined;
 				}
 
-				return buildReviewPrompt(`Reviewing commit \`${hash}\``, stats, diffText, extraInstructions);
+				return buildReviewPrompt(`Reviewing commit \`${hash}\``, stats, diffText, {
+					additionalInstructions: extraInstructions,
+				});
 			}
 
 			case 4: {
-				// Custom instructions - still uses the old approach since user provides context
+				// Custom instructions with opportunistic current-diff context.
 				const instructions = await ctx.ui.editor(
 					"Enter custom review instructions",
 					"Review the following:\n\n",
@@ -396,23 +399,19 @@ export class ReviewCommand implements CustomCommand {
 				);
 				if (!instructions?.trim()) return undefined;
 
-				// For custom, we still try to get current diff for context
-				let diffText: string | undefined;
-				try {
-					diffText = await git.diff(this.api.cwd, { base: "HEAD" });
-				} catch {
-					diffText = undefined;
-				}
-				const reviewDiff = diffText?.trim();
+				const reviewDiff = await getUncommittedReviewDiff(this.api).catch(() => undefined);
 
-				if (reviewDiff) {
-					const stats = parseDiff(reviewDiff);
+				if (reviewDiff?.diffText.trim()) {
+					const stats = parseDiff(reviewDiff.diffText);
 					// Even if all files filtered, include the custom instructions
 					return buildReviewPrompt(
 						`Custom review: ${instructions.split("\n")[0].slice(0, 60)}…`,
 						stats,
-						reviewDiff,
-						instructions,
+						reviewDiff.diffText,
+						{
+							additionalInstructions: instructions,
+							diffInstruction: reviewDiff.diffInstruction,
+						},
 					);
 				}
 
@@ -449,6 +448,36 @@ async function getGitStatus(api: CustomCommandAPI): Promise<string> {
 	}
 }
 
+async function getUncommittedReviewDiff(api: CustomCommandAPI): Promise<CurrentReviewDiff> {
+	if (await jj.repo.is(api.cwd)) {
+		return {
+			diffText: await jj.diff(api.cwd),
+			diffInstruction: JJ_UNCOMMITTED_DIFF_INSTRUCTION,
+			emptyMessage: "No uncommitted changes found",
+			mode: "Reviewing JJ working-copy changes",
+		};
+	}
+
+	const status = await getGitStatus(api);
+	if (!status.trim()) {
+		return {
+			diffText: "",
+			diffInstruction: GIT_UNCOMMITTED_DIFF_INSTRUCTION,
+			emptyMessage: "No uncommitted changes found",
+			mode: "Reviewing uncommitted changes (staged + unstaged)",
+		};
+	}
+
+	const [unstagedDiff, stagedDiff] = await Promise.all([git.diff(api.cwd), git.diff(api.cwd, { cached: true })]);
+	const combinedDiff = [unstagedDiff, stagedDiff].filter(Boolean).join("\n");
+	return {
+		diffText: combinedDiff,
+		diffInstruction: GIT_UNCOMMITTED_DIFF_INSTRUCTION,
+		emptyMessage: "No diff content found",
+		mode: "Reviewing uncommitted changes (staged + unstaged)",
+	};
+}
+
 async function getRecentCommits(api: CustomCommandAPI, count: number): Promise<string[]> {
 	try {
 		return await git.log.onelines(api.cwd, count);