@oh-my-pi/pi-coding-agent 15.10.12 → 15.11.1

package/src/internal-urls/history-protocol.ts

@@ -0,0 +1,113 @@
+/**
+ * Protocol handler for history:// URLs.
+ *
+ * Exposes agent transcripts as concise markdown. Live refs render from the
+ * in-memory message array; parked refs (session disposed, sessionFile
+ * retained) load read-only from the JSONL session file — no writer, no lock.
+ *
+ * URL forms:
+ * - history:// - Index of all registry agents (id, status, kind, last activity)
+ * - history://<agentId> - Concise markdown transcript of that agent
+ */
+import type { AgentRef } from "../registry/agent-registry";
+import { AgentRegistry } from "../registry/agent-registry";
+import { formatSessionHistoryMarkdown } from "../session/session-history-format";
+import { loadSessionMessagesReadOnly } from "../session/session-manager";
+import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } from "./types";
+
+/** Humanize a last-activity timestamp as `Ns/Nm/Nh/Nd ago`. */
+function formatAgo(timestamp: number): string {
+	const diffMs = Math.max(0, Date.now() - timestamp);
+	const secs = Math.floor(diffMs / 1000);
+	if (secs < 60) return `${secs}s ago`;
+	const mins = Math.floor(secs / 60);
+	if (mins < 60) return `${mins}m ago`;
+	const hours = Math.floor(mins / 60);
+	if (hours < 24) return `${hours}h ago`;
+	return `${Math.floor(hours / 24)}d ago`;
+}
+
+/**
+ * Handler for history:// URLs.
+ *
+ * Resolves agent ids against the global AgentRegistry, serving transcripts
+ * for both live and parked agents.
+ */
+export class HistoryProtocolHandler implements ProtocolHandler {
+	readonly scheme = "history";
+	readonly immutable = false;
+
+	async resolve(url: InternalUrl): Promise<InternalResource> {
+		const agentId = url.rawHost || url.hostname;
+		const registry = AgentRegistry.global();
+
+		if (!agentId) {
+			const content = this.#renderIndex(registry.list());
+			return {
+				url: url.href,
+				content,
+				contentType: "text/markdown",
+				size: Buffer.byteLength(content, "utf-8"),
+			};
+		}
+
+		let ref = registry.get(agentId);
+		if (!ref) {
+			// Case-insensitive fallback: agent ids are human-typed (e.g. AuthLoader).
+			const lower = agentId.toLowerCase();
+			ref = registry.list().find(candidate => candidate.id.toLowerCase() === lower);
+		}
+		if (!ref) {
+			const known = registry.list().map(candidate => candidate.id);
+			const knownStr = known.length > 0 ? known.join(", ") : "none";
+			throw new Error(`Unknown agent: ${agentId}\nKnown agents: ${knownStr}\nList all with history://`);
+		}
+
+		const notes: string[] = [];
+		let messages: unknown[];
+		if (ref.session) {
+			messages = ref.session.messages;
+			notes.push("Source: live session");
+		} else if (ref.sessionFile) {
+			messages = await loadSessionMessagesReadOnly(ref.sessionFile);
+			notes.push(`Source: session file (read-only, ${ref.status})`);
+		} else {
+			throw new Error(`Agent ${ref.id} has no transcript: session is gone and no session file was retained`);
+		}
+
+		const content = formatSessionHistoryMarkdown(messages, { title: `${ref.id} (${ref.status})` });
+		return {
+			url: url.href,
+			content,
+			contentType: "text/markdown",
+			size: Buffer.byteLength(content, "utf-8"),
+			sourcePath: ref.sessionFile ?? undefined,
+			notes,
+		};
+	}
+
+	#renderIndex(refs: AgentRef[]): string {
+		const lines: string[] = ["# Agents", ""];
+		if (refs.length === 0) {
+			lines.push("No agents registered.");
+			return `${lines.join("\n")}\n`;
+		}
+		lines.push("| id | status | kind | parent | last activity |", "|---|---|---|---|---|");
+		for (const ref of refs) {
+			lines.push(
+				`| ${ref.id} | ${ref.status} | ${ref.kind} | ${ref.parentId ?? "—"} | ${formatAgo(ref.lastActivity)} |`,
+			);
+		}
+		lines.push("", "Read a transcript with `read history://<id>`.");
+		return `${lines.join("\n")}\n`;
+	}
+
+	async complete(): Promise<UrlCompletion[]> {
+		return AgentRegistry.global()
+			.list()
+			.map(ref => ({
+				value: ref.id,
+				description: `${ref.status} · ${ref.kind}${ref.parentId ? ` · parent ${ref.parentId}` : ""}`,
+			}));
+	}
+}

package/src/internal-urls/index.ts

@@ -10,6 +10,7 @@
 
 export * from "./agent-protocol";
 export * from "./artifact-protocol";
+export * from "./history-protocol";
 export * from "./issue-pr-protocol";
 export * from "./json-query";
 export * from "./local-protocol";

package/src/internal-urls/router.ts

@@ -1,5 +1,5 @@
 /**
- * Internal URL router for internal protocols (`agent://`, `artifact://`, `issue://`, `local://`, `mcp://`, `memory://`, `omp://`, `pr://`, `rule://`, `skill://`, and `vault://`).
+ * Internal URL router for internal protocols (`agent://`, `artifact://`, `history://`, `issue://`, `local://`, `mcp://`, `memory://`, `omp://`, `pr://`, `rule://`, `skill://`, and `vault://`).
  *
  * One process-global router with one handler per scheme. Access via
  * `InternalUrlRouter.instance()`. Handlers are stateless; per-session and
@@ -7,6 +7,7 @@
  */
 import { AgentProtocolHandler } from "./agent-protocol";
 import { ArtifactProtocolHandler } from "./artifact-protocol";
+import { HistoryProtocolHandler } from "./history-protocol";
 import { IssueProtocolHandler, PrProtocolHandler } from "./issue-pr-protocol";
 import { LocalProtocolHandler } from "./local-protocol";
 import { McpProtocolHandler } from "./mcp-protocol";
@@ -35,6 +36,7 @@ export class InternalUrlRouter {
 		this.register(new McpProtocolHandler());
 		this.register(new IssueProtocolHandler());
 		this.register(new PrProtocolHandler());
+		this.register(new HistoryProtocolHandler());
 	}
 
 	/** Process-global router instance. */

package/src/internal-urls/types.ts

@@ -1,7 +1,7 @@
 /**
  * Types for the internal URL routing system.
  *
- * Internal URLs (`agent://`, `artifact://`, `issue://`, `local://`, `mcp://`, `memory://`, `omp://`, `pr://`, `rule://`, `skill://`, and `vault://`) are resolved by tools like read,
+ * Internal URLs (`agent://`, `artifact://`, `history://`, `issue://`, `local://`, `mcp://`, `memory://`, `omp://`, `pr://`, `rule://`, `skill://`, and `vault://`) are resolved by tools like read,
  * providing access to agent outputs and server resources without exposing filesystem paths.
  */
 

package/src/irc/bus.ts

@@ -0,0 +1,292 @@
+/**
+ * IrcBus - Process-global mailbox bus for agent-to-agent messaging.
+ *
+ * Replaces the old auto-reply model: a `send` never blocks on the recipient
+ * generating anything. Delivery resolves the recipient via the global
+ * AgentRegistry — parked agents are revived through the
+ * AgentLifecycleManager, idle agents are woken with a real turn, and busy
+ * agents receive the message as a non-interrupting aside at the next step
+ * boundary (see AgentSession.deliverIrcMessage). Replies are real turns by
+ * the recipient, observed via `wait`.
+ */
+
+import { logger, Snowflake } from "@oh-my-pi/pi-utils";
+import { AgentLifecycleManager } from "../registry/agent-lifecycle";
+import { AgentRegistry, MAIN_AGENT_ID } from "../registry/agent-registry";
+import type { CustomMessage } from "../session/messages";
+
+export interface IrcMessage {
+	id: string;
+	/** Sender agent id. */
+	from: string;
+	/** Recipient agent id (resolved; "all" is expanded by the tool, not stored). */
+	to: string;
+	body: string;
+	ts: number;
+	/** Message id being answered. */
+	replyTo?: string;
+}
+
+export interface IrcDeliveryReceipt {
+	to: string;
+	outcome: "injected" | "woken" | "revived" | "failed";
+	error?: string;
+}
+
+interface IrcWaiter {
+	from?: string;
+	resolve: (msg: IrcMessage) => void;
+	cancel: () => void;
+}
+
+/** Mailbox cap per agent; oldest messages are dropped beyond it. */
+const MAILBOX_CAP = 100;
+
+export class IrcBus {
+	static #global: IrcBus | undefined;
+
+	static global(): IrcBus {
+		if (!IrcBus.#global) {
+			IrcBus.#global = new IrcBus();
+		}
+		return IrcBus.#global;
+	}
+
+	/** Reset the global bus. Test-only. */
+	static resetGlobalForTests(): void {
+		IrcBus.#global = undefined;
+	}
+
+	readonly #registry: AgentRegistry;
+	readonly #lifecycle: () => AgentLifecycleManager;
+	readonly #mailboxes = new Map<string, IrcMessage[]>();
+	readonly #waiters = new Map<string, IrcWaiter[]>();
+
+	constructor(registry: AgentRegistry = AgentRegistry.global(), lifecycle?: AgentLifecycleManager) {
+		this.#registry = registry;
+		// Lazy: the lifecycle global self-constructs against the global registry,
+		// so only touch it when a parked recipient actually needs reviving.
+		this.#lifecycle = () => lifecycle ?? AgentLifecycleManager.global();
+	}
+
+	/**
+	 * Fire-and-forget delivery. Never blocks on the recipient generating
+	 * anything: the receipt reports how the message reached the recipient
+	 * (waiter/aside = "injected", idle wake = "woken", park revival =
+	 * "revived"), not what they did with it.
+	 *
+	 * Mailbox semantics: a successfully delivered message never lingers in
+	 * the recipient's mailbox — injection/wake puts the full body into their
+	 * context, so buffering it too would double-deliver via a later
+	 * `wait`/`inbox` and inflate unread counts. Only a failed live hand-off
+	 * is buffered for the recipient to drain later.
+	 */
+	async send(msg: Omit<IrcMessage, "id" | "ts">): Promise<IrcDeliveryReceipt> {
+		const message: IrcMessage = { ...msg, id: Snowflake.next(), ts: Date.now() };
+		const ref = this.#registry.get(message.to);
+		if (!ref || ref.status === "aborted") {
+			return { to: message.to, outcome: "failed", error: `Unknown or terminated agent "${message.to}".` };
+		}
+
+		let revived = false;
+		if (ref.status === "parked") {
+			try {
+				await this.#lifecycle().ensureLive(message.to);
+				revived = true;
+			} catch (error) {
+				return {
+					to: message.to,
+					outcome: "failed",
+					error: error instanceof Error ? error.message : String(error),
+				};
+			}
+		}
+
+		// A pending `wait` from the recipient consumes the message directly —
+		// it is returned from their irc tool call and never hits the inbox or
+		// the session injection path.
+		const waiter = this.#takeMatchingWaiter(message.to, message.from);
+		if (waiter) {
+			waiter.resolve(message);
+			this.#relayToMainUi(message);
+			return { to: message.to, outcome: revived ? "revived" : "injected" };
+		}
+
+		const session = this.#registry.get(message.to)?.session;
+		if (!session) {
+			return { to: message.to, outcome: "failed", error: `Agent "${message.to}" has no live session.` };
+		}
+
+		try {
+			const delivery = await session.deliverIrcMessage(message);
+			this.#relayToMainUi(message);
+			return { to: message.to, outcome: revived ? "revived" : delivery };
+		} catch (error) {
+			// Live hand-off failed (e.g. recipient disposed mid-shutdown): buffer
+			// the message so a later `wait`/`inbox` from the recipient can still
+			// pick it up. The receipt stays "failed" — the recipient has not
+			// seen it.
+			this.#enqueue(message);
+			return {
+				to: message.to,
+				outcome: "failed",
+				error: error instanceof Error ? error.message : String(error),
+			};
+		}
+	}
+
+	/**
+	 * Block until a message for `agentId` (optionally from `filter.from`)
+	 * arrives; consume + return it. Null on timeout (`timeoutMs <= 0` waits
+	 * forever). Rejects when `signal` aborts. By default, already-buffered
+	 * mail satisfies the wait before parking a future waiter; callers that
+	 * need a strictly future reply can disable that drain.
+	 */
+	async wait(
+		agentId: string,
+		filter: { from?: string },
+		timeoutMs: number,
+		signal?: AbortSignal,
+		options?: { drainPending?: boolean },
+	): Promise<IrcMessage | null> {
+		if (signal?.aborted) {
+			throw signal.reason instanceof Error ? signal.reason : new Error("IRC wait aborted");
+		}
+
+		if (options?.drainPending !== false) {
+			// Already-pending mail satisfies the wait without parking a waiter.
+			const pending = this.#takeFromMailbox(agentId, filter.from);
+			if (pending) return pending;
+		}
+
+		const { promise, resolve, reject } = Promise.withResolvers<IrcMessage | null>();
+		let timer: NodeJS.Timeout | undefined;
+		let onAbort: (() => void) | undefined;
+
+		const waiter: IrcWaiter = {
+			from: filter.from,
+			resolve: msg => {
+				cleanup();
+				resolve(msg);
+			},
+			cancel: () => {
+				cleanup();
+			},
+		};
+		const cleanup = (): void => {
+			this.#removeWaiter(agentId, waiter);
+			clearTimeout(timer);
+			if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+		};
+
+		if (signal) {
+			onAbort = () => {
+				cleanup();
+				reject(signal.reason instanceof Error ? signal.reason : new Error("IRC wait aborted"));
+			};
+			signal.addEventListener("abort", onAbort, { once: true });
+		}
+		if (timeoutMs > 0) {
+			timer = setTimeout(() => {
+				cleanup();
+				resolve(null);
+			}, timeoutMs);
+			timer.unref?.();
+		}
+
+		let waiters = this.#waiters.get(agentId);
+		if (!waiters) {
+			waiters = [];
+			this.#waiters.set(agentId, waiters);
+		}
+		waiters.push(waiter);
+		return promise;
+	}
+
+	/** Drain (or peek) pending messages for `agentId`. */
+	inbox(agentId: string, opts?: { peek?: boolean }): IrcMessage[] {
+		const mailbox = this.#mailboxes.get(agentId);
+		if (!mailbox || mailbox.length === 0) return [];
+		if (opts?.peek) return [...mailbox];
+		this.#mailboxes.delete(agentId);
+		return mailbox;
+	}
+
+	unreadCount(agentId: string): number {
+		return this.#mailboxes.get(agentId)?.length ?? 0;
+	}
+
+	#enqueue(message: IrcMessage): void {
+		let mailbox = this.#mailboxes.get(message.to);
+		if (!mailbox) {
+			mailbox = [];
+			this.#mailboxes.set(message.to, mailbox);
+		}
+		mailbox.push(message);
+		if (mailbox.length > MAILBOX_CAP) {
+			const dropped = mailbox.shift();
+			logger.debug("IrcBus: mailbox full, dropped oldest message", {
+				agentId: message.to,
+				droppedId: dropped?.id,
+				droppedFrom: dropped?.from,
+			});
+		}
+	}
+
+	/** Resolve the OLDEST waiter for `agentId` whose from-filter accepts `from`. */
+	#takeMatchingWaiter(agentId: string, from: string): IrcWaiter | undefined {
+		const waiters = this.#waiters.get(agentId);
+		if (!waiters) return undefined;
+		const index = waiters.findIndex(waiter => !waiter.from || waiter.from === from);
+		if (index === -1) return undefined;
+		const [waiter] = waiters.splice(index, 1);
+		if (waiters.length === 0) this.#waiters.delete(agentId);
+		return waiter;
+	}
+
+	#removeWaiter(agentId: string, waiter: IrcWaiter): void {
+		const waiters = this.#waiters.get(agentId);
+		if (!waiters) return;
+		const index = waiters.indexOf(waiter);
+		if (index !== -1) waiters.splice(index, 1);
+		if (waiters.length === 0) this.#waiters.delete(agentId);
+	}
+
+	#takeFromMailbox(agentId: string, from?: string): IrcMessage | undefined {
+		const mailbox = this.#mailboxes.get(agentId);
+		if (!mailbox) return undefined;
+		const index = from ? mailbox.findIndex(msg => msg.from === from) : 0;
+		if (index === -1 || mailbox.length === 0) return undefined;
+		const [message] = mailbox.splice(index, 1);
+		if (mailbox.length === 0) this.#mailboxes.delete(agentId);
+		return message;
+	}
+
+	/**
+	 * Surface agent↔agent traffic as a display-only card on the main session
+	 * UI. Skipped when the main agent is either endpoint: as recipient its
+	 * own `deliverIrcMessage` (or `wait` tool result) already shows the
+	 * message, and as sender the irc send tool call already rendered the
+	 * outbound body — relaying it again would duplicate it in the transcript.
+	 */
+	#relayToMainUi(message: IrcMessage): void {
+		if (message.to === MAIN_AGENT_ID || message.from === MAIN_AGENT_ID) return;
+		const mainSession = this.#registry.get(MAIN_AGENT_ID)?.session;
+		if (!mainSession) return;
+		const record: CustomMessage = {
+			role: "custom",
+			customType: "irc:relay",
+			content: `[IRC \`${message.from}\` → \`${message.to}\`]\n\n${message.body}`,
+			display: true,
+			details: { from: message.from, to: message.to, body: message.body },
+			attribution: "agent",
+			timestamp: message.ts,
+		};
+		try {
+			mainSession.emitIrcRelayObservation(record);
+		} catch (error) {
+			// Display-only forwarding must never affect delivery semantics.
+			logger.debug("IrcBus: main UI relay failed", { to: message.to, error: String(error) });
+		}
+	}
+}

package/src/main.ts

@@ -51,7 +51,6 @@ import { ExtensionRunner } from "./extensibility/extensions/runner";
 import type { ExtensionUIContext } from "./extensibility/extensions/types";
 import { scheduleMarketplaceAutoUpdate } from "./extensibility/plugins/marketplace-auto-update";
 import type { MCPManager } from "./mcp";
-import { WelcomeComponent } from "./modes/components/welcome";
 import { InteractiveMode } from "./modes/interactive-mode";
 import type { PrintModeOptions } from "./modes/print-mode";
 import { CURRENT_SETUP_VERSION } from "./modes/setup-version";
@@ -70,7 +69,7 @@ import { resolveResumableSession, type SessionInfo, SessionManager } from "./ses
 import { discoverTitleSystemPromptFile, resolvePromptInput } from "./system-prompt";
 import { initTelemetryExport, isTelemetryExportEnabled } from "./telemetry-export";
 import { AUTO_THINKING } from "./thinking";
-import { discoverStartupLspServers, type LspStartupServerInfo } from "./tools";
+import type { LspStartupServerInfo } from "./tools";
 import {
 	getChangelogPath,
 	getNewEntries,
@@ -93,37 +92,12 @@ function maybeShowStartupSplash(options: {
 	resuming: boolean;
 	quiet: boolean;
 	version: string;
-	setupPending: boolean;
-	modelName?: string;
-	providerName?: string;
-	lspServers?: LspStartupServerInfo[];
 }): void {
 	if (!options.isInteractive) return;
 	if (options.resuming || options.quiet) return;
 	if ($env.PI_TIMING) return;
 	if (!process.stdin.isTTY || !process.stdout.isTTY) return;
-	// First-run launches go straight into the setup wizard, which paints its own
-	// splash — keep the minimal two-line notice there.
-	if (options.setupPending) {
-		process.stdout.write(`${chalk.dim(`omp ${options.version}`)}\n${chalk.dim("Initializing session…")}\n`);
-		return;
-	}
-	// Render the same welcome box the TUI paints first: recent sessions as a
-	// loading placeholder (the fixed slot count keeps the box height stable) and
-	// the logo held on the intro animation's first frame so the in-TUI intro
-	// continues from the frame shown here. Clearing the screen first puts the
-	// box at the same origin the TUI's first full paint (clearScrollback) uses,
-	// so the live welcome replaces this frame in place without shifting.
-	const welcome = new WelcomeComponent(
-		options.version,
-		options.modelName ?? "",
-		options.providerName ?? "",
-		null,
-		options.lspServers ?? [],
-	);
-	welcome.holdIntroFirstFrame();
-	const lines = welcome.render(process.stdout.columns || 80);
-	process.stdout.write(`\x1b[2J\x1b[H\x1b[3J\n${lines.join("\n")}\n`);
+	//process.stdout.write(`${chalk.dim(`omp ${options.version}`)}\n${chalk.dim("Initializing session…")}\n`);
 }
 
 async function checkForNewVersion(currentVersion: string): Promise<string | undefined> {
@@ -156,7 +130,7 @@ const HOST_DEFAULTED_SETTING_PATHS: SettingPath[] = [
 	"task.isolation.merge",
 	"task.isolation.commits",
 	"task.eager",
-	"task.simple",
+	"task.batch",
 	"task.maxConcurrency",
 	"task.maxRecursionDepth",
 	"task.disabledAgents",
@@ -425,7 +399,7 @@ async function runInteractiveMode(
 	// Every in-process session load also uses `clearTerminalHistory`; cold launch
 	// follows the same clean-cutover path instead of preserving a previous run's
 	// transcript above the fresh one.
-	mode.renderInitialMessages(undefined, { preserveExistingChat: true, clearTerminalHistory: true });
+	mode.renderInitialMessages({ preserveExistingChat: true, clearTerminalHistory: true });
 
 	for (const notify of notifs) {
 		if (!notify) {
@@ -1239,40 +1213,11 @@ export async function runRootCommand(
 			stdinContent: pipedInput,
 		});
 
-		// Resolve the model the session will most likely start with so the splash
-		// box matches the final welcome screen (the raw role selector, e.g.
-		// "anthropic/claude-fable-5:high", is wider than the left column and would
-		// collapse the box into the single-column layout).
-		let splashModel = sessionOptions.model;
-		if (!splashModel) {
-			const remembered = settingsInstance.getModelRole("default");
-			if (remembered) {
-				splashModel = resolveModelRoleValue(remembered, modelRegistry.getAll(), {
-					settings: settingsInstance,
-					matchPreferences: modelMatchPreferences,
-					modelRegistry,
-				}).model;
-			}
-		}
-		// Mirror createAgentSession's startup LSP discovery (sync and cheap: root
-		// markers + binary lookup) so the splash lists the same servers the live
-		// welcome screen will show.
-		const splashLspServers =
-			(sessionOptions.enableLsp ?? true)
-				? discoverStartupLspServers(
-						sessionOptions.cwd ?? cwd,
-						settingsInstance.get("lsp.lazy") ? "available" : "connecting",
-					)
-				: [];
 		maybeShowStartupSplash({
 			isInteractive,
 			resuming: Boolean(parsedArgs.continue || parsedArgs.resume || parsedArgs.fork),
 			quiet: settingsInstance.get("startup.quiet"),
 			version: VERSION,
-			setupPending: deps.forceSetupWizard === true || settingsInstance.get("setupVersion") < CURRENT_SETUP_VERSION,
-			modelName: splashModel?.name,
-			providerName: splashModel?.provider,
-			lspServers: splashLspServers,
 		});
 
 		const { session, setToolUIContext, modelFallbackMessage, lspServers, mcpManager } = await createSession({
@@ -1322,7 +1267,10 @@ export async function runRootCommand(
 						return `${scopedModel.model.id}${thinkingStr}`;
 					})
 					.join(", ");
-				process.stdout.write(`${chalk.dim(`Model scope: ${modelList} ${chalk.gray("(Ctrl+P to cycle)")}`)}\n`);
+				// Routed through the TUI (not stdout): the startup capture owns the
+				// terminal in raw mode here, and the TUI's first clearScrollback paint
+				// would wipe a pre-TUI line anyway.
+				notifs.push({ kind: "info", message: `Model scope: ${modelList} (Ctrl+P to cycle)` });
 			}
 
 			if ($env.PI_TIMING) {

package/src/mcp/manager.ts

@@ -1174,12 +1174,15 @@ export class MCPManager {
 					const shouldRefresh =
 						forceRefresh || (credential.expires && Date.now() >= credential.expires - REFRESH_BUFFER_MS);
 					if (shouldRefresh && credential.refresh && auth.tokenUrl) {
+						const resource =
+							auth.resource ?? (config.type === "http" || config.type === "sse" ? config.url : undefined);
 						try {
 							const refreshed = await refreshMCPOAuthToken(
 								auth.tokenUrl,
 								credential.refresh,
 								auth.clientId,
 								auth.clientSecret,
+								resource,
 							);
 							const refreshedCredential = { type: "oauth" as const, ...refreshed };
 							await this.#authStorage.set(credentialId, refreshedCredential);