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

package/src/session/history-storage.ts

@@ -8,6 +8,8 @@ export interface HistoryEntry {
 	prompt: string;
 	created_at: number;
 	cwd?: string;
+	/** ID of the session the prompt was submitted from, if known. */
+	sessionId?: string;
 }
 
 type HistoryRow = {
@@ -15,6 +17,7 @@ type HistoryRow = {
 	prompt: string;
 	created_at: number;
 	cwd: string | null;
+	session_id: string | null;
 };
 
 const SQLITE_NOW_EPOCH = "CAST(strftime('%s','now') AS INTEGER)";
@@ -62,7 +65,8 @@ class AsyncDrain<T> {
 export class HistoryStorage {
 	#db: Database;
 	static #instance?: HistoryStorage;
-	#drain = new AsyncDrain<Pick<HistoryEntry, "prompt" | "cwd">>(100);
+	#drain = new AsyncDrain<Pick<HistoryEntry, "prompt" | "cwd" | "sessionId">>(100);
+	#sessionResolver?: () => string | undefined;
 
 	// Prepared statements
 	#insertRowStmt: Statement;
@@ -91,7 +95,8 @@ CREATE TABLE IF NOT EXISTS history (
 	id INTEGER PRIMARY KEY AUTOINCREMENT,
 	prompt TEXT NOT NULL,
 	created_at INTEGER NOT NULL DEFAULT (${SQLITE_NOW_EPOCH}),
-	cwd TEXT
+	cwd TEXT,
+	session_id TEXT
 );
 CREATE INDEX IF NOT EXISTS idx_history_created_at ON history(created_at DESC);
 
@@ -106,6 +111,10 @@ CREATE TRIGGER IF NOT EXISTS history_ai AFTER INSERT ON history BEGIN
 			this.#migrateHistorySchema();
 		}
 
+		if (!this.#historySchemaHasColumn("session_id")) {
+			this.#db.run("ALTER TABLE history ADD COLUMN session_id TEXT");
+		}
+
 		if (!hasFts) {
 			try {
 				this.#db.run("INSERT INTO history_fts(history_fts) VALUES('rebuild')");
@@ -115,14 +124,14 @@ CREATE TRIGGER IF NOT EXISTS history_ai AFTER INSERT ON history BEGIN
 		}
 
 		this.#recentStmt = this.#db.prepare(
-			"SELECT id, prompt, created_at, cwd FROM history ORDER BY created_at DESC, id DESC LIMIT ?",
+			"SELECT id, prompt, created_at, cwd, session_id FROM history ORDER BY created_at DESC, id DESC LIMIT ?",
 		);
 		this.#searchStmt = this.#db.prepare(
-			"SELECT h.id, h.prompt, h.created_at, h.cwd FROM history_fts f JOIN history h ON h.id = f.rowid WHERE history_fts MATCH ? ORDER BY h.created_at DESC, h.id DESC LIMIT ?",
+			"SELECT h.id, h.prompt, h.created_at, h.cwd, h.session_id FROM history_fts f JOIN history h ON h.id = f.rowid WHERE history_fts MATCH ? ORDER BY h.created_at DESC, h.id DESC LIMIT ?",
 		);
 		this.#lastPromptStmt = this.#db.prepare("SELECT prompt FROM history ORDER BY id DESC LIMIT 1");
 
-		this.#insertRowStmt = this.#db.prepare("INSERT INTO history (prompt, cwd) VALUES (?, ?)");
+		this.#insertRowStmt = this.#db.prepare("INSERT INTO history (prompt, cwd, session_id) VALUES (?, ?, ?)");
 
 		const last = this.#lastPromptStmt.get() as { prompt?: string } | undefined;
 		this.#lastPromptCache = last?.prompt ?? null;
@@ -140,20 +149,30 @@ CREATE TRIGGER IF NOT EXISTS history_ai AFTER INSERT ON history BEGIN
 		HistoryStorage.#instance = undefined;
 	}
 
-	#insertBatch(rows: Array<Pick<HistoryEntry, "prompt" | "cwd">>): void {
-		this.#db.transaction((rows: Array<Pick<HistoryEntry, "prompt" | "cwd">>) => {
+	#insertBatch(rows: Array<Pick<HistoryEntry, "prompt" | "cwd" | "sessionId">>): void {
+		this.#db.transaction((rows: Array<Pick<HistoryEntry, "prompt" | "cwd" | "sessionId">>) => {
 			for (const row of rows) {
-				this.#insertRowStmt.run(row.prompt, row.cwd ?? null);
+				this.#insertRowStmt.run(row.prompt, row.cwd ?? null, row.sessionId ?? null);
 			}
 		})(rows);
 	}
 
-	add(prompt: string, cwd?: string): Promise<void> {
+	/**
+	 * Register a resolver that supplies the current session ID for prompts added
+	 * without an explicit `sessionId`. Evaluated synchronously at `add()` time so
+	 * batched writes capture the session active when the prompt was submitted.
+	 */
+	setSessionResolver(resolver: () => string | undefined): void {
+		this.#sessionResolver = resolver;
+	}
+
+	add(prompt: string, cwd?: string, sessionId?: string): Promise<void> {
 		const trimmed = prompt.trim();
 		if (!trimmed) return Promise.resolve();
 		if (this.#lastPromptCache === trimmed) return Promise.resolve();
 		this.#lastPromptCache = trimmed;
-		return this.#drain.push({ prompt: trimmed, cwd: cwd ?? undefined }, rows => {
+		const session = sessionId ?? this.#sessionResolver?.();
+		return this.#drain.push({ prompt: trimmed, cwd: cwd ?? undefined, sessionId: session || undefined }, rows => {
 			this.#insertBatch(rows);
 		});
 	}
@@ -224,6 +243,24 @@ CREATE TRIGGER IF NOT EXISTS history_ai AFTER INSERT ON history BEGIN
 		return merged;
 	}
 
+	/**
+	 * IDs of the sessions whose stored prompts match `query`, ordered by match
+	 * relevance (most relevant/recent first) and de-duplicated. Prompts with no
+	 * recorded session are skipped. Used to augment session ranking in the
+	 * resume picker with prompts that the 4KB session-list prefix never sees.
+	 */
+	matchingSessionIds(query: string, limit = 500): string[] {
+		const seen = new Set<string>();
+		const ids: string[] = [];
+		for (const entry of this.search(query, limit)) {
+			const id = entry.sessionId;
+			if (!id || seen.has(id)) continue;
+			seen.add(id);
+			ids.push(id);
+		}
+		return ids;
+	}
+
 	#ensureDir(dbPath: string): void {
 		const dir = path.dirname(dbPath);
 		fs.mkdirSync(dir, { recursive: true });
@@ -236,6 +273,11 @@ CREATE TRIGGER IF NOT EXISTS history_ai AFTER INSERT ON history BEGIN
 		return row?.sql?.includes("unixepoch(") ?? false;
 	}
 
+	#historySchemaHasColumn(column: string): boolean {
+		const columns = this.#db.prepare("PRAGMA table_info(history)").all() as Array<{ name: string }>;
+		return columns.some(col => col.name === column);
+	}
+
 	#migrateHistorySchema(): void {
 		const migrate = this.#db.transaction(() => {
 			this.#db.run("ALTER TABLE history RENAME TO history_legacy");
@@ -247,7 +289,8 @@ CREATE TABLE history (
 	id INTEGER PRIMARY KEY AUTOINCREMENT,
 	prompt TEXT NOT NULL,
 	created_at INTEGER NOT NULL DEFAULT (${SQLITE_NOW_EPOCH}),
-	cwd TEXT
+	cwd TEXT,
+	session_id TEXT
 );
 CREATE INDEX IF NOT EXISTS idx_history_created_at ON history(created_at DESC);
 INSERT INTO history (id, prompt, created_at, cwd)
@@ -294,7 +337,7 @@ END;
 		if (stmt) return stmt;
 		const whereClause = Array(tokenCount).fill("prompt LIKE ? ESCAPE '\\' COLLATE NOCASE").join(" AND ");
 		stmt = this.#db.prepare(
-			`SELECT id, prompt, created_at, cwd FROM history WHERE ${whereClause} ORDER BY created_at DESC, id DESC LIMIT ?`,
+			`SELECT id, prompt, created_at, cwd, session_id FROM history WHERE ${whereClause} ORDER BY created_at DESC, id DESC LIMIT ?`,
 		);
 		this.#substringStmts.set(tokenCount, stmt);
 		return stmt;
@@ -306,6 +349,7 @@ END;
 			prompt: row.prompt,
 			created_at: row.created_at,
 			cwd: row.cwd ?? undefined,
+			sessionId: row.session_id ?? undefined,
 		};
 	}
 }

package/src/session/session-manager.ts

@@ -254,6 +254,22 @@ export interface SessionContext {
 	modeData?: Record<string, unknown>;
 }
 
+/** Lists session model strings to try when restoring, in fallback order. */
+export function getRestorableSessionModels(
+	models: Readonly<Record<string, string>>,
+	lastModelChangeRole: string | undefined,
+): string[] {
+	const defaultModel = models.default;
+	if (!lastModelChangeRole || lastModelChangeRole === "default" || lastModelChangeRole === "temporary") {
+		return defaultModel ? [defaultModel] : [];
+	}
+
+	const roleModel = models[lastModelChangeRole];
+	if (!roleModel) return defaultModel ? [defaultModel] : [];
+	if (!defaultModel || roleModel === defaultModel) return [roleModel];
+	return [roleModel, defaultModel];
+}
+
 export interface SessionInfo {
 	path: string;
 	id: string;
@@ -1808,6 +1824,8 @@ export async function resolveResumableSession(
 	return { session: globalMatch, scope: "global" };
 }
 interface SessionManagerStateSnapshot {
+	cwd: string;
+	sessionDir: string;
 	sessionId: string;
 	sessionName: string | undefined;
 	titleSource: "auto" | "user" | undefined;
@@ -1880,6 +1898,8 @@ export class SessionManager {
 
 	captureState(): SessionManagerStateSnapshot {
 		return {
+			cwd: this.cwd,
+			sessionDir: this.sessionDir,
 			sessionId: this.#sessionId,
 			sessionName: this.#sessionName,
 			titleSource: this.#titleSource,
@@ -1893,6 +1913,8 @@ export class SessionManager {
 	}
 
 	restoreState(snapshot: SessionManagerStateSnapshot): void {
+		this.cwd = snapshot.cwd;
+		this.sessionDir = snapshot.sessionDir;
 		this.#sessionId = snapshot.sessionId;
 		this.#sessionName = snapshot.sessionName;
 		this.#titleSource = snapshot.titleSource;
@@ -1938,6 +1960,18 @@ export class SessionManager {
 			this.#sessionName = header?.title;
 			this.#titleSource = header?.titleSource;
 
+			// Adopt the loaded session's own working directory. Sessions are stored in
+			// a directory keyed by their cwd, so resuming a session from another
+			// project (e.g. global review in the picker) must re-point cwd/sessionDir
+			// at that project. Same-cwd resumes and in-place reloads are a no-op; old
+			// sessions with no recorded cwd keep the current cwd.
+			const headerCwd = header?.cwd ? path.resolve(header.cwd) : undefined;
+			if (headerCwd && headerCwd !== this.cwd) {
+				this.cwd = headerCwd;
+				this.sessionDir = path.resolve(this.#sessionFile, "..");
+				writeTerminalBreadcrumb(this.cwd, this.#sessionFile);
+			}
+
 			this.#needsFullRewriteOnNextPersist = migrateToCurrentVersion(this.#fileEntries);
 
 			await resolveBlobRefsInEntries(this.#fileEntries, this.#blobStore);

package/src/task/output-manager.ts

@@ -1,29 +1,28 @@
 /**
  * Session-scoped manager for agent output IDs.
  *
- * Ensures unique output IDs across task tool invocations within a session.
- * Prefixes each ID with a sequential number (e.g., "0-AuthProvider", "1-AuthApi").
- * If a parent prefix is provided, IDs are nested (e.g., "0-Auth.1-Subtask").
+ * Keeps every subagent output id unique within a session without polluting the
+ * common case with bookkeeping. A requested name is used verbatim the first
+ * time it appears; only a *repeated* name gets a numeric suffix to disambiguate
+ * it (e.g. "Anna", "Anna-2", "Anna-3"). When a parent prefix is configured, ids
+ * are nested under it (e.g. "Anna.Bob") so hierarchical outputs stay grouped.
  *
- * This enables reliable agent:// URL resolution and prevents artifact collisions.
+ * This enables reliable agent:// URL resolution and prevents artifact
+ * collisions across repeated or nested task invocations.
  */
 import * as fs from "node:fs/promises";
 
-function escapeRegExp(value: string): string {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
 /**
  * Manages agent output ID allocation to ensure uniqueness.
  *
- * Each allocated ID gets a numeric prefix based on allocation order.
- * If configured with a parent prefix, the numeric prefix is appended after
- * the parent (e.g., "0-Parent.0-Child").
- * On resume, scans existing files to find the next available index.
+ * The first allocation of a given name keeps the name as-is; subsequent
+ * allocations of the same name get a `-2`, `-3`, … suffix. On resume, scans
+ * existing output files so previously written outputs are never overwritten.
  */
 export class AgentOutputManager {
-	#nextId = 0;
 	#initialized = false;
+	/** Final ids already handed out, relative to this manager's scope. */
+	readonly #taken = new Set<string>();
 	readonly #getArtifactsDir: () => string | null;
 	readonly #parentPrefix: string | undefined;
 
@@ -33,8 +32,8 @@ export class AgentOutputManager {
 	}
 
 	/**
-	 * Scan existing agent output files to find the next available ID.
-	 * This ensures we don't overwrite outputs when resuming a session.
+	 * Seed the taken-id set from output files already on disk so a resumed
+	 * session never reuses a name that would clobber a prior subagent's output.
 	 */
 	async #ensureInitialized(): Promise<void> {
 		if (this.#initialized) return;
@@ -50,31 +49,41 @@ export class AgentOutputManager {
 			return; // Directory doesn't exist yet
 		}
 
-		const pattern = this.#parentPrefix
-			? new RegExp(`^${escapeRegExp(this.#parentPrefix)}\\.(\\d+)-.*\\.md$`)
-			: /^(\d+)-.*\.md$/;
-
-		let maxId = -1;
+		const prefix = this.#parentPrefix ? `${this.#parentPrefix}.` : "";
 		for (const file of files) {
-			const match = file.match(pattern);
-			if (match) {
-				const id = Number.parseInt(match[1], 10);
-				if (id > maxId) maxId = id;
+			if (!file.endsWith(".md")) continue;
+			let rest = file.slice(0, -3); // drop ".md"
+			if (prefix) {
+				if (!rest.startsWith(prefix)) continue;
+				rest = rest.slice(prefix.length);
 			}
+			// Requested ids never contain "."; a dot marks a nested child, so this
+			// manager only owns the first segment of whatever remains.
+			const dot = rest.indexOf(".");
+			const segment = dot === -1 ? rest : rest.slice(0, dot);
+			if (segment) this.#taken.add(segment);
 		}
-		this.#nextId = maxId + 1;
+	}
+
+	/** Pick the first free name (base, then `base-2`, `base-3`, …) and reserve it. */
+	#allocateUnique(id: string): string {
+		let candidate = id;
+		for (let n = 2; this.#taken.has(candidate); n++) {
+			candidate = `${id}-${n}`;
+		}
+		this.#taken.add(candidate);
+		return this.#parentPrefix ? `${this.#parentPrefix}.${candidate}` : candidate;
 	}
 
 	/**
-	 * Allocate a unique ID with numeric prefix.
+	 * Allocate a unique ID.
 	 *
-	 * @param id Requested ID (e.g., "AuthProvider")
-	 * @returns Unique ID with prefix (e.g., "0-AuthProvider")
+	 * @param id Requested ID (e.g., "Anna")
+	 * @returns Unique ID ("Anna" first, then "Anna-2", "Anna-3", …)
 	 */
 	async allocate(id: string): Promise<string> {
 		await this.#ensureInitialized();
-		const prefix = this.#parentPrefix ? `${this.#parentPrefix}.` : "";
-		return `${prefix}${this.#nextId++}-${id}`;
+		return this.#allocateUnique(id);
 	}
 
 	/**
@@ -85,23 +94,6 @@ export class AgentOutputManager {
 	 */
 	async allocateBatch(ids: string[]): Promise<string[]> {
 		await this.#ensureInitialized();
-		const prefix = this.#parentPrefix ? `${this.#parentPrefix}.` : "";
-		return ids.map(id => `${prefix}${this.#nextId++}-${id}`);
-	}
-
-	/**
-	 * Get the next ID that would be allocated (without allocating).
-	 */
-	async peekNextIndex(): Promise<number> {
-		await this.#ensureInitialized();
-		return this.#nextId;
-	}
-
-	/**
-	 * Reset state (primarily for testing).
-	 */
-	reset(): void {
-		this.#nextId = 0;
-		this.#initialized = false;
+		return ids.map(id => this.#allocateUnique(id));
 	}
 }

package/src/task/render.ts

@@ -128,15 +128,10 @@ function formatJsonScalar(value: unknown, _theme: Theme): string {
 }
 
 function formatTaskId(id: string): string {
+	// Ids are name-based (e.g. "Anna", "Anna-2"); a "." separates nesting levels
+	// (e.g. "Anna.Bob"). Render the hierarchy with a ">" breadcrumb.
 	const segments = id.split(".");
-	if (segments.length < 2) return id;
-
-	const parsed = segments.map(segment => segment.match(/^(\d+)-(.+)$/));
-	if (parsed.some(match => !match)) return id;
-
-	const indices = parsed.map(match => match![1]).join(".");
-	const labels = parsed.map(match => match![2]).join(">");
-	return `${indices} ${labels}`;
+	return segments.length < 2 ? id : segments.join(">");
 }
 
 const MISSING_YIELD_WARNING_PREFIX = "SYSTEM WARNING: Subagent exited without calling yield tool";

package/src/tools/browser/tab-worker.ts

@@ -815,18 +815,21 @@ export class WorkerCore {
 			{ maxWidth: 1024, maxHeight: 1024, maxBytes: 150 * 1024, jpegQuality: 70 },
 		);
 		const explicitPath = opts.save ? resolveToCwd(opts.save, session.cwd) : undefined;
+		const saveFullRes = !!(explicitPath || session.browserScreenshotDir);
+		const savedBuffer = saveFullRes ? buffer : resized.buffer;
+		const savedMimeType = saveFullRes ? "image/png" : resized.mimeType;
+		// Auto-generated names must match the bytes we actually write: full-res is always
+		// PNG, but the resized buffer is whichever of PNG/JPEG/WebP encoded smallest.
+		const ext = savedMimeType === "image/webp" ? "webp" : savedMimeType === "image/jpeg" ? "jpg" : "png";
 		const dest =
 			explicitPath ??
 			(session.browserScreenshotDir
 				? path.join(
 						session.browserScreenshotDir,
-						`screenshot-${new Date().toISOString().replace(/[:.]/g, "-").slice(0, -1)}.png`,
+						`screenshot-${new Date().toISOString().replace(/[:.]/g, "-").slice(0, -1)}.${ext}`,
 					)
-				: path.join(os.tmpdir(), `omp-sshots-${Snowflake.next()}.png`));
+				: path.join(os.tmpdir(), `omp-sshots-${Snowflake.next()}.${ext}`));
 		await fs.promises.mkdir(path.dirname(dest), { recursive: true });
-		const saveFullRes = !!(explicitPath || session.browserScreenshotDir);
-		const savedBuffer = saveFullRes ? buffer : resized.buffer;
-		const savedMimeType = saveFullRes ? "image/png" : resized.mimeType;
 		await Bun.write(dest, savedBuffer);
 		const info: ScreenshotResult = {
 			dest,

package/src/tools/find.ts

@@ -16,6 +16,7 @@ import type { ToolSession } from ".";
 import { applyListLimit } from "./list-limit";
 import { formatFullOutputReference, type OutputMeta } from "./output-meta";
 import {
+	expandDelimitedPathEntries,
 	formatPathRelativeToCwd,
 	hasGlobPathChars,
 	normalizePathLikeInput,
@@ -52,33 +53,6 @@ const DEFAULT_GLOB_TIMEOUT_MS = 5000;
 const MIN_GLOB_TIMEOUT_MS = 500;
 const MAX_GLOB_TIMEOUT_MS = 60_000;
 
-/**
- * Reject comma-separated path lists packed into a single array element
- * (`["a.py,b.py"]`). The schema is array-of-string; agents that pass a
- * single comma-joined element get silent no-matches otherwise.
- *
- * Commas inside brace expansion (`{a,b}`) are legitimate glob syntax and
- * must pass through.
- */
-export function validateFindPathInputs(paths: readonly string[]): void {
-	for (const entry of paths) {
-		let braceDepth = 0;
-		for (let i = 0; i < entry.length; i++) {
-			const ch = entry.charCodeAt(i);
-			if (ch === 0x5c /* \ */ && i + 1 < entry.length) {
-				i++;
-				continue;
-			}
-			if (ch === 0x7b /* { */) braceDepth++;
-			else if (ch === 0x7d /* } */) {
-				if (braceDepth > 0) braceDepth--;
-			} else if (ch === 0x2c /* , */ && braceDepth === 0) {
-				throw new ToolError(`paths is an array — pass ["a", "b"] not ["a,b"] (got ${JSON.stringify(entry)})`);
-			}
-		}
-	}
-}
-
 /**
  * Group find matches by their directory so the model doesn't pay repeated
  * tokens for shared path prefixes. Preserves the input order: groups appear in
@@ -180,8 +154,10 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 
 		return untilAborted(signal, async () => {
 			const formatScopePath = (targetPath: string): string => formatPathRelativeToCwd(targetPath, this.session.cwd);
-			validateFindPathInputs(paths);
-			const rawPatterns = paths.map(input => normalizePathLikeInput(input).replace(/\\/g, "/"));
+			const rawPatternInputs = this.#customOps
+				? paths
+				: await expandDelimitedPathEntries(paths, this.session.cwd, { splitter: parseFindPattern });
+			const rawPatterns = rawPatternInputs.map(input => normalizePathLikeInput(input).replace(/\\/g, "/"));
 			const internalRouter = InternalUrlRouter.instance();
 			const normalizedPatterns: string[] = [];
 			for (const rawPattern of rawPatterns) {

package/src/tools/index.ts

@@ -159,7 +159,7 @@ export interface ToolSession {
 	getHindsightSessionState?: () => HindsightSessionState | undefined;
 	/** Get Mnemopi runtime state for this agent session. */
 	getMnemopiSessionState?: () => MnemopiSessionState | undefined;
-	/** Agent identity used for IRC routing. Returns the registry id (e.g. "0-Main", "0-AuthLoader"). */
+	/** Agent identity used for IRC routing. Returns the registry id (e.g. "Main", "AuthLoader"). */
 	getAgentId?: () => string | null;
 	/** Look up a registered tool by name (used by the eval js backend's tool bridge). */
 	getToolByName?: (name: string) => AgentTool | undefined;

package/src/tools/path-utils.ts

@@ -379,6 +379,145 @@ export function hasGlobPathChars(filePath: string): boolean {
 	return GLOB_PATH_CHARS.some(char => filePath.includes(char));
 }
 
+type PathEntrySplitter = (item: string) => { basePath: string };
+
+const TOP_LEVEL_WHITESPACE_RE = /\s/;
+
+type DelimitedPathSplitMode = "comma" | "semicolon" | "whitespace" | "mixed";
+
+function isDelimitedPathSeparator(ch: string, mode: DelimitedPathSplitMode): boolean {
+	if (mode === "comma") return ch === ",";
+	if (mode === "semicolon") return ch === ";";
+	if (mode === "whitespace") return TOP_LEVEL_WHITESPACE_RE.test(ch);
+	return ch === "," || ch === ";" || TOP_LEVEL_WHITESPACE_RE.test(ch);
+}
+
+function hasTopLevelPathDelimiter(entry: string): boolean {
+	let braceDepth = 0;
+	for (let i = 0; i < entry.length; i++) {
+		const ch = entry[i];
+		if (ch === "\\" && i + 1 < entry.length) {
+			i++;
+			continue;
+		}
+		if (ch === "{") {
+			braceDepth++;
+			continue;
+		}
+		if (ch === "}") {
+			if (braceDepth > 0) braceDepth--;
+			continue;
+		}
+		if (braceDepth === 0 && (ch === "," || ch === ";" || TOP_LEVEL_WHITESPACE_RE.test(ch))) {
+			return true;
+		}
+	}
+	return false;
+}
+
+function splitTopLevelDelimitedPath(entry: string, mode: DelimitedPathSplitMode): string[] {
+	const parts: string[] = [];
+	let braceDepth = 0;
+	let start = 0;
+	for (let i = 0; i < entry.length; i++) {
+		const ch = entry[i];
+		if (ch === "\\" && i + 1 < entry.length) {
+			i++;
+			continue;
+		}
+		if (ch === "{") {
+			braceDepth++;
+			continue;
+		}
+		if (ch === "}") {
+			if (braceDepth > 0) braceDepth--;
+			continue;
+		}
+		if (braceDepth !== 0 || !isDelimitedPathSeparator(ch, mode)) continue;
+		parts.push(entry.slice(start, i));
+		start = i + 1;
+	}
+	parts.push(entry.slice(start));
+	return parts;
+}
+
+async function delimitedPathPartResolves(entry: string, cwd: string, splitter: PathEntrySplitter): Promise<boolean> {
+	if (isInternalUrlPath(entry)) return true;
+	const peeled = splitPathAndSel(entry).path;
+	const { basePath } = splitter(peeled);
+	const absoluteBasePath = resolveToCwd(basePath, cwd);
+	try {
+		await fs.promises.stat(absoluteBasePath);
+		return true;
+	} catch (err) {
+		if (isEnoent(err)) return false;
+		throw err;
+	}
+}
+
+async function tryDelimitedPathSplit(
+	entry: string,
+	cwd: string,
+	splitter: PathEntrySplitter,
+	mode: DelimitedPathSplitMode,
+	requireAllParts: boolean,
+): Promise<string[] | null> {
+	const rawParts = splitTopLevelDelimitedPath(entry, mode);
+	if (rawParts.length < 2) return null;
+
+	const parts = rawParts.map(normalizePathLikeInput).filter(part => part.length > 0);
+	if (parts.length === 0) return null;
+	if (parts.length < 2 && rawParts.length === parts.length) return null;
+
+	const resolved = await Promise.all(parts.map(part => delimitedPathPartResolves(part, cwd, splitter)));
+	const valid = requireAllParts ? resolved.every(Boolean) : resolved.some(Boolean);
+	return valid ? parts : null;
+}
+
+/**
+ * Split one path-like entry whose multiple targets were flattened into one
+ * string. Existing paths are kept intact, so real filenames containing spaces,
+ * commas, or semicolons win over delimiter recovery.
+ */
+export async function splitDelimitedPathEntry(
+	entry: string,
+	cwd: string,
+	options: { splitter?: PathEntrySplitter } = {},
+): Promise<string[] | null> {
+	const normalizedEntry = normalizePathLikeInput(entry);
+	if (!hasTopLevelPathDelimiter(normalizedEntry)) return null;
+	if (isInternalUrlPath(normalizedEntry)) return null;
+
+	const splitter = options.splitter ?? parseSearchPath;
+	const peeledEntry = splitPathAndSel(normalizedEntry).path;
+	if (!hasGlobPathChars(peeledEntry) && (await delimitedPathPartResolves(normalizedEntry, cwd, splitter))) {
+		return null;
+	}
+
+	return (
+		(await tryDelimitedPathSplit(normalizedEntry, cwd, splitter, "comma", false)) ??
+		(await tryDelimitedPathSplit(normalizedEntry, cwd, splitter, "semicolon", false)) ??
+		(await tryDelimitedPathSplit(normalizedEntry, cwd, splitter, "whitespace", true)) ??
+		(await tryDelimitedPathSplit(normalizedEntry, cwd, splitter, "mixed", true))
+	);
+}
+
+/** Expand delimited entries in-place while preserving unsplit entries. */
+export async function expandDelimitedPathEntries(
+	entries: readonly string[],
+	cwd: string,
+	options: { splitter?: PathEntrySplitter } = {},
+): Promise<string[]> {
+	const expanded: string[] = [];
+	for (const entry of entries) {
+		const normalizedEntry = normalizePathLikeInput(entry);
+		const split = await splitDelimitedPathEntry(normalizedEntry, cwd, options);
+		if (split) expanded.push(...split);
+		else expanded.push(normalizedEntry);
+	}
+	return expanded;
+}
+
 export interface ParsedSearchPath {
 	basePath: string;
 	glob?: string;
@@ -769,7 +908,11 @@ export interface ToolScopeResolution {
  */
 export async function resolveToolSearchScope(opts: ToolScopeOptions): Promise<ToolScopeResolution> {
 	const { rawPaths: inputs, cwd, internalUrlAction } = opts;
-	const rawPaths = inputs.map(normalizePathLikeInput);
+	const normalizedRawPaths = inputs.map(normalizePathLikeInput);
+	if (normalizedRawPaths.some(rawPath => rawPath.length === 0)) {
+		throw new ToolError("`paths` must contain non-empty paths or globs");
+	}
+	const rawPaths = await expandDelimitedPathEntries(normalizedRawPaths, cwd);
 	if (rawPaths.some(rawPath => rawPath.length === 0)) {
 		throw new ToolError("`paths` must contain non-empty paths or globs");
 	}