@primitivedotdev/cli 0.31.4 → 0.31.6

package/dist/oclif/index.js

@@ -651,6 +651,7 @@ var sdk_gen_exports = /* @__PURE__ */ __exportAll({
 	getEmail: () => getEmail,
 	getFunction: () => getFunction,
 	getFunctionTestRunTrace: () => getFunctionTestRunTrace,
+	getInboxStatus: () => getInboxStatus,
 	getSendPermissions: () => getSendPermissions,
 	getSentEmail: () => getSentEmail,
 	getStorageStats: () => getStorageStats,
@@ -1033,6 +1034,28 @@ const downloadDomainZoneFile = (options) => (options.client ?? client).get({
 	...options
 });
 /**
+* Get inbound inbox readiness
+*
+* Returns one consolidated view of inbound domain readiness,
+* webhook/function processing routes, deployed Functions, and
+* recent inbound email activity.
+*
+* Agents should call this before guiding a user through inbound
+* setup. It answers the practical questions "can I receive mail",
+* "will anything process that mail", and "what should I do next"
+* without forcing clients to stitch together domains, endpoints,
+* functions, and emails manually.
+*
+*/
+const getInboxStatus = (options) => (options?.client ?? client).get({
+	security: [{
+		scheme: "bearer",
+		type: "http"
+	}],
+	url: "/inbox/status",
+	...options
+});
+/**
 * List inbound emails
 *
 * Returns a paginated list of INBOUND emails received at your
@@ -1894,6 +1917,10 @@ const openapiDocument = {
 			"name": "Domains",
 			"description": "Claim, verify, and manage email domains"
 		},
+		{
+			"name": "Inbox",
+			"description": "Check inbound email setup and processing readiness"
+		},
 		{
 			"name": "Emails",
 			"description": "List, inspect, and manage received emails"
@@ -2500,6 +2527,23 @@ const openapiDocument = {
 				}
 			}
 		},
+		"/inbox/status": { "get": {
+			"operationId": "getInboxStatus",
+			"summary": "Get inbound inbox readiness",
+			"description": "Returns one consolidated view of inbound domain readiness,\nwebhook/function processing routes, deployed Functions, and\nrecent inbound email activity.\n\nAgents should call this before guiding a user through inbound\nsetup. It answers the practical questions \"can I receive mail\",\n\"will anything process that mail\", and \"what should I do next\"\nwithout forcing clients to stitch together domains, endpoints,\nfunctions, and emails manually.\n",
+			"tags": ["Inbox"],
+			"responses": {
+				"200": {
+					"description": "Consolidated inbox readiness status",
+					"content": { "application/json": { "schema": { "allOf": [{ "$ref": "#/components/schemas/SuccessEnvelope" }, {
+						"type": "object",
+						"properties": { "data": { "$ref": "#/components/schemas/InboxStatus" } }
+					}] } } }
+				},
+				"401": { "$ref": "#/components/responses/Unauthorized" },
+				"429": { "$ref": "#/components/responses/RateLimited" }
+			}
+		} },
 		"/emails": { "get": {
 			"operationId": "listEmails",
 			"summary": "List inbound emails",
@@ -4788,6 +4832,181 @@ const openapiDocument = {
 				} },
 				"required": ["secret"]
 			},
+			"InboxStatus": {
+				"type": "object",
+				"additionalProperties": false,
+				"properties": {
+					"ready": {
+						"type": "boolean",
+						"description": "True when at least one active inbound domain has an enabled processing route."
+					},
+					"receiving_ready": {
+						"type": "boolean",
+						"description": "True when at least one active verified or managed domain can receive mail."
+					},
+					"processing_ready": {
+						"type": "boolean",
+						"description": "True when at least one receiving-ready domain has an enabled webhook or function route."
+					},
+					"summary": {
+						"type": "string",
+						"description": "Short human-readable status summary."
+					},
+					"next_actions": {
+						"type": "array",
+						"items": { "$ref": "#/components/schemas/InboxStatusNextAction" }
+					},
+					"domains": {
+						"type": "array",
+						"items": { "$ref": "#/components/schemas/InboxStatusDomain" }
+					},
+					"endpoints": { "$ref": "#/components/schemas/InboxStatusEndpointSummary" },
+					"functions": { "$ref": "#/components/schemas/InboxStatusFunctionSummary" },
+					"recent_emails": { "$ref": "#/components/schemas/InboxStatusRecentEmailSummary" }
+				},
+				"required": [
+					"ready",
+					"receiving_ready",
+					"processing_ready",
+					"summary",
+					"next_actions",
+					"domains",
+					"endpoints",
+					"functions",
+					"recent_emails"
+				]
+			},
+			"InboxStatusNextAction": {
+				"type": "object",
+				"additionalProperties": false,
+				"properties": {
+					"kind": {
+						"type": "string",
+						"enum": [
+							"add_domain",
+							"verify_domain",
+							"configure_processing",
+							"send_test_email",
+							"fix_failed_functions"
+						]
+					},
+					"message": {
+						"type": "string",
+						"description": "Human-readable next step."
+					},
+					"command": {
+						"type": "string",
+						"description": "Suggested Primitive CLI command when there is an obvious next step."
+					}
+				},
+				"required": ["kind", "message"]
+			},
+			"InboxStatusDomain": {
+				"type": "object",
+				"additionalProperties": false,
+				"properties": {
+					"id": { "type": "string" },
+					"domain": { "type": "string" },
+					"verified": { "type": "boolean" },
+					"active": { "type": "boolean" },
+					"managed": { "type": "boolean" },
+					"receiving_ready": { "type": "boolean" },
+					"processing_ready": { "type": "boolean" },
+					"processing_route_count": { "type": "integer" },
+					"endpoint_count": { "type": "integer" },
+					"enabled_endpoint_count": { "type": "integer" },
+					"function_endpoint_count": { "type": "integer" },
+					"email_count": {
+						"type": "integer",
+						"description": "Number of inbound emails received for this domain in the last 30 days."
+					},
+					"latest_email_received_at": {
+						"type": ["string", "null"],
+						"format": "date-time",
+						"description": "Most recent inbound email received for this domain in the last 30 days."
+					},
+					"status": {
+						"type": "string",
+						"enum": [
+							"ready",
+							"stored_only",
+							"pending_dns",
+							"inactive"
+						]
+					}
+				},
+				"required": [
+					"id",
+					"domain",
+					"verified",
+					"active",
+					"managed",
+					"receiving_ready",
+					"processing_ready",
+					"processing_route_count",
+					"endpoint_count",
+					"enabled_endpoint_count",
+					"function_endpoint_count",
+					"email_count",
+					"latest_email_received_at",
+					"status"
+				]
+			},
+			"InboxStatusEndpointSummary": {
+				"type": "object",
+				"additionalProperties": false,
+				"properties": {
+					"total": { "type": "integer" },
+					"enabled": { "type": "integer" },
+					"disabled": { "type": "integer" },
+					"fallback_enabled": { "type": "integer" },
+					"domain_scoped_enabled": { "type": "integer" },
+					"http_enabled": { "type": "integer" },
+					"function_enabled": { "type": "integer" }
+				},
+				"required": [
+					"total",
+					"enabled",
+					"disabled",
+					"fallback_enabled",
+					"domain_scoped_enabled",
+					"http_enabled",
+					"function_enabled"
+				]
+			},
+			"InboxStatusFunctionSummary": {
+				"type": "object",
+				"additionalProperties": false,
+				"properties": {
+					"total": { "type": "integer" },
+					"deployed": { "type": "integer" },
+					"pending": { "type": "integer" },
+					"failed": { "type": "integer" }
+				},
+				"required": [
+					"total",
+					"deployed",
+					"pending",
+					"failed"
+				]
+			},
+			"InboxStatusRecentEmailSummary": {
+				"type": "object",
+				"description": "Inbound email activity from the last 30 days.",
+				"additionalProperties": false,
+				"properties": {
+					"total": {
+						"type": "integer",
+						"description": "Number of inbound emails received in the last 30 days."
+					},
+					"latest_received_at": {
+						"type": ["string", "null"],
+						"format": "date-time",
+						"description": "Most recent inbound email received in the last 30 days."
+					}
+				},
+				"required": ["total", "latest_received_at"]
+			},
 			"Domain": {
 				"description": "A domain can be either verified or unverified. Verified domains have\n`is_active` and `spam_threshold` fields. Unverified domains have a\n`verification_token` and `dns_records` for DNS setup.\n",
 				"oneOf": [{ "$ref": "#/components/schemas/VerifiedDomain" }, { "$ref": "#/components/schemas/UnverifiedDomain" }]
@@ -10881,6 +11100,193 @@ const operationManifest = [
 		"tag": "Functions",
 		"tagCommand": "functions"
 	},
+	{
+		"binaryResponse": false,
+		"bodyRequired": false,
+		"command": "get-inbox-status",
+		"description": "Returns one consolidated view of inbound domain readiness,\nwebhook/function processing routes, deployed Functions, and\nrecent inbound email activity.\n\nAgents should call this before guiding a user through inbound\nsetup. It answers the practical questions \"can I receive mail\",\n\"will anything process that mail\", and \"what should I do next\"\nwithout forcing clients to stitch together domains, endpoints,\nfunctions, and emails manually.\n",
+		"hasJsonBody": false,
+		"method": "GET",
+		"operationId": "getInboxStatus",
+		"path": "/inbox/status",
+		"pathParams": [],
+		"queryParams": [],
+		"requestSchema": null,
+		"responseSchema": {
+			"type": "object",
+			"additionalProperties": false,
+			"properties": {
+				"ready": {
+					"type": "boolean",
+					"description": "True when at least one active inbound domain has an enabled processing route."
+				},
+				"receiving_ready": {
+					"type": "boolean",
+					"description": "True when at least one active verified or managed domain can receive mail."
+				},
+				"processing_ready": {
+					"type": "boolean",
+					"description": "True when at least one receiving-ready domain has an enabled webhook or function route."
+				},
+				"summary": {
+					"type": "string",
+					"description": "Short human-readable status summary."
+				},
+				"next_actions": {
+					"type": "array",
+					"items": {
+						"type": "object",
+						"additionalProperties": false,
+						"properties": {
+							"kind": {
+								"type": "string",
+								"enum": [
+									"add_domain",
+									"verify_domain",
+									"configure_processing",
+									"send_test_email",
+									"fix_failed_functions"
+								]
+							},
+							"message": {
+								"type": "string",
+								"description": "Human-readable next step."
+							},
+							"command": {
+								"type": "string",
+								"description": "Suggested Primitive CLI command when there is an obvious next step."
+							}
+						},
+						"required": ["kind", "message"]
+					}
+				},
+				"domains": {
+					"type": "array",
+					"items": {
+						"type": "object",
+						"additionalProperties": false,
+						"properties": {
+							"id": { "type": "string" },
+							"domain": { "type": "string" },
+							"verified": { "type": "boolean" },
+							"active": { "type": "boolean" },
+							"managed": { "type": "boolean" },
+							"receiving_ready": { "type": "boolean" },
+							"processing_ready": { "type": "boolean" },
+							"processing_route_count": { "type": "integer" },
+							"endpoint_count": { "type": "integer" },
+							"enabled_endpoint_count": { "type": "integer" },
+							"function_endpoint_count": { "type": "integer" },
+							"email_count": {
+								"type": "integer",
+								"description": "Number of inbound emails received for this domain in the last 30 days."
+							},
+							"latest_email_received_at": {
+								"type": ["string", "null"],
+								"format": "date-time",
+								"description": "Most recent inbound email received for this domain in the last 30 days."
+							},
+							"status": {
+								"type": "string",
+								"enum": [
+									"ready",
+									"stored_only",
+									"pending_dns",
+									"inactive"
+								]
+							}
+						},
+						"required": [
+							"id",
+							"domain",
+							"verified",
+							"active",
+							"managed",
+							"receiving_ready",
+							"processing_ready",
+							"processing_route_count",
+							"endpoint_count",
+							"enabled_endpoint_count",
+							"function_endpoint_count",
+							"email_count",
+							"latest_email_received_at",
+							"status"
+						]
+					}
+				},
+				"endpoints": {
+					"type": "object",
+					"additionalProperties": false,
+					"properties": {
+						"total": { "type": "integer" },
+						"enabled": { "type": "integer" },
+						"disabled": { "type": "integer" },
+						"fallback_enabled": { "type": "integer" },
+						"domain_scoped_enabled": { "type": "integer" },
+						"http_enabled": { "type": "integer" },
+						"function_enabled": { "type": "integer" }
+					},
+					"required": [
+						"total",
+						"enabled",
+						"disabled",
+						"fallback_enabled",
+						"domain_scoped_enabled",
+						"http_enabled",
+						"function_enabled"
+					]
+				},
+				"functions": {
+					"type": "object",
+					"additionalProperties": false,
+					"properties": {
+						"total": { "type": "integer" },
+						"deployed": { "type": "integer" },
+						"pending": { "type": "integer" },
+						"failed": { "type": "integer" }
+					},
+					"required": [
+						"total",
+						"deployed",
+						"pending",
+						"failed"
+					]
+				},
+				"recent_emails": {
+					"type": "object",
+					"description": "Inbound email activity from the last 30 days.",
+					"additionalProperties": false,
+					"properties": {
+						"total": {
+							"type": "integer",
+							"description": "Number of inbound emails received in the last 30 days."
+						},
+						"latest_received_at": {
+							"type": ["string", "null"],
+							"format": "date-time",
+							"description": "Most recent inbound email received in the last 30 days."
+						}
+					},
+					"required": ["total", "latest_received_at"]
+				}
+			},
+			"required": [
+				"ready",
+				"receiving_ready",
+				"processing_ready",
+				"summary",
+				"next_actions",
+				"domains",
+				"endpoints",
+				"functions",
+				"recent_emails"
+			]
+		},
+		"sdkName": "getInboxStatus",
+		"summary": "Get inbound inbox readiness",
+		"tag": "Inbox",
+		"tagCommand": "inbox"
+	},
 	{
 		"binaryResponse": false,
 		"bodyRequired": false,
@@ -12973,7 +13379,7 @@ function surfaceUnauthorizedHint(params) {
 	}
 	process.stderr.write("Your saved Primitive CLI OAuth session was rejected. If the command was working a moment ago, please retry; brief retries often clear transient rejections. If it keeps failing, run `primitive logout && primitive signin` to mint a fresh session.\n");
 }
-function formatElapsed(ms) {
+function formatElapsed$1(ms) {
 	const seconds = ms / 1e3;
 	if (seconds < 60) return `${seconds.toFixed(2)}s`;
 	const minutes = Math.floor(seconds / 60);
@@ -12985,7 +13391,7 @@ async function runWithTiming(enabled, fn) {
 	try {
 		return await fn();
 	} finally {
-		process.stderr.write(`[time: ${formatElapsed(Date.now() - start)}]\n`);
+		process.stderr.write(`[time: ${formatElapsed$1(Date.now() - start)}]\n`);
 	}
 }
 const TIME_FLAG_DESCRIPTION = "Print the wall-clock duration of this command to stderr after it completes (e.g. `[time: 1.34s]`). Useful for measuring `--wait` send latency, comparing CLI overhead, or capturing timing in scripts.";
@@ -13082,6 +13488,7 @@ const OPERATION_HINTS = {
 	addDomain: "Tip: after this returns a domain id, run `primitive domains zone-file --id <domain-id> --output <domain>.zone` when the user wants an importable DNS zone file.",
 	verifyDomain: "Tip: if DNS is still missing, run `primitive domains zone-file --id <domain-id> --output <domain>.zone` to give the user an importable DNS zone file.",
 	downloadDomainZoneFile: "Tip: prefer `primitive domains zone-file --id <domain-id> --output <domain>.zone` for CLI-friendly file output.",
+	getInboxStatus: "Tip: prefer `primitive inbox status` for a compact readiness summary and next-step commands.",
 	sendEmail: "Tip: prefer `primitive send --to <address> --body <text> --attachment <file>` for file attachments. This raw command exists for callers passing JSON.",
 	createFunction: "Tip: prefer `primitive functions deploy --name <name> --file <bundle>` for file-input ergonomics. This raw command exists for callers passing JSON.",
 	updateFunction: "Tip: prefer `primitive functions redeploy --id <id> --file <bundle>` for file-input ergonomics. This raw command exists for callers passing JSON.",
@@ -13348,6 +13755,300 @@ async function readStdinToString() {
 	for await (const chunk of process.stdin) chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
 	return Buffer.concat(chunks).toString("utf8");
 }
+var ChatProgressIndicator = class {
+	currentMessage = null;
+	frameIndex = 0;
+	lastLineLength = 0;
+	startedAt;
+	timer = null;
+	constructor(stream = process.stderr, now = Date.now) {
+		this.stream = stream;
+		this.now = now;
+		this.startedAt = this.now();
+	}
+	start(message) {
+		this.stopTimer();
+		this.currentMessage = message;
+		if (this.stream.isTTY) {
+			this.render(message);
+			this.timer = setInterval(() => this.render(message), 120);
+			this.timer.unref?.();
+			return;
+		}
+		this.stream.write(`${message}\n`);
+	}
+	update(message, options = {}) {
+		this.currentMessage = message;
+		if (this.stream.isTTY) {
+			this.stopTimer();
+			this.clearLine();
+			this.render(message);
+			this.timer = setInterval(() => this.render(message), 120);
+			this.timer.unref?.();
+			return;
+		}
+		this.stopTimer();
+		this.stream.write(`${message}\n`);
+		if (options.heartbeatMs !== void 0) {
+			this.timer = setInterval(() => {
+				this.stream.write(`${formatWaitingHeartbeat(message, this.now() - this.startedAt, options.timeoutSeconds)}\n`);
+			}, options.heartbeatMs);
+			this.timer.unref?.();
+		}
+	}
+	notice(message) {
+		if (this.stream.isTTY) {
+			const currentMessage = this.currentMessage;
+			this.clearLine();
+			this.stream.write(`${message}\n`);
+			if (currentMessage !== null && this.timer !== null) this.render(currentMessage);
+			return;
+		}
+		this.stream.write(`${message}\n`);
+	}
+	succeed(message) {
+		this.finish(`${message} after ${formatElapsed(this.now() - this.startedAt)}.`);
+	}
+	fail(message) {
+		this.finish(message);
+	}
+	finish(message) {
+		this.stopTimer();
+		this.currentMessage = null;
+		if (this.stream.isTTY) this.clearLine();
+		this.stream.write(`${message}\n`);
+	}
+	render(message) {
+		const frames = [
+			"-",
+			"\\",
+			"|",
+			"/"
+		];
+		const frame = frames[this.frameIndex % frames.length];
+		this.frameIndex += 1;
+		const line = `${frame} ${message} (${formatElapsed(this.now() - this.startedAt)})`;
+		this.lastLineLength = Math.max(this.lastLineLength, line.length);
+		this.stream.write(`\r${line}`);
+	}
+	clearLine() {
+		if (this.lastLineLength > 0) {
+			this.stream.write(`\r${" ".repeat(this.lastLineLength)}\r`);
+			this.lastLineLength = 0;
+		}
+	}
+	stopTimer() {
+		if (this.timer !== null) {
+			clearInterval(this.timer);
+			this.timer = null;
+		}
+	}
+};
+function formatElapsed(ms) {
+	const seconds = Math.max(0, Math.round(ms / 1e3));
+	if (seconds < 60) return `${seconds}s`;
+	const minutes = Math.floor(seconds / 60);
+	const remainder = seconds % 60;
+	return remainder === 0 ? `${minutes}m` : `${minutes}m ${remainder}s`;
+}
+function formatWaitingHeartbeat(message, elapsedMs, timeoutSeconds) {
+	const timeout = timeoutSeconds === void 0 ? "" : timeoutSeconds === 0 ? ", no timeout" : `, timeout ${formatElapsed(timeoutSeconds * 1e3)}`;
+	return `${message} (${formatElapsed(elapsedMs)} elapsed${timeout})`;
+}
+function shellQuote(value) {
+	if (/^[A-Za-z0-9_./:@%+=,-]+$/.test(value)) return value;
+	return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function commandFromArgv(argv) {
+	return argv.map(shellQuote).join(" ");
+}
+function resolveChatResponseBody(reply) {
+	if (reply.body_text && reply.body_text.length > 0) return {
+		body: reply.body_text,
+		format: "text"
+	};
+	if (reply.body_html && reply.body_html.length > 0) return {
+		body: reply.body_html,
+		format: "html"
+	};
+	if (reply.body_text !== null && reply.body_text !== void 0) return {
+		body: reply.body_text,
+		format: "text"
+	};
+	if (reply.body_html !== null && reply.body_html !== void 0) return {
+		body: reply.body_html,
+		format: "html"
+	};
+	return {
+		body: "",
+		format: "empty"
+	};
+}
+function matchDescription(strategy) {
+	return strategy === "strict" ? "strict, matched by reply_to_sent_email_id" : "fallback, matched by sender/time window";
+}
+function buildCommand(kind, description, argv, options = {}) {
+	const requiresMessage = options.requiresMessage ?? false;
+	return {
+		argv,
+		description,
+		command: commandFromArgv(argv),
+		kind,
+		placeholders: requiresMessage ? [{
+			description: "Replace with the message body before running.",
+			token: "<message>"
+		}] : [],
+		requires_message: requiresMessage
+	};
+}
+function buildChatFollowUpCommands(context) {
+	const commands = [];
+	const continueParts = [
+		"primitive",
+		"chat",
+		context.recipient,
+		"<message>",
+		"--from",
+		context.from,
+		"--subject",
+		context.subject,
+		"--timeout",
+		String(context.timeoutSeconds)
+	];
+	if (context.reply.message_id) continueParts.push("--in-reply-to", context.reply.message_id);
+	if (context.json) continueParts.push("--json");
+	if (context.quiet) continueParts.push("--quiet");
+	if (context.strictOnly) continueParts.push("--strict-only");
+	else if (context.strictPhaseSeconds !== DEFAULT_STRICT_PHASE_SECONDS) continueParts.push("--strict-phase-seconds", String(context.strictPhaseSeconds));
+	commands.push(buildCommand("continue_chat", "Continue this chat", continueParts, { requiresMessage: true }));
+	commands.push(buildCommand("reply_direct", "Reply directly to the inbound email", [
+		"primitive",
+		"reply",
+		"--id",
+		context.reply.id,
+		"--from",
+		context.from,
+		"--body",
+		"<message>"
+	], { requiresMessage: true }));
+	commands.push(buildCommand("inspect_reply", "Inspect the full inbound email", [
+		"primitive",
+		"emails",
+		"get",
+		"--id",
+		context.reply.id
+	]));
+	commands.push(buildCommand("wait_for_more", "Wait for future replies to this send", [
+		"primitive",
+		"emails",
+		"wait",
+		"--reply-to-sent-email-id",
+		context.sent.id,
+		"--to",
+		context.from,
+		"--since",
+		context.reply.received_at,
+		"--timeout",
+		String(context.timeoutSeconds)
+	]));
+	return commands;
+}
+function buildChatRecoveryCommands(context) {
+	return [
+		buildCommand("wait_threaded_reply", "Wait for the threaded reply again", [
+			"primitive",
+			"emails",
+			"wait",
+			"--reply-to-sent-email-id",
+			context.sent.id,
+			"--to",
+			context.from,
+			"--since",
+			context.sentAtIso,
+			"--timeout",
+			String(context.timeoutSeconds)
+		]),
+		buildCommand("wait_fallback_reply", "Fallback wait by sender/time window", [
+			"primitive",
+			"emails",
+			"wait",
+			"--from",
+			context.recipient,
+			"--to",
+			context.from,
+			"--since",
+			context.sentAtIso,
+			"--timeout",
+			String(context.timeoutSeconds)
+		]),
+		buildCommand("inspect_sent_email", "Inspect the outbound send", [
+			"primitive",
+			"sent",
+			"get",
+			"--id",
+			context.sent.id
+		])
+	];
+}
+function buildChatJsonEnvelope(context) {
+	const responseBody = resolveChatResponseBody(context.reply);
+	return {
+		sent: context.sent,
+		reply: context.reply,
+		response_body: responseBody.body,
+		response_body_format: responseBody.format,
+		match: {
+			description: matchDescription(context.matchStrategy),
+			reply_to_sent_email_id: context.reply.reply_to_sent_email_id ?? null,
+			strategy: context.matchStrategy
+		},
+		follow_up_commands: buildChatFollowUpCommands(context)
+	};
+}
+function formatChatResponse(context) {
+	const accepted = context.sent.accepted.join(", ") || context.recipient;
+	const responseBody = resolveChatResponseBody(context.reply);
+	const lines = [
+		"Reply received",
+		"",
+		"Sent",
+		`  To: ${accepted}`,
+		`  From: ${context.sent.from || context.from}`,
+		`  Subject: ${context.subject}`,
+		`  Sent email id: ${context.sent.id}`,
+		`  Delivery status: ${context.sent.delivery_status ?? context.sent.status}`,
+		"",
+		"Reply",
+		`  Email id: ${context.reply.id}`,
+		`  From: ${context.reply.from_email}`,
+		`  To: ${context.reply.to_email}`,
+		`  Subject: ${context.reply.subject ?? "(no subject)"}`,
+		`  Received: ${context.reply.received_at}`,
+		`  Match: ${matchDescription(context.matchStrategy)}`
+	];
+	if (context.reply.reply_to_sent_email_id) lines.push(`  Reply to sent email id: ${context.reply.reply_to_sent_email_id}`);
+	if (context.reply.message_id) lines.push(`  Message-Id: ${context.reply.message_id}`);
+	lines.push("", "Helpful follow-up commands", "  Replace <message> before running commands that include it.", "  Commands are templates; use --json for parse-safe output.");
+	for (const { description, command } of buildChatFollowUpCommands(context)) lines.push(`  ${description}:`, `    ${command}`);
+	lines.push("", `Response body (${responseBody.format}; use --json for parsing)`, "----- BEGIN RESPONSE -----", responseBody.body || "(empty response)", "----- END RESPONSE -----");
+	return lines.join("\n");
+}
+function formatChatRecoveryContext(context) {
+	const lines = [
+		"",
+		"Sent message context",
+		`  To: ${context.sent.accepted.join(", ") || context.recipient}`,
+		`  From: ${context.sent.from || context.from}`,
+		`  Subject: ${context.subject}`,
+		`  Sent email id: ${context.sent.id}`,
+		`  Delivery status: ${context.sent.delivery_status ?? context.sent.status}`,
+		`  Poll since: ${context.sentAtIso}`,
+		"",
+		"Helpful recovery commands"
+	];
+	for (const { description, command } of buildChatRecoveryCommands(context)) lines.push(`  ${description}:`, `    ${command}`);
+	return lines.join("\n");
+}
 var ChatCommand = class ChatCommand extends Command {
 	static description = `Send a message to an address and wait for the reply.
 
@@ -13356,13 +14057,24 @@ var ChatCommand = class ChatCommand extends Command {
   \`primitive chat\` is semantic (send + wait for the threaded reply).
 
   The message body can be given as the second positional argument or
-  piped via stdin. The reply body is written to stdout; --json emits a
-  structured envelope with both sides of the exchange.
+  piped via stdin. The default output confirms the reply was received,
+  prints exchange metadata, shows the response body, and lists helpful
+  follow-up commands as templates. The default transcript is for humans;
+  agents and scripts should pass --json for parse-safe output.
+
+  --json emits a structured envelope with both sides of the exchange,
+  a direct response_body field, match details, and follow-up command
+  metadata such as kind, argv, placeholders, and requires_message.
 
-  Matching the reply: the wait phase polls inbound mail filtered by
-  the recipient as sender and the send time as a lower bound. The
-  first match is taken; the full inbound row is then fetched for the
-  body. Exits non-zero on timeout.`;
+  Matching the reply: chat first waits in strict threading mode by
+  filtering inbound mail with reply_to_sent_email_id=<sent id>. If
+  no strict match arrives before the strict phase ends, and
+  --strict-only is not set, it falls back to a weaker sender/time
+  window match: from=<recipient>, to=<sender>, and since=<send time>.
+  The fallback can catch clients that strip threading headers, but it
+  is less exact than strict matching. Progress is written to stderr
+  while the CLI waits. Exits non-zero on timeout and prints recovery
+  commands when the send succeeded but no reply was returned.`;
 	static summary = "Chat with an agent over email (send and wait for the reply)";
 	static examples = [
 		"<%= config.bin %> chat help@agent.acme.dev 'how do I rotate my API key?'",
@@ -13395,7 +14107,8 @@ var ChatCommand = class ChatCommand extends Command {
 		from: Flags.string({ description: "Sender address. Defaults to agent@<your-first-verified-outbound-domain>." }),
 		subject: Flags.string({ description: "Subject line. Defaults to the first line of the message when omitted." }),
 		"in-reply-to": Flags.string({ description: "Message-Id of the parent email to thread this against. Use when continuing a prior conversation from outside the CLI; for an inbound you received via Primitive, prefer `primitive reply --id <inbound-id>`." }),
-		json: Flags.boolean({ description: "Emit a structured JSON envelope { sent, reply } on stdout instead of just the reply body." }),
+		json: Flags.boolean({ description: "Emit a structured JSON envelope { sent, reply, response_body, response_body_format, match, follow_up_commands } on stdout instead of the human-readable transcript." }),
+		quiet: Flags.boolean({ description: "Suppress stderr progress updates while sending and waiting. Errors and recovery commands are still written to stderr." }),
 		timeout: Flags.integer({
 			default: DEFAULT_CHAT_TIMEOUT_SECONDS,
 			description: "Seconds to wait for a reply before exiting non-zero; 0 waits forever.",
@@ -13440,6 +14153,8 @@ var ChatCommand = class ChatCommand extends Command {
 			const from = flags.from ?? await pickDefaultFromAddress(apiClient, authFailureContext);
 			const subject = flags.subject ?? deriveSubject(message);
 			const sentAtIso = (/* @__PURE__ */ new Date()).toISOString();
+			const progress = flags.quiet ? null : new ChatProgressIndicator(process.stderr);
+			progress?.start(`Sending message to ${args.recipient}`);
 			const sendResult = await sendEmail({
 				body: {
 					from,
@@ -13452,6 +14167,7 @@ var ChatCommand = class ChatCommand extends Command {
 				responseStyle: "fields"
 			});
 			if (sendResult.error) {
+				progress?.fail("Message send failed.");
 				const errorPayload = extractErrorPayload(sendResult.error);
 				writeErrorWithHints(errorPayload);
 				surfaceUnauthorizedHint({
@@ -13462,39 +14178,76 @@ var ChatCommand = class ChatCommand extends Command {
 				return;
 			}
 			const sent = sendResult.data?.data;
-			if (!sent) throw cliError$6("Send succeeded but the API returned no data.");
-			const reply = await waitForReply({
-				apiClient,
-				authFailureContext,
+			if (!sent) {
+				progress?.fail("Send succeeded but the API returned no data.");
+				throw cliError$6("Send succeeded but the API returned no data.");
+			}
+			progress?.update(`Message sent; waiting for reply from ${args.recipient}`, {
+				heartbeatMs: 15e3,
+				timeoutSeconds: flags.timeout
+			});
+			const baseContext = {
 				from,
-				interval: flags.interval,
-				pageSize: flags["page-size"],
+				json: flags.json,
+				quiet: flags.quiet,
 				recipient: args.recipient,
+				sent,
 				sentAtIso,
-				sentId: sent.id,
 				strictOnly: flags["strict-only"],
 				strictPhaseSeconds: flags["strict-phase-seconds"],
+				subject,
 				timeoutSeconds: flags.timeout
-			});
-			if (reply === null) {
-				process.stderr.write(`Timed out after ${flags.timeout}s waiting for a reply from ${args.recipient}.\n`);
+			};
+			let replyResult;
+			try {
+				replyResult = await waitForReply({
+					apiClient,
+					authFailureContext,
+					from,
+					interval: flags.interval,
+					notice: (message) => {
+						if (progress) {
+							progress.notice(message);
+							return;
+						}
+						process.stderr.write(`${message}\n`);
+					},
+					pageSize: flags["page-size"],
+					recipient: args.recipient,
+					sentAtIso,
+					sentId: sent.id,
+					strictOnly: flags["strict-only"],
+					strictPhaseSeconds: flags["strict-phase-seconds"],
+					timeoutSeconds: flags.timeout
+				});
+			} catch (error) {
+				progress?.fail("Reply polling failed.");
+				process.stderr.write(`${formatChatRecoveryContext(baseContext)}\n`);
+				throw error;
+			}
+			if (replyResult === null) {
+				const timeoutMessage = `Timed out after ${flags.timeout}s waiting for a reply from ${args.recipient}.`;
+				progress?.fail(timeoutMessage);
+				if (progress === null) process.stderr.write(`${timeoutMessage}\n`);
+				process.stderr.write(`${formatChatRecoveryContext(baseContext)}\n`);
 				process.exitCode = 1;
 				return;
 			}
-			if (flags.json) {
-				const envelope = {
-					sent,
-					reply
-				};
-				this.log(JSON.stringify(envelope, null, 2));
-			} else {
-				const body = reply.body_text ?? reply.body_html ?? "";
-				this.log(body);
-			}
+			progress?.succeed(`Reply received from ${replyResult.reply.from_email}`);
+			const outputContext = {
+				...baseContext,
+				matchStrategy: replyResult.matchStrategy,
+				reply: replyResult.reply
+			};
+			if (flags.json) this.log(JSON.stringify(buildChatJsonEnvelope(outputContext), null, 2));
+			else this.log(formatChatResponse(outputContext));
 		});
 	}
 };
 async function waitForReply(params) {
+	const notice = params.notice ?? ((message) => {
+		process.stderr.write(`${message}\n`);
+	});
 	const totalDeadline = params.timeoutSeconds === 0 ? null : Date.now() + params.timeoutSeconds * 1e3;
 	const strictDeadlineFromBudget = Date.now() + params.strictPhaseSeconds * 1e3;
 	const strictDeadline = params.strictOnly ? totalDeadline : totalDeadline === null ? strictDeadlineFromBudget : Math.min(strictDeadlineFromBudget, totalDeadline);
@@ -13563,11 +14316,14 @@ async function waitForReply(params) {
 				const detail = envelope?.data ?? envelope ?? null;
 				if (!detail) throw new Errors.CLIError(`Reply landed but the email body could not be loaded (id=${match.id}).`, { exit: 1 });
 				if (phase.label === "strict" && detail.reply_to_sent_email_id !== params.sentId) {
-					if (!strictFilterUnsupported) process.stderr.write(params.strictOnly ? "Strict-phase reply matching is not supported by this Primitive API host; --strict-only requires server support so the command will exit without a match.\n" : "Strict-phase reply matching is not supported by this Primitive API host; falling back to time-window matching.\n");
+					if (!strictFilterUnsupported) notice(params.strictOnly ? "Strict-phase reply matching is not supported by this Primitive API host; --strict-only requires server support so the command will exit without a match." : "Strict-phase reply matching is not supported by this Primitive API host; falling back to time-window matching.");
 					strictFilterUnsupported = true;
 					continue;
 				}
-				return detail;
+				return {
+					reply: detail,
+					matchStrategy: phase.label
+				};
 			}
 			if (strictFilterUnsupported && phase.label === "strict") break;
 			if (lastAccepted !== void 0) continue;
@@ -13589,6 +14345,33 @@ function redactConfig(config) {
 		environments: Object.fromEntries(Object.entries(config.environments).map(([name, environment]) => [name, redactCliEnvironment(environment)]))
 	};
 }
+function switchCliEnvironment(configDir, environmentName) {
+	const environment = normalizeCliEnvironmentName(environmentName);
+	const config = loadOrCreateConfig(configDir);
+	if (!config.environments[environment]) throw new Errors.CLIError(`Primitive CLI environment ${environment} is not configured.`, { exit: 1 });
+	const previousEnvironment = resolveConfigEnvironment(config)?.name ?? null;
+	const nextConfig = {
+		...config,
+		current_environment: environment
+	};
+	const shouldClearCredentials = previousEnvironment !== environment;
+	let removedCredentials = false;
+	if (shouldClearCredentials) {
+		const releaseLock = acquireCliCredentialsLock(configDir);
+		try {
+			saveCliConfig(configDir, nextConfig);
+			removedCredentials = existsSync(credentialsPath(configDir));
+			deleteCliCredentials(configDir);
+		} finally {
+			releaseLock();
+		}
+	} else saveCliConfig(configDir, nextConfig);
+	return {
+		environment,
+		previousEnvironment,
+		removedCredentials
+	};
+}
 var ConfigSetCommand = class ConfigSetCommand extends Command {
 	static summary = "Set a Primitive CLI request environment";
 	static flags = {
@@ -13625,20 +14408,16 @@ var ConfigSetCommand = class ConfigSetCommand extends Command {
 };
 var ConfigUseCommand = class ConfigUseCommand extends Command {
 	static summary = "Switch the active Primitive CLI request environment";
+	static description = "Switch the active Primitive CLI request environment. When this switches to a different environment, the CLI removes saved OAuth credentials so the next authenticated command signs in against the newly active API host.";
 	static args = { environment: Args.string({
 		description: "Environment name to use",
 		required: true
 	}) };
 	async run() {
 		const { args } = await this.parse(ConfigUseCommand);
-		const environment = normalizeCliEnvironmentName(args.environment);
-		const config = loadOrCreateConfig(this.config.configDir);
-		if (!config.environments[environment]) throw new Errors.CLIError(`Primitive CLI environment ${environment} is not configured.`, { exit: 1 });
-		saveCliConfig(this.config.configDir, {
-			...config,
-			current_environment: environment
-		});
+		const { environment, removedCredentials } = switchCliEnvironment(this.config.configDir, args.environment);
 		process.stderr.write(`Primitive CLI environment ${environment} is active.\n`);
+		if (removedCredentials) process.stderr.write("Removed saved Primitive CLI credentials. Run `primitive signin` to authenticate in the active environment.\n");
 	}
 };
 var ConfigListCommand = class ConfigListCommand extends Command {
@@ -14108,7 +14887,7 @@ const ADDRESS_DISPLAY_WIDTH = 32;
 const ID_DISPLAY_WIDTH_SHORT = 8;
 const ID_DISPLAY_WIDTH_FULL = 36;
 const RECEIVED_DISPLAY_WIDTH = 19;
-function truncate(value, width) {
+function truncate$1(value, width) {
 	if (value.length <= width) return value.padEnd(width);
 	return `${value.slice(0, width - 3)}...`;
 }
@@ -14123,7 +14902,7 @@ function pickIdWidth(isTty) {
 	return isTty ? ID_DISPLAY_WIDTH_SHORT : ID_DISPLAY_WIDTH_FULL;
 }
 function formatRow(email, idWidth) {
-	return `${truncate(email.id.slice(0, idWidth), idWidth)}  ${formatReceivedAt(email.received_at)}  ${truncate(email.sender ?? "", ADDRESS_DISPLAY_WIDTH)}  ${truncate(email.recipient ?? "", ADDRESS_DISPLAY_WIDTH)}  ${truncate((email.subject ?? "").replace(/\s+/g, " "), SUBJECT_DISPLAY_WIDTH)}`;
+	return `${truncate$1(email.id.slice(0, idWidth), idWidth)}  ${formatReceivedAt(email.received_at)}  ${truncate$1(email.sender ?? "", ADDRESS_DISPLAY_WIDTH)}  ${truncate$1(email.recipient ?? "", ADDRESS_DISPLAY_WIDTH)}  ${truncate$1((email.subject ?? "").replace(/\s+/g, " "), SUBJECT_DISPLAY_WIDTH)}`;
 }
 function formatHeader(idWidth) {
 	return `${"ID".padEnd(idWidth)}  ${"RECEIVED (UTC)".padEnd(RECEIVED_DISPLAY_WIDTH)}  ${"FROM".padEnd(ADDRESS_DISPLAY_WIDTH)}  ${"TO".padEnd(ADDRESS_DISPLAY_WIDTH)}  SUBJECT`;
@@ -16509,6 +17288,174 @@ var FunctionsTestFunctionCommand = class FunctionsTestFunctionCommand extends Co
 	}
 };
 //#endregion
+//#region src/oclif/commands/inbox-status.ts
+const DOMAIN_DISPLAY_WIDTH = 34;
+const STATUS_DISPLAY_WIDTH = 12;
+const BOOL_DISPLAY_WIDTH = 7;
+const NUM_DISPLAY_WIDTH = 6;
+function plural(count, singular, pluralValue = `${singular}s`) {
+	return `${count} ${count === 1 ? singular : pluralValue}`;
+}
+function statusText(status) {
+	switch (status) {
+		case "ready": return "ready";
+		case "stored_only": return "stored-only";
+		case "pending_dns": return "pending-dns";
+		case "inactive": return "inactive";
+		default: return String(status);
+	}
+}
+function yesNo(value) {
+	return value ? "yes" : "no";
+}
+function formatInboxDate(value) {
+	if (!value) return "never";
+	const d = new Date(value);
+	if (Number.isNaN(d.getTime())) return value;
+	const pad = (n) => String(n).padStart(2, "0");
+	return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())} ${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())}:${pad(d.getUTCSeconds())} UTC`;
+}
+function truncate(value, width) {
+	if (value.length <= width) return value.padEnd(width);
+	return `${value.slice(0, width - 3)}...`;
+}
+function domainSummary(domain) {
+	switch (domain.status) {
+		case "ready": return `${domain.domain} can receive mail and has ${plural(domain.processing_route_count, "processing route")}.`;
+		case "stored_only": return `${domain.domain} can receive and store mail, but has no enabled processing route.`;
+		case "pending_dns": return `${domain.domain} is waiting on DNS verification before it can receive mail.`;
+		case "inactive": return `${domain.domain} is verified but inactive.`;
+		default: return `${domain.domain} has status ${String(domain.status)}.`;
+	}
+}
+function focusInboxStatus(status, domainName) {
+	const normalized = domainName.toLowerCase();
+	const domain = status.domains.find((entry) => entry.domain.toLowerCase() === normalized);
+	if (!domain) throw new Errors.CLIError(`Domain ${domainName} was not found.`, { exit: 1 });
+	return {
+		...status,
+		domains: [domain],
+		ready: domain.receiving_ready && domain.processing_ready,
+		receiving_ready: domain.receiving_ready,
+		processing_ready: domain.processing_ready,
+		summary: domainSummary(domain),
+		recent_emails: {
+			total: domain.email_count,
+			latest_received_at: domain.latest_email_received_at
+		}
+	};
+}
+function formatDomainHeader() {
+	return [
+		"DOMAIN".padEnd(DOMAIN_DISPLAY_WIDTH),
+		"STATUS".padEnd(STATUS_DISPLAY_WIDTH),
+		"RECEIVE".padEnd(BOOL_DISPLAY_WIDTH),
+		"PROCESS".padEnd(BOOL_DISPLAY_WIDTH),
+		"EMAILS".padStart(NUM_DISPLAY_WIDTH),
+		"ROUTES".padStart(NUM_DISPLAY_WIDTH)
+	].join("  ");
+}
+function formatDomainRow(domain) {
+	return [
+		truncate(domain.domain, DOMAIN_DISPLAY_WIDTH),
+		statusText(domain.status).padEnd(STATUS_DISPLAY_WIDTH),
+		yesNo(domain.receiving_ready).padEnd(BOOL_DISPLAY_WIDTH),
+		yesNo(domain.processing_ready).padEnd(BOOL_DISPLAY_WIDTH),
+		String(domain.email_count).padStart(NUM_DISPLAY_WIDTH),
+		String(domain.processing_route_count).padStart(NUM_DISPLAY_WIDTH)
+	].join("  ");
+}
+function formatNextAction(action) {
+	return action.command ? `- ${action.message}\n  ${action.command}` : `- ${action.message}`;
+}
+function formatInboxStatus(status) {
+	const lines = [
+		status.summary,
+		"",
+		"Domains"
+	];
+	if (status.domains.length === 0) lines.push("No domains configured.");
+	else {
+		lines.push(formatDomainHeader());
+		for (const domain of status.domains) lines.push(formatDomainRow(domain));
+	}
+	lines.push("", `Endpoints: ${status.endpoints.enabled}/${status.endpoints.total} enabled (${status.endpoints.fallback_enabled} fallback, ${status.endpoints.domain_scoped_enabled} domain-scoped, ${status.endpoints.function_enabled} function)`, `Functions: ${status.functions.deployed}/${status.functions.total} deployed (${status.functions.pending} pending, ${status.functions.failed} failed)`, `Recent inbound: ${plural(status.recent_emails.total, "email")} latest ${formatInboxDate(status.recent_emails.latest_received_at)}`);
+	if (status.next_actions.length > 0) {
+		lines.push("", "Next actions");
+		for (const action of status.next_actions) lines.push(formatNextAction(action));
+	}
+	return lines.join("\n");
+}
+var InboxStatusCommand = class InboxStatusCommand extends Command {
+	static description = `Show consolidated inbound email readiness.
+
+  This checks the server-owned inbox status API instead of reconstructing readiness locally from separate domain, endpoint, function, and email lists. Use it before testing inbound email setup: it tells you whether mail can be received, whether anything will process it, and which next command is most useful.`;
+	static summary = "Show inbound email readiness";
+	static examples = [
+		"<%= config.bin %> inbox status",
+		"<%= config.bin %> inbox status --domain example.com",
+		"<%= config.bin %> inbox status --json | jq '.data.next_actions'"
+	];
+	static flags = {
+		"api-key": Flags.string({
+			description: "Primitive API key override (defaults to PRIMITIVE_API_KEY or saved OAuth login credentials)",
+			env: "PRIMITIVE_API_KEY"
+		}),
+		"api-base-url-1": Flags.string({
+			description: API_BASE_URL_1_FLAG_DESCRIPTION,
+			env: "PRIMITIVE_API_BASE_URL_1",
+			hidden: true
+		}),
+		"api-base-url-2": Flags.string({
+			description: API_BASE_URL_2_FLAG_DESCRIPTION,
+			env: "PRIMITIVE_API_BASE_URL_2",
+			hidden: true
+		}),
+		domain: Flags.string({ description: "Focus domain readiness and recent email fields on one domain returned by the inbox status API." }),
+		json: Flags.boolean({ description: "Print the raw response envelope as JSON. With --domain, domain readiness and recent email fields are focused while endpoint, function, and next-action summaries remain account-level." }),
+		time: Flags.boolean({ description: TIME_FLAG_DESCRIPTION })
+	};
+	async run() {
+		const { flags } = await this.parse(InboxStatusCommand);
+		await runWithTiming(flags.time, async () => {
+			const { apiClient, auth, baseUrlOverridden } = await createAuthenticatedCliApiClient({
+				apiKey: flags["api-key"],
+				apiBaseUrl1: flags["api-base-url-1"],
+				apiBaseUrl2: flags["api-base-url-2"],
+				configDir: this.config.configDir
+			});
+			const result = await getInboxStatus({
+				client: apiClient.client,
+				responseStyle: "fields"
+			});
+			if (result.error) {
+				const errorPayload = extractErrorPayload(result.error);
+				writeErrorWithHints(errorPayload);
+				surfaceUnauthorizedHint({
+					auth,
+					baseUrlOverridden,
+					configDir: this.config.configDir,
+					payload: errorPayload
+				});
+				process.exitCode = 1;
+				return;
+			}
+			const envelope = result.data ?? {};
+			const status = envelope.data;
+			if (!status) throw new Errors.CLIError("Primitive API returned no inbox status.", { exit: 1 });
+			const outputStatus = flags.domain ? focusInboxStatus(status, flags.domain) : status;
+			if (flags.json) {
+				this.log(JSON.stringify({
+					...envelope,
+					data: outputStatus
+				}, null, 2));
+				return;
+			}
+			this.log(formatInboxStatus(outputStatus));
+		});
+	}
+};
+//#endregion
 //#region src/oclif/commands/login.ts
 const MAX_CLI_LOGIN_POLL_INTERVAL_SECONDS = 60;
 function cliError$3(message) {
@@ -17915,25 +18862,39 @@ var SigninOtpResendCommand = class SigninOtpResendCommand extends Command {
 };
 //#endregion
 //#region src/oclif/commands/whoami.ts
+function formatWhoamiSummary(account) {
+	return [
+		`Authenticated as ${account.email}`,
+		`Account id: ${account.id}`,
+		`Plan: ${account.plan}`
+	].join("\n");
+}
 var WhoamiCommand = class WhoamiCommand extends Command {
-	static description = `Print the account currently authenticated by saved OAuth credentials or an explicit API key. Useful as a credentials smoke test: confirms auth is live and shows which account it belongs to.`;
+	static description = `Print the account currently authenticated by saved OAuth credentials or an explicit API key. Useful as a credentials smoke test: confirms auth is live and shows which account it belongs to.
+
+  The default output is a concise human summary. Pass --json only when a script intentionally needs the full /account response.`;
 	static summary = "Print the authenticated account (credentials smoke test)";
-	static examples = ["<%= config.bin %> whoami", "<%= config.bin %> whoami --api-key prim_..."];
+	static examples = [
+		"<%= config.bin %> whoami",
+		"<%= config.bin %> whoami --api-key prim_...",
+		"<%= config.bin %> whoami --json | jq .id"
+	];
 	static flags = {
 		"api-key": Flags.string({
 			description: "Primitive API key override (defaults to PRIMITIVE_API_KEY or saved OAuth login credentials)",
 			env: "PRIMITIVE_API_KEY"
 		}),
 		"api-base-url-1": Flags.string({
-			description: "Override the primary API base URL. Internal testing only; not documented to customers.",
+			description: API_BASE_URL_1_FLAG_DESCRIPTION,
 			env: "PRIMITIVE_API_BASE_URL_1",
 			hidden: true
 		}),
 		"api-base-url-2": Flags.string({
-			description: "Override the attachments-supporting send host base URL. Internal testing only; not documented to customers.",
+			description: API_BASE_URL_2_FLAG_DESCRIPTION,
 			env: "PRIMITIVE_API_BASE_URL_2",
 			hidden: true
 		}),
+		json: Flags.boolean({ description: "Print the full account JSON response. Default output hides setup and billing internals." }),
 		time: Flags.boolean({ description: TIME_FLAG_DESCRIPTION })
 	};
 	async run() {
@@ -17966,12 +18927,11 @@ var WhoamiCommand = class WhoamiCommand extends Command {
 				process.stderr.write("Server returned an empty account body; this should not happen for a valid key.\n");
 				throw new Errors.CLIError("unexpected empty response");
 			}
-			const onboarding = account.onboarding_completed === true ? "complete" : account.onboarding_step ? `in progress (step: ${account.onboarding_step})` : "incomplete";
-			process.stderr.write(`Authenticated as ${account.email}\n`);
-			process.stderr.write(`  Account id: ${account.id}\n`);
-			process.stderr.write(`  Plan:       ${account.plan}\n`);
-			process.stderr.write(`  Onboarding: ${onboarding}\n`);
-			this.log(JSON.stringify(account, null, 2));
+			if (flags.json) {
+				this.log(JSON.stringify(account, null, 2));
+				return;
+			}
+			this.log(formatWhoamiSummary(account));
 		});
 	}
 };
@@ -18225,7 +19185,11 @@ const DESCRIBE_OPERATION_ALIASES = {
 function resolveOperationAlias(id) {
 	return DESCRIBE_OPERATION_ALIASES[id] ?? id;
 }
-const OVERRIDDEN_OPERATION_IDS = new Set(["domains:download-domain-zone-file", "functions:test-function"]);
+const OVERRIDDEN_OPERATION_IDS = new Set([
+	"domains:download-domain-zone-file",
+	"functions:test-function",
+	"inbox:get-inbox-status"
+]);
 const generatedCommands = Object.fromEntries(operationManifest.filter((operation) => !OVERRIDDEN_OPERATION_IDS.has(operationId(operation))).map((operation) => [operationId(operation), createOperationCommand(operation)]));
 const COMMANDS = {
 	completion: CompletionCommand,
@@ -18257,6 +19221,8 @@ const COMMANDS = {
 	"emails:wait": EmailsWaitCommand,
 	"domains:zone-file": DomainsZoneFileCommand,
 	"domains:download-domain-zone-file": DomainsZoneFileCommand,
+	"inbox:status": InboxStatusCommand,
+	"inbox:get-inbox-status": InboxStatusCommand,
 	"functions:init": FunctionsInitCommand,
 	"functions:templates": FunctionsTemplatesCommand,
 	"functions:deploy": FunctionsDeployCommand,