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

package/src/session/agent-session.ts

@@ -62,6 +62,7 @@ import type {
 	Message,
 	MessageAttribution,
 	Model,
+	ProviderResponseMetadata,
 	ProviderSessionState,
 	ServiceTier,
 	SimpleStreamOptions,
@@ -87,6 +88,7 @@ import { countTokens, MacOSPowerAssertion } from "@oh-my-pi/pi-natives";
 import {
 	extractRetryHint,
 	getAgentDbPath,
+	getInstallId,
 	isEnoent,
 	isUnexpectedSocketCloseMessage,
 	logger,
@@ -227,7 +229,7 @@ import type {
 	SessionContext,
 	SessionManager,
 } from "./session-manager";
-import { getLatestCompactionEntry } from "./session-manager";
+import { getLatestCompactionEntry, getRestorableSessionModels } from "./session-manager";
 import type { ShakeMode, ShakeResult } from "./shake-types";
 import { ToolChoiceQueue } from "./tool-choice-queue";
 import { YieldQueue } from "./yield-queue";
@@ -358,7 +360,7 @@ export interface AgentSessionConfig {
 	 * **MUST NOT** dispose it on their own teardown.
 	 */
 	ownedAsyncJobManager?: AsyncJobManager;
-	/** Agent identity (registry id like "0-Main" or "3-Alice") used for IRC routing. */
+	/** Agent identity (registry id like "Main" or "Alice") used for IRC routing. */
 	agentId?: string;
 	/** Shared agent registry (for forwarding IRC observations to the main session UI). */
 	agentRegistry?: AgentRegistry;
@@ -581,15 +583,14 @@ function buildSessionMetadata(
 		const accountUuid = authStorage?.getOAuthAccountId("anthropic", sessionId);
 		if (typeof accountUuid === "string" && accountUuid.length > 0) {
 			userId.account_uuid = accountUuid;
-			// Derive device_id from account_uuid so the payload matches the real CC
-			// getAPIMetadata shape without hardware fingerprinting. A SHA-256 of a
-			// namespaced account UUID produces a stable 64-hex value that is
-			// indistinguishable from a randomly generated device ID on the wire, is
-			// deterministic per account (survives reinstalls), and is auditable: it
-			// is derived solely from the OAuth UUID the user already consented to
-			// share with Anthropic. Omitted when no OAuth credential is available
-			// (API-key callers) to avoid sending a hash of an empty string.
-			userId.device_id = crypto.createHash("sha256").update(`omp-device-id-v1:${accountUuid}`).digest("hex");
+			// Claude Code's `device_id` is a stable 64-hex install identifier. Use
+			// omp's persistent install id as the root instead of deriving it from
+			// `account_uuid`: logging into a different Claude account on the same
+			// install should not make the device look new.
+			userId.device_id = crypto
+				.createHash("sha256")
+				.update(`omp-claude-device-id-v1:${getInstallId()}`)
+				.digest("hex");
 		}
 	}
 	return { user_id: JSON.stringify(userId) };
@@ -1104,10 +1105,12 @@ export class AgentSession {
 		this.#onResponse = configuredOnResponse
 			? async (response, model) => {
 					this.rawSseDebugBuffer.recordResponse(response, model);
+					this.#ingestProviderUsageHeaders(response, model);
 					await configuredOnResponse(response, model);
 				}
 			: (response, model) => {
 					this.rawSseDebugBuffer.recordResponse(response, model);
+					this.#ingestProviderUsageHeaders(response, model);
 				};
 		const configuredOnSseEvent = config.onSseEvent;
 		this.#onSseEvent = configuredOnSseEvent
@@ -2827,13 +2830,14 @@ export class AgentSession {
 
 	/**
 	 * Set agent.sessionId from the session manager and install a dynamic
-	 * metadata resolver so every API request carries `metadata.user_id` shaped
-	 * like real Claude Code's `getAPIMetadata` output: `{ session_id,
-	 * account_uuid }` (the latter only when an Anthropic OAuth credential with
-	 * a known account UUID is loaded). Resolving live keeps the value in sync
-	 * with auth-state changes (login/logout, token refresh that surfaces a new
-	 * account uuid) without needing to re-call `#syncAgentSessionId()` on every
-	 * such event.
+	 * metadata resolver so every Anthropic API request carries
+	 * `metadata.user_id` shaped like real Claude Code's `getAPIMetadata` output:
+	 * `{ session_id, account_uuid, device_id }`. `account_uuid` is included only
+	 * when an Anthropic OAuth credential with a known account UUID is loaded;
+	 * `device_id` is derived from the persistent omp install id. Resolving live
+	 * keeps the value in sync with auth-state changes (login/logout, token
+	 * refresh that surfaces a new account uuid) without needing to re-call
+	 * `#syncAgentSessionId()` on every such event.
 	 */
 	#syncAgentSessionId(sessionId?: string): void {
 		const sid = this.#providerSessionId ?? sessionId ?? this.sessionManager.getSessionId();
@@ -8723,28 +8727,34 @@ export class AgentSession {
 			}
 
 			// Restore model if saved
-			const defaultModelStr = sessionContext.models.default;
-			if (defaultModelStr) {
-				const slashIdx = defaultModelStr.indexOf("/");
-				if (slashIdx > 0) {
-					const provider = defaultModelStr.slice(0, slashIdx);
-					const modelId = defaultModelStr.slice(slashIdx + 1);
-					const availableModels = this.#modelRegistry.getAvailable();
-					const match = availableModels.find(m => m.provider === provider && m.id === modelId);
-					if (match) {
-						const currentModel = this.model;
-						const shouldResetProviderState =
-							switchingToDifferentSession ||
-							(currentModel !== undefined &&
-								(currentModel.provider !== match.provider ||
-									currentModel.id !== match.id ||
-									currentModel.api !== match.api));
-						if (shouldResetProviderState) {
-							this.#setModelWithProviderSessionReset(match);
-						} else {
-							this.agent.setModel(match);
-							this.#syncToolCallBatchCap(match);
-						}
+			const targetModelStrings = getRestorableSessionModels(
+				sessionContext.models,
+				this.sessionManager.getLastModelChangeRole(),
+			);
+			if (targetModelStrings.length > 0) {
+				const availableModels = this.#modelRegistry.getAvailable();
+				let match: Model | undefined;
+				for (const targetModelStr of targetModelStrings) {
+					const slashIdx = targetModelStr.indexOf("/");
+					if (slashIdx <= 0) continue;
+					const provider = targetModelStr.slice(0, slashIdx);
+					const modelId = targetModelStr.slice(slashIdx + 1);
+					match = availableModels.find(m => m.provider === provider && m.id === modelId);
+					if (match) break;
+				}
+				if (match) {
+					const currentModel = this.model;
+					const shouldResetProviderState =
+						switchingToDifferentSession ||
+						(currentModel !== undefined &&
+							(currentModel.provider !== match.provider ||
+								currentModel.id !== match.id ||
+								currentModel.api !== match.api));
+					if (shouldResetProviderState) {
+						this.#setModelWithProviderSessionReset(match);
+					} else {
+						this.agent.setModel(match);
+						this.#syncToolCallBatchCap(match);
 					}
 				}
 			}
@@ -9202,12 +9212,10 @@ export class AgentSession {
 	 * Uses the last assistant message's usage data when available,
 	 * otherwise estimates tokens for all messages.
 	 */
-	getContextUsage(): ContextUsage | undefined {
+	getContextUsage(options?: { contextWindow?: number }): ContextUsage | undefined {
 		const model = this.model;
-		if (!model) return undefined;
-
-		const contextWindow = model.contextWindow ?? 0;
-		if (contextWindow <= 0) return undefined;
+		const contextWindow = options?.contextWindow ?? model?.contextWindow ?? 0;
+		if (!Number.isFinite(contextWindow) || contextWindow <= 0) return undefined;
 
 		// After compaction, the last assistant usage reflects pre-compaction context size.
 		// We can only trust usage from an assistant that responded after the latest compaction.
@@ -9248,6 +9256,14 @@ export class AgentSession {
 		};
 	}
 
+	#ingestProviderUsageHeaders(response: ProviderResponseMetadata, model?: Model): void {
+		if (model?.provider !== "anthropic") return;
+		this.#modelRegistry.authStorage.ingestUsageHeaders("anthropic", response.headers, {
+			sessionId: this.agent.sessionId,
+			baseUrl: this.#modelRegistry.getProviderBaseUrl?.("anthropic"),
+		});
+	}
+
 	async fetchUsageReports(signal?: AbortSignal): Promise<UsageReport[] | null> {
 		const authStorage = this.#modelRegistry.authStorage;
 		if (!authStorage.fetchUsageReports) return null;
@@ -9265,7 +9281,7 @@ export class AgentSession {
 	} {
 		const messages = this.messages;
 
-		// Find last assistant message with usage
+		// Find last assistant message with valid usage.
 		let lastUsageIndex: number | null = null;
 		let lastUsage: Usage | undefined;
 		for (let i = messages.length - 1; i >= 0; i--) {

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