@oh-my-pi/pi-coding-agent 17.0.9 → 17.1.1

package/src/advisor/runtime.ts

@@ -5,7 +5,12 @@ import * as AIError from "@oh-my-pi/pi-ai/error";
 import { type CursorExecResolvedCarrier, kCursorExecResolved } from "@oh-my-pi/pi-ai/utils/block-symbols";
 import { logger } from "@oh-my-pi/pi-utils";
 import { obfuscateToolArguments, type SecretObfuscator } from "../secrets/obfuscator";
-import { formatSessionHistoryMarkdown, PRIMARY_CONTEXT_CUSTOM_TYPES } from "../session/session-history-format";
+import {
+	formatExecutionSourcePreview,
+	formatSessionHistoryMarkdown,
+	formatToolResultErrorPreview,
+	PRIMARY_CONTEXT_CUSTOM_TYPES,
+} from "../session/session-history-format";
 
 /**
  * Minimal slice of `Agent` the runtime drives — satisfied by pi-agent-core
@@ -267,6 +272,8 @@ export class AdvisorRuntime {
 	#seenContext = new Map<string, string>();
 	/** Incremented whenever the advisor loses context so queued raw deltas are re-rendered against fresh dedupe state. */
 	#renderRevision = 0;
+	/** Regex secret values observed in primary deltas and retained until advisor context resets. */
+	#advisorRegexSecretValues = new Set<string>();
 	#pending: PendingDelta[] = [];
 	#busy = false;
 	#backlog = 0;
@@ -428,6 +435,7 @@ export class AdvisorRuntime {
 		this.#backlog = 0;
 		this.#consecutiveFailures = 0;
 		this.#failureNotified = false;
+		this.#advisorRegexSecretValues.clear();
 		this.#wakeAllWaiters();
 		try {
 			this.agent.abort("advisor disposed");
@@ -436,6 +444,7 @@ export class AdvisorRuntime {
 
 	#clearSeenContext(): void {
 		this.#seenContext.clear();
+		this.#advisorRegexSecretValues.clear();
 		this.#renderRevision++;
 	}
 
@@ -527,9 +536,44 @@ export class AdvisorRuntime {
 			.map(message => this.#dedupContextMessage(message));
 		if (delta.length === 0) return null;
 		const obfuscator = this.host.obfuscator;
-		const formattedDelta = obfuscator?.hasSecrets() ? obfuscateAdvisorDelta(obfuscator, delta) : delta;
-		const md = formatSessionHistoryMarkdown(formattedDelta, ADVISOR_RENDER_OPTIONS);
+		let md = formatSessionHistoryMarkdown(delta, ADVISOR_RENDER_OPTIONS);
 		if (!md.trim()) return null;
+		if (obfuscator?.hasSecrets()) {
+			let discoveredNewRegexSecretValue = false;
+			const addRegexValues = (text: string): void => {
+				for (const secretValue of obfuscator.collectRegexSecretValuesForObfuscation(text)) {
+					if (this.#advisorRegexSecretValues.has(secretValue)) continue;
+					this.#advisorRegexSecretValues.add(secretValue);
+					discoveredNewRegexSecretValue = true;
+				}
+			};
+			for (const message of delta) {
+				if (
+					message.role === "custom" &&
+					PRIMARY_CONTEXT_CUSTOM_TYPES.has(message.customType) &&
+					typeof message.content === "string"
+				) {
+					addRegexValues(message.content);
+				}
+			}
+			addRegexValues(md);
+			scrubAdvisorHistory(obfuscator, this.agent.state.messages, this.#advisorRegexSecretValues);
+			if (discoveredNewRegexSecretValue) {
+				this.#pending = this.#pending.map(delta => ({
+					...delta,
+					text: obfuscator.stripUnsafeFriendlyPlaceholderPrefixes(delta.text, this.#advisorRegexSecretValues),
+				}));
+			}
+			md = formatSessionHistoryMarkdown(
+				delta.map(message =>
+					message.role === "custom" && PRIMARY_CONTEXT_CUSTOM_TYPES.has(message.customType)
+						? obfuscateAdvisorMessage(obfuscator, message, this.#advisorRegexSecretValues)
+						: message,
+				),
+				ADVISOR_RENDER_OPTIONS,
+			);
+			md = obfuscator.obfuscate(md, this.#advisorRegexSecretValues);
+		}
 		const heading = wip ? "### Session update [in progress — more steps follow]" : "### Session update";
 		return `${heading}\n\n${md}`;
 	}
@@ -731,6 +775,10 @@ export class AdvisorRuntime {
 			wip = late.at(-1)!.wip;
 		}
 
+		const batchObfuscator = this.host.obfuscator;
+		if (batchObfuscator?.hasSecrets()) {
+			batchText = batchObfuscator.stripUnsafeFriendlyPlaceholderPrefixes(batchText, this.#advisorRegexSecretValues);
+		}
 		return { batch: batchText || null, rawMessages, finalTurns: turns, wip, resetContext: false };
 	}
 
@@ -987,12 +1035,16 @@ function getAdvisorTurnError(messages: readonly AgentMessage[]): Error | undefin
 
 type TextualContent = string | readonly (TextContent | ImageContent)[];
 
-function obfuscateTextualContent(obfuscator: SecretObfuscator, content: TextualContent): TextualContent {
-	if (typeof content === "string") return obfuscator.obfuscate(content);
+function obfuscateTextualContent(
+	obfuscator: SecretObfuscator,
+	content: TextualContent,
+	sharedRegexSecretValues: ReadonlySet<string>,
+): TextualContent {
+	if (typeof content === "string") return obfuscator.obfuscate(content, sharedRegexSecretValues);
 	let changed = false;
 	const result = content.map((block): TextContent | ImageContent => {
 		if (block.type !== "text") return block;
-		const text = obfuscator.obfuscate(block.text);
+		const text = obfuscator.obfuscate(block.text, sharedRegexSecretValues);
 		if (text === block.text) return block;
 		changed = true;
 		return { ...block, text };
@@ -1000,17 +1052,50 @@ function obfuscateTextualContent(obfuscator: SecretObfuscator, content: TextualC
 	return changed ? result : content;
 }
 
-function obfuscateAssistantMessage(obfuscator: SecretObfuscator, message: AssistantMessage): AssistantMessage {
+function firstAdvisorToolResultErrorLine(content: TextualContent): string | undefined {
+	if (typeof content === "string") return content.split("\n", 1)[0];
+	const first = content[0];
+	if (first?.type !== "text") return undefined;
+	return first.text.split("\n", 1)[0];
+}
+
+function obfuscateAdvisorToolResultErrorContent(
+	obfuscator: SecretObfuscator,
+	content: TextualContent,
+	sharedRegexSecretValues: ReadonlySet<string>,
+): TextualContent {
+	const firstLine = firstAdvisorToolResultErrorLine(content);
+	if (firstLine === undefined) return content;
+	const preview = formatToolResultErrorPreview(content);
+	const obfuscatedPreview = obfuscator.obfuscate(preview, sharedRegexSecretValues);
+	if (obfuscatedPreview === firstLine) return content;
+	if (typeof content === "string") return obfuscatedPreview + content.slice(firstLine.length);
+	const first = content[0]!;
+	if (first.type !== "text") return content;
+	return [{ ...first, text: obfuscatedPreview + first.text.slice(firstLine.length) }, ...content.slice(1)];
+}
+
+function obfuscateAssistantMessage(
+	obfuscator: SecretObfuscator,
+	message: AssistantMessage,
+	sharedRegexSecretValues: ReadonlySet<string>,
+): AssistantMessage {
 	let changed = false;
 	const content = message.content.map((block): AssistantMessage["content"][number] => {
 		if (block.type === "text") {
-			const text = obfuscator.obfuscate(block.text);
+			const text = obfuscator.obfuscate(block.text, sharedRegexSecretValues);
 			if (text === block.text) return block;
 			changed = true;
 			return { ...block, text };
 		}
+		if (block.type === "thinking") {
+			const thinking = obfuscator.obfuscate(block.thinking, sharedRegexSecretValues);
+			if (thinking === block.thinking) return block;
+			changed = true;
+			return { ...block, thinking, thinkingSignature: undefined };
+		}
 		if (block.type === "toolCall") {
-			const args = obfuscateToolArguments(obfuscator, block.arguments);
+			const args = obfuscateToolArguments(obfuscator, block.arguments, sharedRegexSecretValues);
 			if (args === block.arguments) return block;
 			changed = true;
 			return { ...block, arguments: args };
@@ -1023,68 +1108,83 @@ function obfuscateAssistantMessage(obfuscator: SecretObfuscator, message: Assist
 function obfuscateDetails(
 	obfuscator: SecretObfuscator,
 	details: Record<string, unknown> | undefined,
+	sharedRegexSecretValues: ReadonlySet<string>,
 ): Record<string, unknown> | undefined {
 	if (!details) return details;
 	// Walk strings at every depth: `customOneLiner` renders nested fields
 	// (e.g. `async-result` reads `details.jobs[].label`/`jobId`), so a shallow
 	// pass leaks any secret a background job's label happens to contain.
-	return obfuscateToolArguments(obfuscator, details);
+	return obfuscateToolArguments(obfuscator, details, sharedRegexSecretValues);
 }
 
-function obfuscateAdvisorMessage(obfuscator: SecretObfuscator, message: AgentMessage): AgentMessage {
+function obfuscateAdvisorMessage(
+	obfuscator: SecretObfuscator,
+	message: AgentMessage,
+	sharedRegexSecretValues: ReadonlySet<string>,
+): AgentMessage {
 	switch (message.role) {
 		case "user":
 		case "developer": {
-			const content = obfuscateTextualContent(obfuscator, message.content as TextualContent);
+			const content = obfuscateTextualContent(
+				obfuscator,
+				message.content as TextualContent,
+				sharedRegexSecretValues,
+			);
 			return content === message.content ? message : ({ ...(message as object), content } as AgentMessage);
 		}
 		case "toolResult": {
 			const msg = message as AgentMessage & {
 				content: TextualContent;
 				details?: Record<string, unknown>;
+				isError?: boolean;
 			};
-			const content = obfuscateTextualContent(obfuscator, msg.content);
-			const details = obfuscateDetails(obfuscator, msg.details);
+			const content = msg.isError
+				? obfuscateAdvisorToolResultErrorContent(obfuscator, msg.content, sharedRegexSecretValues)
+				: msg.content;
+			let details = msg.details;
+			if (typeof details?.diff === "string") {
+				const diff = obfuscator.obfuscate(details.diff, sharedRegexSecretValues);
+				if (diff !== details.diff) details = { ...details, diff };
+			}
 			if (content === msg.content && details === msg.details) return message;
 			return { ...(message as object), content, details } as AgentMessage;
 		}
 		case "assistant":
-			return obfuscateAssistantMessage(obfuscator, message as AssistantMessage) as AgentMessage;
+			return obfuscateAssistantMessage(
+				obfuscator,
+				message as AssistantMessage,
+				sharedRegexSecretValues,
+			) as AgentMessage;
 		case "custom":
 		case "hookMessage": {
+			if (!formatSessionHistoryMarkdown([message], { expandPrimaryContext: true }).trim()) return message;
 			const msg = message as AgentMessage & {
 				content: TextualContent;
 				details?: Record<string, unknown>;
 			};
-			const content = obfuscateTextualContent(obfuscator, msg.content);
-			const details = obfuscateDetails(obfuscator, msg.details);
+			const content = obfuscateTextualContent(obfuscator, msg.content, sharedRegexSecretValues);
+			const details = obfuscateDetails(obfuscator, msg.details, sharedRegexSecretValues);
 			if (content === msg.content && details === msg.details) return message;
 			return { ...(message as object), content, details } as AgentMessage;
 		}
 		case "bashExecution": {
-			const msg = message as AgentMessage & { command: string; output: string };
-			const command = obfuscator.obfuscate(msg.command);
-			const output = obfuscator.obfuscate(msg.output);
-			return command === msg.command && output === msg.output
-				? message
-				: ({ ...(message as object), command, output } as AgentMessage);
+			const msg = message as AgentMessage & { command: string };
+			const command = obfuscator.obfuscate(formatExecutionSourcePreview(msg.command), sharedRegexSecretValues);
+			return command === msg.command ? message : ({ ...(message as object), command } as AgentMessage);
 		}
 		case "pythonExecution": {
-			const msg = message as AgentMessage & { code: string; output: string };
-			const code = obfuscator.obfuscate(msg.code);
-			const output = obfuscator.obfuscate(msg.output);
-			return code === msg.code && output === msg.output
-				? message
-				: ({ ...(message as object), code, output } as AgentMessage);
+			const msg = message as AgentMessage & { code: string };
+			const code = obfuscator.obfuscate(formatExecutionSourcePreview(msg.code), sharedRegexSecretValues);
+			return code === msg.code ? message : ({ ...(message as object), code } as AgentMessage);
 		}
 		case "branchSummary": {
 			const msg = message as AgentMessage & { summary: string };
-			const summary = obfuscator.obfuscate(msg.summary);
+			const summary = obfuscator.obfuscate(msg.summary, sharedRegexSecretValues);
 			return summary === msg.summary ? message : ({ ...(message as object), summary } as AgentMessage);
 		}
 		case "compactionSummary": {
 			const msg = message as AgentMessage & { summary: string };
-			const summary = obfuscator.obfuscate(msg.summary);
+			const summary = obfuscator.obfuscate(msg.summary, sharedRegexSecretValues);
 			return summary === msg.summary ? message : ({ ...(message as object), summary } as AgentMessage);
 		}
 		case "fileMention": {
@@ -1093,11 +1193,10 @@ function obfuscateAdvisorMessage(obfuscator: SecretObfuscator, message: AgentMes
 			};
 			let changed = false;
 			const files = msg.files.map(file => {
-				const path = obfuscator.obfuscate(file.path);
-				const content = obfuscator.obfuscate(file.content);
-				if (path === file.path && content === file.content) return file;
+				const path = obfuscator.obfuscate(file.path, sharedRegexSecretValues);
+				if (path === file.path) return file;
 				changed = true;
-				return { ...file, path, content };
+				return { ...file, path };
 			});
 			return changed ? ({ ...(message as object), files } as AgentMessage) : message;
 		}
@@ -1106,12 +1205,14 @@ function obfuscateAdvisorMessage(obfuscator: SecretObfuscator, message: AgentMes
 	}
 }
 
-function obfuscateAdvisorDelta(obfuscator: SecretObfuscator, messages: AgentMessage[]): AgentMessage[] {
-	let changed = false;
-	const result = messages.map(message => {
-		const next = obfuscateAdvisorMessage(obfuscator, message);
-		if (next !== message) changed = true;
-		return next;
-	});
-	return changed ? result : messages;
+function scrubAdvisorHistory(
+	obfuscator: SecretObfuscator,
+	messages: AgentMessage[],
+	sharedRegexSecretValues: ReadonlySet<string>,
+): void {
+	for (let index = 0; index < messages.length; index++) {
+		const message = messages[index]!;
+		const next = obfuscateAdvisorMessage(obfuscator, message, sharedRegexSecretValues);
+		if (next !== message) messages[index] = next;
+	}
 }

package/src/async/job-manager.ts

@@ -60,8 +60,19 @@ export interface AsyncJob {
 	queued?: boolean;
 }
 
+/** Delivery callback for a settled job's result text. */
+export type AsyncJobDeliverySink = (jobId: string, text: string, job?: AsyncJob) => void | Promise<void>;
+
 export interface AsyncJobManagerOptions {
-	onJobComplete: (jobId: string, text: string, job?: AsyncJob) => void | Promise<void>;
+	/**
+	 * Delivery sink for UNOWNED completions (jobs registered without an
+	 * `ownerId`). Owned deliveries route exclusively through
+	 * {@link AsyncJobManager.registerDeliverySink}; when the owner has no live
+	 * sink they are dead-lettered (dropped with a warning; the job row keeps
+	 * the result text until retention eviction) — never routed here, which
+	 * would leak one agent's result into another session.
+	 */
+	onJobComplete?: AsyncJobDeliverySink;
 	maxRunningJobs?: number;
 	retentionMs?: number;
 }
@@ -128,6 +139,7 @@ export class AsyncJobManager {
 	readonly #watchedJobs = new Set<string>();
 	readonly #evictionTimers = new Map<string, NodeJS.Timeout>();
 	readonly #pollEscalation = new Map<string | undefined, PollEscalationState>();
+	readonly #deliverySinks = new Map<string, AsyncJobDeliverySink>();
 	readonly #onJobComplete: AsyncJobManagerOptions["onJobComplete"];
 	readonly #maxRunningJobs: number;
 	readonly #retentionMs: number;
@@ -409,6 +421,55 @@ export class AsyncJobManager {
 		await Promise.all(Array.from(this.#jobs.values()).map(job => job.promise));
 	}
 
+	/**
+	 * Route completions for jobs owned by `ownerId` to `sink`. Sessions register
+	 * their own sink at construction and unregister on dispose. Owned deliveries
+	 * with no live sink are dead-lettered — `onJobComplete` serves only unowned
+	 * deliveries.
+	 *
+	 * Last registration wins for an owner id; the returned unregister clears the
+	 * mapping only while it still points at `sink`, so a revived session's fresh
+	 * registration survives its parked predecessor's late cleanup.
+	 */
+	registerDeliverySink(ownerId: string, sink: AsyncJobDeliverySink): () => void {
+		this.#deliverySinks.set(ownerId, sink);
+		return () => {
+			if (this.#deliverySinks.get(ownerId) === sink) this.#deliverySinks.delete(ownerId);
+		};
+	}
+
+	/**
+	 * Wait until every job owned by `ownerId` has settled — its run promise
+	 * resolved, which for cancelled jobs means the underlying process actually
+	 * exited. Jobs registered while waiting (e.g. by a follow-up turn) are
+	 * awaited too. Returns false when `timeoutMs` elapses first.
+	 *
+	 * `excludeSuppressed` skips jobs whose delivery is suppressed (acknowledged
+	 * or `hub`-watched): those can never re-wake a run, so quiescence barriers
+	 * pass it to share one contract with the pending-async-wake predicate.
+	 * Teardown reaps omit it — worktree safety concerns every owner process.
+	 */
+	async waitForOwnerJobs(
+		ownerId: string,
+		options?: { timeoutMs?: number; excludeSuppressed?: boolean },
+	): Promise<boolean> {
+		const deadline =
+			options?.timeoutMs === undefined ? Number.POSITIVE_INFINITY : Date.now() + Math.max(0, options.timeoutMs);
+		const awaited = new Set<string>();
+		for (;;) {
+			const pending = this.#filterJobs(this.#jobs.values(), { ownerId }).filter(
+				job => !awaited.has(job.id) && (options?.excludeSuppressed !== true || !this.isDeliverySuppressed(job.id)),
+			);
+			if (pending.length === 0) return true;
+			for (const job of pending) awaited.add(job.id);
+			const settled = await this.#waitForDeliveryPromise(
+				Promise.all(pending.map(job => job.promise)).then(() => {}),
+				deadline,
+			);
+			if (!settled) return false;
+		}
+	}
+
 	async #waitForAllUntil(deadline: number): Promise<boolean> {
 		const promises = Array.from(this.#jobs.values()).map(job => job.promise);
 		if (promises.length === 0) return true;
@@ -489,6 +550,7 @@ export class AsyncJobManager {
 		this.#suppressedDeliveries.clear();
 		this.#watchedJobs.clear();
 		this.#pollEscalation.clear();
+		this.#deliverySinks.clear();
 		return jobsSettled && drained;
 	}
 
@@ -655,11 +717,37 @@ export class AsyncJobManager {
 		}
 	}
 
+	/**
+	 * Resolve the sink for one delivery attempt: owned deliveries route ONLY to
+	 * their owner's registered sink (a missing sink dead-letters — never the
+	 * default, which would misroute a dead owner's result into another
+	 * session); unowned deliveries use the constructor default. Resolved per
+	 * attempt so a sink registered between retries (e.g. a revived session)
+	 * picks up the retry.
+	 */
+	#resolveDeliverySink(ownerId: string | undefined): AsyncJobDeliverySink | undefined {
+		if (ownerId !== undefined) return this.#deliverySinks.get(ownerId);
+		return this.#onJobComplete;
+	}
+
 	#deliverDelivery(delivery: AsyncJobDelivery): Promise<void> {
+		const sink = this.#resolveDeliverySink(delivery.ownerId);
+		if (!sink) {
+			// Dead-letter: owned delivery with no live sink (session disposed or
+			// parked), or unowned delivery with no default sink. Drop it — the
+			// job row keeps its result/error text until retention eviction, so
+			// the outcome stays inspectable via job queries and agent:// reads.
+			logger.warn("Async job delivery dead-lettered: no delivery sink", {
+				jobId: delivery.jobId,
+				ownerId: delivery.ownerId,
+			});
+			delivery.promise = Promise.resolve();
+			return delivery.promise;
+		}
 		const promise = (async () => {
 			this.#inFlightDeliveries.push(delivery);
 			try {
-				await this.#onJobComplete(delivery.jobId, delivery.text, this.#jobs.get(delivery.jobId));
+				await sink(delivery.jobId, delivery.text, this.#jobs.get(delivery.jobId));
 			} catch (error) {
 				delivery.attempt += 1;
 				delivery.lastError = error instanceof Error ? error.message : String(error);

package/src/cli/args.ts

@@ -19,6 +19,8 @@ export type Mode = "text" | "json" | "rpc" | "acp" | "rpc-ui";
 
 export interface Args {
 	cwd?: string;
+	/** Workspace directories beyond cwd for this session (repeatable `--add-dir`). */
+	addDir?: string[];
 	profile?: string;
 	alias?: string;
 	allowHome?: boolean;
@@ -394,6 +396,7 @@ ${chalk.bold("Available Tools (default-enabled unless noted):")}
   notebook      - Edit Jupyter notebooks
   inspect_image - Analyze images with a vision model
   browser       - Browser automation (Puppeteer)
+  computer      - Native host desktop capture and input (disabled by default)
   task          - Launch sub-agents for parallel tasks
   todo          - Manage todo/task lists
   web_search    - Search the web

package/src/cli/auth-gateway-cli.ts

@@ -24,7 +24,12 @@ import {
 	completeSimple,
 	type Model,
 } from "@oh-my-pi/pi-ai";
-import { AuthBrokerClient, RemoteAuthCredentialStore, type SnapshotResponse } from "@oh-my-pi/pi-ai/auth-broker";
+import {
+	AuthBrokerClient,
+	loadAuthBrokerAccountPool,
+	RemoteAuthCredentialStore,
+	type SnapshotResponse,
+} from "@oh-my-pi/pi-ai/auth-broker";
 import { DEFAULT_AUTH_GATEWAY_BIND, startAuthGateway } from "@oh-my-pi/pi-ai/auth-gateway";
 import { type GeneratedProvider, getBundledModels, getBundledProviders } from "@oh-my-pi/pi-catalog/models";
 import { getConfigRootDir, isEnoent, VERSION } from "@oh-my-pi/pi-utils";
@@ -147,9 +152,14 @@ async function runServe(flags: AuthGatewayCommandArgs["flags"]): Promise<void> {
 
 	// Build a broker-backed AuthStorage — same pattern as discoverAuthStorage()
 	// in sdk.ts. The gateway never touches local SQLite.
+	const accountPool = await loadAuthBrokerAccountPool();
 	const client = createBrokerClient(brokerConfig);
 	const initialSnapshot = await fetchBrokerSnapshot(client);
-	const store = new RemoteAuthCredentialStore({ client, initialSnapshot });
+	const store = new RemoteAuthCredentialStore({
+		client,
+		initialSnapshot,
+		accountPool,
+	});
 	// Refresh + usage both flow through the store's broker hooks automatically —
 	// `RemoteAuthCredentialStore.refreshOAuthCredential` and `.fetchUsageReports`.
 	// AuthStorage discovers them when no explicit option overrides them, so the
@@ -538,9 +548,14 @@ async function runCheck(flags: AuthGatewayCommandArgs["flags"]): Promise<void> {
 		);
 	}
 
+	const accountPool = await loadAuthBrokerAccountPool();
 	const client = createBrokerClient(brokerConfig);
 	const initialSnapshot = await fetchBrokerSnapshot(client);
-	const store = new RemoteAuthCredentialStore({ client, initialSnapshot });
+	const store = new RemoteAuthCredentialStore({
+		client,
+		initialSnapshot,
+		accountPool,
+	});
 	const storage = new AuthStorage(store, { sourceLabel: `broker ${brokerConfig.url}` });
 	try {
 		await storage.reload();