@gscdump/cli 0.8.1 → 0.9.0

package/dist/index.mjs

@@ -1,17 +1,18 @@
 #!/usr/bin/env node
 import { t as __exportAll } from "./_chunks/rolldown-runtime.mjs";
-import { t as ofetch } from "./_chunks/libs/ofetch.mjs";
 import { a as loadConfig, c as setConfigDir, i as getConfigPath, n as defaultDataDir, o as resolveDataDir, r as getConfigDir, s as saveConfig } from "./_chunks/config.mjs";
-import os from "node:os";
-import path from "node:path";
+import { t as ofetch } from "./_chunks/libs/ofetch.mjs";
 import process from "node:process";
 import { defineCommand, runMain } from "citty";
 import { defaultAnalyzerRegistry } from "@gscdump/analysis/registry";
+import fs, { readFile, readdir, rm } from "node:fs/promises";
+import path, { join } from "node:path";
 import { AnalyzerCapabilityError, analyzeFromSource, createEngineQuerySource } from "@gscdump/analysis";
 import { createGscApiQuerySource } from "@gscdump/engine-gsc-api";
+import { decodeSiteId, normalizeSiteUrl } from "gscdump/tenant";
+import os from "node:os";
 import { cancel, confirm, isCancel, multiselect, select, text } from "@clack/prompts";
-import { addSite, batchInspectUrls, batchRequestIndexing, createAuth, daysAgo, deleteSite, fetchSitemap, fetchSitesWithSitemaps, formatErrorForCli, getDateRange, getIndexingMetadata, getVerificationToken, googleSearchConsole, progressBar, requestIndexing, siteUrlToVerificationSite, verificationMethodsFor, verifySite } from "gscdump";
-import fs, { readFile, rm } from "node:fs/promises";
+import { addSite, batchInspectUrls, batchRequestIndexing, createAuth, daysAgo, deleteSite, discoverSitemap, fetchSitemap, fetchSitemapUrls, fetchSitesWithSitemaps, formatErrorForCli, getDateRange, getIndexingMetadata, getVerificationToken, getVerifiedSite, googleSearchConsole, listVerifiedSites, progressBar, requestIndexing, runSequentialBatch, siteUrlToVerificationSite, unverifySite, verificationMethodsFor, verifySite } from "gscdump";
 import { createServer } from "node:http";
 import { JWT, OAuth2Client } from "google-auth-library";
 import { Buffer } from "node:buffer";
@@ -26,48 +27,11 @@ import { createEmptyTypesStore, createIndexingMetadataStore, createInspectionSto
 import { createGscMcpServer } from "@gscdump/mcp/server";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { SearchTypes, and, between, contains, country, date, device, eq, gsc, notRegex, page, query, regex, searchAppearance } from "gscdump/query";
+import { defaultReportRegistry, dryRunReport, formatReport, runReport } from "@gscdump/analysis/report";
+import { resolveWindow } from "@gscdump/engine/period";
 import { inferLegacyTier } from "@gscdump/engine";
 import { DEFAULT_ROLLUPS, rebuildRollups } from "@gscdump/analysis/rollups";
 import { filesystemStats } from "@gscdump/engine/filesystem";
-var LocalStoreUnsupportedError = class extends Error {
-	constructor(tool) {
-		super(`analysis "${tool}" is not yet implemented against the local Parquet store`);
-		this.name = "LocalStoreUnsupportedError";
-	}
-};
-var LocalStoreEmptyError = class extends Error {
-	constructor(siteUrl) {
-		super(`no local data synced for ${siteUrl} (run \`gscdump sync\` first)`);
-		this.name = "LocalStoreEmptyError";
-	}
-};
-async function hasLocalData(store, siteUrl) {
-	return (await store.engine.listLive({
-		userId: store.userId,
-		siteId: store.siteIdFor(siteUrl)
-	})).length > 0;
-}
-async function runLocalAnalysis(store, siteUrl, params) {
-	return analyzeFromSource(createEngineQuerySource({
-		engine: store.engine,
-		ctx: {
-			userId: store.userId,
-			siteId: store.siteIdFor(siteUrl)
-		}
-	}), params, defaultAnalyzerRegistry).catch((e) => {
-		if (e instanceof AnalyzerCapabilityError) throw new LocalStoreUnsupportedError(params.type);
-		throw e;
-	});
-}
-async function runLiveAnalysis(client, siteUrl, params) {
-	return analyzeFromSource(createGscApiQuerySource({
-		client,
-		siteUrl
-	}), params, defaultAnalyzerRegistry).catch((e) => {
-		if (e instanceof AnalyzerCapabilityError) throw new LocalStoreUnsupportedError(params.type);
-		throw e;
-	});
-}
 const ENV_LINE_RE$1 = /^([^=]+)=(.*)$/;
 function parseEnvFile(envPath) {
 	let content;
@@ -110,7 +74,7 @@ function loadEnvFromCwd() {
 	}
 	return applied;
 }
-const VERSION = "0.8.1";
+const VERSION = "0.9.0";
 const baseLogger = createConsola({
 	stdout: process.stderr,
 	stderr: process.stderr
@@ -119,6 +83,28 @@ const logger = baseLogger.withTag("gscdump");
 function setQuiet(quiet) {
 	if (quiet) baseLogger.level = 1;
 }
+const OUTPUT_ARGS = {
+	json: {
+		type: "boolean",
+		default: false,
+		description: "Output as JSON"
+	},
+	quiet: {
+		type: "boolean",
+		alias: "q",
+		default: false,
+		description: "Suppress info/success output"
+	}
+};
+function applyOutputMode(args) {
+	const json = Boolean(args.json);
+	const quiet = json || Boolean(args.quiet);
+	setQuiet(quiet);
+	return {
+		json,
+		quiet
+	};
+}
 let colorEnabled = (() => {
 	if (process.env.NO_COLOR) return false;
 	if (process.argv.includes("--no-color")) return false;
@@ -257,7 +243,8 @@ async function loadServiceAccount(jsonPath) {
 	});
 }
 async function resolveServiceAccount(opts = {}) {
-	const p = opts.path || process.env.GSC_SERVICE_ACCOUNT_JSON || process.env.GOOGLE_APPLICATION_CREDENTIALS;
+	let p = opts.path || process.env.GSC_SERVICE_ACCOUNT_JSON || process.env.GOOGLE_APPLICATION_CREDENTIALS;
+	if (!p) p = (await loadConfig().catch(() => null))?.serviceAccountPath;
 	if (!p) return null;
 	return loadServiceAccount(p);
 }
@@ -538,15 +525,21 @@ function redactCred(v, keepTail = 6) {
 async function describeAuthProvenance() {
 	const rows = [];
 	const warnings = [];
-	const saPath = process.env.GSC_SERVICE_ACCOUNT_JSON || process.env.GOOGLE_APPLICATION_CREDENTIALS;
-	if (saPath) {
+	const saEnvPath = process.env.GSC_SERVICE_ACCOUNT_JSON || process.env.GOOGLE_APPLICATION_CREDENTIALS;
+	const saConfigPath = !saEnvPath ? (await loadConfig().catch(() => null))?.serviceAccountPath : void 0;
+	const saPath = saEnvPath || saConfigPath;
+	if (saEnvPath) {
 		const saEnv = process.env.GSC_SERVICE_ACCOUNT_JSON ? "GSC_SERVICE_ACCOUNT_JSON" : "GOOGLE_APPLICATION_CREDENTIALS";
 		rows.push({
 			field: "service_account",
 			source: envSourceLabel(saEnv),
-			value: displayPath(saPath)
+			value: displayPath(saEnvPath)
 		});
-	}
+	} else if (saConfigPath) rows.push({
+		field: "service_account",
+		source: `${displayPath(`${getConfigDir()}/config.json`)}`,
+		value: displayPath(saConfigPath)
+	});
 	const clientId = pickEnvSource("GSC_CLIENT_ID", "GOOGLE_CLIENT_ID");
 	const clientSecret = pickEnvSource("GSC_CLIENT_SECRET", "GOOGLE_CLIENT_SECRET");
 	const config = await loadConfig().catch(() => null);
@@ -706,6 +699,92 @@ async function gscErrorHandler(error) {
 	console.error();
 	process.exit(1);
 }
+var LocalStoreUnsupportedError = class extends Error {
+	constructor(tool) {
+		super(`analysis "${tool}" is not yet implemented against the local Parquet store`);
+		this.name = "LocalStoreUnsupportedError";
+	}
+};
+async function hasLocalData(store, siteUrl) {
+	return (await store.engine.listLive({
+		userId: store.userId,
+		siteId: store.siteIdFor(siteUrl)
+	})).length > 0;
+}
+async function listLocalSites(dataDir, userId = "local") {
+	return readdir(join(dataDir, `u_${userId}`), { withFileTypes: true }).then((entries) => entries.filter((e) => e.isDirectory() && (e.name.startsWith("d_") || e.name.startsWith("h_"))).map((e) => decodeSiteId(e.name))).catch(() => []);
+}
+function pickLocalSite(siteUrls, hint) {
+	if (siteUrls.length === 0) return null;
+	if (!hint) return siteUrls.length === 1 ? siteUrls[0] : null;
+	const normalized = normalizeSiteUrl(hint);
+	const exact = siteUrls.find((s) => s === normalized || s === hint);
+	if (exact) return exact;
+	return siteUrls.find((s) => s.includes(hint) || hint.includes(s)) ?? null;
+}
+async function resolveAnalysisSource(args) {
+	const isLive = !!args.live;
+	const format = args.json ? "json" : args.format ? String(args.format) : "table";
+	if (!isLive) {
+		const config = await loadConfig();
+		const dataDir = resolveDataDir(config);
+		const store = createLocalStore({ dataDir });
+		const siteHint = args.site ? String(args.site) : config.defaultSite;
+		const localSites = await listLocalSites(dataDir, store.userId);
+		const siteUrl = pickLocalSite(localSites, siteHint);
+		if (!siteUrl) {
+			if (localSites.length === 0) logger.error(`No local data found in ${dataDir}. Run \`gscdump sync\` first, or pass --live.`);
+			else logger.error(`Could not resolve site${siteHint ? ` from "${siteHint}"` : ""}. Local sites: ${localSites.join(", ")}`);
+			process.exit(1);
+		}
+		if (!await hasLocalData(store, siteUrl).catch(() => false)) {
+			logger.error(`No local data for ${siteUrl}. Run \`gscdump sync\` first, or pass --live.`);
+			process.exit(1);
+		}
+		const source = createEngineQuerySource({
+			engine: store.engine,
+			ctx: {
+				userId: store.userId,
+				siteId: store.siteIdFor(siteUrl)
+			}
+		});
+		const runAnalysis = (params) => analyzeFromSource(source, params, defaultAnalyzerRegistry).catch((e) => {
+			if (e instanceof AnalyzerCapabilityError) {
+				logger.error(`${new LocalStoreUnsupportedError(params.type).message}. Pass --live to run against the GSC API.`);
+				process.exit(1);
+			}
+			logger.error(`Local analysis failed: ${e.message}`);
+			process.exit(1);
+		});
+		return {
+			source,
+			siteUrl,
+			format,
+			isLive,
+			runAnalysis
+		};
+	}
+	const ctx = await createCommandContext({
+		needsAuth: true,
+		needsStore: false
+	});
+	const siteUrl = await ctx.resolveSite(args.site ? String(args.site) : void 0);
+	const source = createGscApiQuerySource({
+		client: ctx.client,
+		siteUrl
+	});
+	const runAnalysis = (params) => analyzeFromSource(source, params, defaultAnalyzerRegistry).catch((e) => {
+		if (e instanceof AnalyzerCapabilityError) throw new LocalStoreUnsupportedError(params.type);
+		return gscErrorHandler(e);
+	});
+	return {
+		source,
+		siteUrl,
+		format,
+		isLive,
+		runAnalysis
+	};
+}
 const ANALYSIS_TOOLS = defaultAnalyzerRegistry.listAnalyzerIds();
 const TOOL_EXTRA_ARGS = {
 	brand: { "brand-terms": {
@@ -822,40 +901,14 @@ function makeToolCommand(tool) {
 			...extraArgs
 		},
 		async run({ args }) {
-			const ctx = await createCommandContext({
-				needsAuth: true,
-				needsStore: !args.live
+			const { format, runAnalysis } = await resolveAnalysisSource({
+				site: args.site,
+				live: !!args.live,
+				json: !!args.json,
+				format: args.format
 			});
-			const siteUrl = await ctx.resolveSite(args.site);
 			logger.info(`Running ${tool} analysis...`);
-			const params = buildParams(tool, args);
-			const format = args.json ? "json" : String(args.format);
-			if (!args.live) {
-				const store = ctx.store;
-				if (!await hasLocalData(store, siteUrl).catch(() => false)) {
-					logger.error(`No local data for ${siteUrl}. Run \`gscdump sync\` first, or pass --live.`);
-					process.exit(1);
-				}
-				const localResult = await runLocalAnalysis(store, siteUrl, params).catch((e) => {
-					if (e instanceof LocalStoreUnsupportedError) {
-						logger.error(`${e.message}. Pass --live to run against the GSC API.`);
-						process.exit(1);
-					}
-					if (e instanceof LocalStoreEmptyError) {
-						logger.error(`${e.message}`);
-						process.exit(1);
-					}
-					logger.error(`Local analysis failed: ${e.message}`);
-					process.exit(1);
-				});
-				if (format === "json") {
-					console.log(JSON.stringify(localResult, null, 2));
-					return;
-				}
-				renderResults(localResult.results, localResult.results.length, format);
-				return;
-			}
-			const result = await runLiveAnalysis(ctx.client, siteUrl, params).catch(gscErrorHandler);
+			const result = await runAnalysis(buildParams(tool, args));
 			if (format === "json") {
 				console.log(JSON.stringify(result, null, 2));
 				return;
@@ -1036,41 +1089,319 @@ const analyzeCommand = defineCommand({
 		name: "analyze",
 		description: "SEO analysis tools"
 	},
-	subCommands: Object.fromEntries(ANALYSIS_TOOLS.map((tool) => [tool, makeToolCommand(tool)]))
+	subCommands: {
+		list: defineCommand({
+			meta: {
+				name: "list",
+				description: "List available analyzer ids"
+			},
+			args: { json: {
+				type: "boolean",
+				default: false,
+				description: "Output as JSON"
+			} },
+			async run({ args }) {
+				if (args.json) {
+					console.log(JSON.stringify(ANALYSIS_TOOLS, null, 2));
+					return;
+				}
+				for (const id of ANALYSIS_TOOLS) console.log(id);
+			}
+		}),
+		...Object.fromEntries(ANALYSIS_TOOLS.map((tool) => [tool, makeToolCommand(tool)]))
+	}
+});
+const ROOT_DIR = path.join(os.homedir(), ".config", "gscdump");
+const PROFILES_DIR = path.join(ROOT_DIR, "profiles");
+const ACTIVE_MARKER = path.join(ROOT_DIR, "active-profile");
+let activeOverride = null;
+let configDirOverridden = false;
+function getProfileDir(name) {
+	return path.join(PROFILES_DIR, name);
+}
+function readActiveMarkerSync() {
+	if (!fs$1.existsSync(ACTIVE_MARKER)) return null;
+	return fs$1.readFileSync(ACTIVE_MARKER, "utf-8").trim() || null;
+}
+function resolveActiveProfile() {
+	return activeOverride ?? process.env.GSCDUMP_PROFILE ?? readActiveMarkerSync();
+}
+function applyProfileFromCli(opts) {
+	if (opts.configDir) {
+		setConfigDir(opts.configDir);
+		configDirOverridden = true;
+		return;
+	}
+	if (opts.profile) {
+		activeOverride = opts.profile;
+		setConfigDir(getProfileDir(opts.profile));
+		return;
+	}
+	const envProfile = process.env.GSCDUMP_PROFILE;
+	if (envProfile) {
+		setConfigDir(getProfileDir(envProfile));
+		return;
+	}
+	const marker = readActiveMarkerSync();
+	if (marker) setConfigDir(getProfileDir(marker));
+}
+async function setActiveProfile(name) {
+	await fs.mkdir(ROOT_DIR, {
+		recursive: true,
+		mode: 448
+	});
+	if (name == null) {
+		await fs.rm(ACTIVE_MARKER, { force: true }).catch(() => {});
+		return;
+	}
+	await fs.writeFile(ACTIVE_MARKER, name, { mode: 384 });
+}
+async function listProfiles() {
+	return fs.readdir(PROFILES_DIR).then((entries) => entries.filter((e) => !e.startsWith(".")).sort()).catch(() => []);
+}
+async function createProfile(name) {
+	const dir = getProfileDir(name);
+	await fs.mkdir(dir, {
+		recursive: true,
+		mode: 448
+	});
+	return dir;
+}
+function profileNameFromEmail(email) {
+	return email.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+async function adoptCurrentConfigAsProfile(name) {
+	if (configDirOverridden) return null;
+	if (resolveActiveProfile()) return null;
+	const currentDir = getConfigDir();
+	const targetDir = getProfileDir(name);
+	if (currentDir === targetDir) return targetDir;
+	await fs.mkdir(targetDir, {
+		recursive: true,
+		mode: 448
+	});
+	for (const f of ["tokens.json", "config.json"]) {
+		const src = path.join(currentDir, f);
+		const dst = path.join(targetDir, f);
+		if (await fs.stat(src).then(() => true).catch(() => false)) await fs.rename(src, dst).catch(() => {});
+	}
+	await setActiveProfile(name);
+	activeOverride = name;
+	setConfigDir(targetDir);
+	return targetDir;
+}
+const profileCommand = defineCommand({
+	meta: {
+		name: "profile",
+		description: "Manage gscdump profiles (per-account token + config dirs)"
+	},
+	subCommands: {
+		list: defineCommand({
+			meta: {
+				name: "list",
+				description: "List configured profiles"
+			},
+			args: { ...OUTPUT_ARGS },
+			async run({ args }) {
+				const { json } = applyOutputMode(args);
+				const names = await listProfiles();
+				const active = resolveActiveProfile();
+				if (json) {
+					console.log(JSON.stringify({
+						active,
+						profiles: names
+					}, null, 2));
+					return;
+				}
+				if (names.length === 0) {
+					logger.warn(`No profiles in ${PROFILES_DIR}`);
+					logger.info("Run `gscdump auth login` to create one automatically, or `gscdump profile create <name>`");
+					return;
+				}
+				for (const n of names) console.log(`${n === active ? "*" : " "} ${n}`);
+			}
+		}),
+		path: defineCommand({
+			meta: {
+				name: "path",
+				description: "Print the config directory for a profile"
+			},
+			args: { name: {
+				type: "positional",
+				required: false,
+				description: "Profile name (default: active)"
+			} },
+			async run({ args }) {
+				const name = args.name ? String(args.name) : resolveActiveProfile();
+				if (!name) {
+					logger.error("No profile specified and none active (set --profile, GSCDUMP_PROFILE, or run `gscdump profile use <name>`)");
+					process.exit(1);
+				}
+				console.log(getProfileDir(name));
+			}
+		}),
+		current: defineCommand({
+			meta: {
+				name: "current",
+				description: "Print the active profile name"
+			},
+			async run() {
+				const active = resolveActiveProfile();
+				if (!active) process.exit(1);
+				console.log(active);
+			}
+		}),
+		use: defineCommand({
+			meta: {
+				name: "use",
+				description: "Set the persisted active profile (subsequent commands no longer need --profile)"
+			},
+			args: {
+				...OUTPUT_ARGS,
+				name: {
+					type: "positional",
+					required: true,
+					description: "Profile name"
+				}
+			},
+			async run({ args }) {
+				applyOutputMode(args);
+				const name = String(args.name);
+				const dir = getProfileDir(name);
+				if (!await fs.stat(dir).then(() => true).catch(() => false)) {
+					logger.error(`Profile not found: ${name}`);
+					logger.info(`Create it with: gscdump profile create ${name}`);
+					process.exit(1);
+				}
+				await setActiveProfile(name);
+				logger.success(`Active profile: ${name}`);
+			}
+		}),
+		create: defineCommand({
+			meta: {
+				name: "create",
+				description: "Create an empty profile directory"
+			},
+			args: {
+				...OUTPUT_ARGS,
+				"name": {
+					type: "positional",
+					required: true,
+					description: "Profile name"
+				},
+				"no-use": {
+					type: "boolean",
+					default: false,
+					description: "Do not mark the new profile as active"
+				}
+			},
+			async run({ args }) {
+				applyOutputMode(args);
+				const name = String(args.name);
+				const dir = await createProfile(name);
+				if (!args["no-use"]) await setActiveProfile(name);
+				logger.success(`Created profile: ${name}${args["no-use"] ? "" : " (active)"}`);
+				logger.info(displayPath(dir));
+			}
+		}),
+		clear: defineCommand({
+			meta: {
+				name: "clear",
+				description: "Clear the persisted active profile (commands fall back to root config dir)"
+			},
+			args: { ...OUTPUT_ARGS },
+			async run({ args }) {
+				applyOutputMode(args);
+				await setActiveProfile(null);
+				logger.success("Cleared active profile");
+			}
+		}),
+		delete: defineCommand({
+			meta: {
+				name: "delete",
+				description: "Remove a profile directory (tokens + config)"
+			},
+			args: {
+				...OUTPUT_ARGS,
+				name: {
+					type: "positional",
+					required: true,
+					description: "Profile name"
+				},
+				yes: {
+					type: "boolean",
+					alias: "y",
+					default: false,
+					description: "Skip confirmation"
+				}
+			},
+			async run({ args }) {
+				applyOutputMode(args);
+				const name = String(args.name);
+				const dir = getProfileDir(name);
+				if (!await fs.stat(dir).then(() => true).catch(() => false)) {
+					logger.error(`Profile not found: ${name}`);
+					process.exit(1);
+				}
+				if (!args.yes) {
+					const ok = await confirm({
+						message: `Delete profile "${name}" at ${dir}? Tokens and config will be lost.`,
+						initialValue: false
+					});
+					if (isCancel(ok) || !ok) {
+						logger.info("Cancelled");
+						process.exit(0);
+					}
+				}
+				await fs.rm(dir, {
+					recursive: true,
+					force: true
+				});
+				if (readActiveMarkerSync() === name) await setActiveProfile(null);
+				logger.success(`Removed profile: ${name}`);
+			}
+		})
+	}
 });
+const REQUIRED_SCOPES$1 = [
+	"https://www.googleapis.com/auth/webmasters",
+	"https://www.googleapis.com/auth/indexing",
+	"https://www.googleapis.com/auth/siteverification"
+];
 async function fetchTokenInfo(accessToken) {
 	return ofetch("https://oauth2.googleapis.com/tokeninfo", { query: { access_token: accessToken } }).catch(() => null);
 }
+async function resolveLiveAuthState() {
+	const tokens = await loadTokens();
+	const byok = resolveBYOK();
+	let liveToken = null;
+	if (typeof byok === "string") liveToken = byok;
+	else if (byok && "getAccessToken" in byok) liveToken = await byok.getAccessToken().then((r) => r.token ?? null).catch(() => null);
+	else if (tokens?.access_token) liveToken = tokens.access_token;
+	const tokenInfo = liveToken ? await fetchTokenInfo(liveToken) : null;
+	const scopes = tokenInfo?.scope ? tokenInfo.scope.split(/\s+/).filter(Boolean) : [];
+	const has = (s) => scopes.includes(s) || scopes.includes(s.replace(".readonly", ""));
+	const missing = REQUIRED_SCOPES$1.filter((s) => !has(s));
+	return {
+		byok,
+		tokens,
+		liveToken,
+		tokenInfo,
+		scopes,
+		missing
+	};
+}
 const statusCommand$1 = defineCommand({
 	meta: {
 		name: "status",
 		description: "Show current authentication status"
 	},
-	args: {
-		json: {
-			type: "boolean",
-			default: false,
-			description: "Output as JSON"
-		},
-		quiet: {
-			type: "boolean",
-			alias: "q",
-			default: false,
-			description: "Suppress info/success output"
-		}
-	},
+	args: { ...OUTPUT_ARGS },
 	async run({ args }) {
-		setQuiet(Boolean(args.quiet) || Boolean(args.json));
-		const tokens = await loadTokens();
-		const byok = resolveBYOK();
+		const { json } = applyOutputMode(args);
+		const { byok, tokens, tokenInfo, scopes, missing } = await resolveLiveAuthState();
 		const byokKind = byok ? typeof byok === "string" ? "access-token" : "refresh-token" : null;
-		let liveToken = null;
-		if (typeof byok === "string") liveToken = byok;
-		else if (byok && "getAccessToken" in byok) liveToken = await byok.getAccessToken().then((r) => r.token ?? null).catch(() => null);
-		else if (tokens?.access_token) liveToken = tokens.access_token;
-		const tokenInfo = liveToken ? await fetchTokenInfo(liveToken) : null;
-		const scopes = tokenInfo?.scope ? tokenInfo.scope.split(/\s+/).filter(Boolean) : [];
-		if (args.json) {
+		if (json) {
 			console.log(JSON.stringify({
 				authenticated: !!tokens || !!byok,
 				source: byok ? "byok" : tokens ? "saved-tokens" : null,
@@ -1089,14 +1420,7 @@ const statusCommand$1 = defineCommand({
 		const reportScopes = () => {
 			if (scopes.length === 0) return;
 			console.log(`  Scopes:`);
-			const required = [
-				"https://www.googleapis.com/auth/webmasters",
-				"https://www.googleapis.com/auth/indexing",
-				"https://www.googleapis.com/auth/siteverification"
-			];
-			const has = (s) => scopes.includes(s) || scopes.includes(s.replace(".readonly", ""));
 			for (const s of scopes) console.log(`    \x1B[90m└─\x1B[0m ${s}`);
-			const missing = required.filter((s) => !has(s));
 			if (missing.length > 0) {
 				console.log(`  \x1B[33mMissing scopes:\x1B[0m`);
 				for (const s of missing) console.log(`    \x1B[90m└─\x1B[0m ${s}`);
@@ -1136,14 +1460,9 @@ const refreshCommand = defineCommand({
 		name: "refresh",
 		description: "Force-refresh saved OAuth tokens (no-op for BYOK)"
 	},
-	args: { quiet: {
-		type: "boolean",
-		alias: "q",
-		default: false,
-		description: "Suppress info/success output"
-	} },
+	args: { ...OUTPUT_ARGS },
 	async run({ args }) {
-		setQuiet(Boolean(args.quiet));
+		applyOutputMode(args);
 		if (resolveBYOK()) {
 			logger.info("BYOK detected; refresh handled per-call by the SDK");
 			return;
@@ -1181,6 +1500,7 @@ const authCommand = defineCommand({
 				description: "Run OAuth flow and persist tokens (skip if BYOK env vars set)"
 			},
 			args: {
+				...OUTPUT_ARGS,
 				"force": {
 					type: "boolean",
 					alias: "f",
@@ -1195,22 +1515,17 @@ const authCommand = defineCommand({
 				"service-account": {
 					type: "string",
 					description: "Path to a service-account JSON key (skips OAuth)"
-				},
-				"quiet": {
-					type: "boolean",
-					alias: "q",
-					default: false,
-					description: "Suppress info/success output"
 				}
 			},
 			async run({ args }) {
-				setQuiet(Boolean(args.quiet));
+				applyOutputMode(args);
 				if (resolveBYOK() && !args.force) {
 					logger.info("BYOK env vars detected, no login needed (--force to override)");
 					return;
 				}
 				if (args["service-account"]) {
-					const jwt = await loadServiceAccount(String(args["service-account"])).catch((e) => {
+					const saPath = path.resolve(String(args["service-account"]));
+					const jwt = await loadServiceAccount(saPath).catch((e) => {
 						logger.error(`Service-account load failed: ${e.message}`);
 						process.exit(1);
 					});
@@ -1218,8 +1533,11 @@ const authCommand = defineCommand({
 						logger.error(`Service-account auth failed: ${e.message}`);
 						process.exit(1);
 					});
+					const config = await loadConfig();
+					config.serviceAccountPath = saPath;
+					await saveConfig(config);
 					logger.success(`Service-account verified: ${jwt.email ?? "OK"}`);
-					logger.info(`Set GOOGLE_APPLICATION_CREDENTIALS=${args["service-account"]} to use it across sessions.`);
+					logger.info(`Saved path to config: ${saPath}`);
 					return;
 				}
 				if (args.force) await clearTokens();
@@ -1232,6 +1550,14 @@ const authCommand = defineCommand({
 					process.exit(1);
 				});
 				logger.success("Logged in");
+				if (!resolveActiveProfile()) {
+					const tokens = await loadTokens();
+					const info = tokens?.access_token ? await fetchTokenInfo(tokens.access_token) : null;
+					if (info?.email) {
+						const name = profileNameFromEmail(info.email);
+						if (await adoptCurrentConfigAsProfile(name).catch(() => null)) logger.success(`Saved as profile "${name}" (active)`);
+					}
+				}
 				if (resolveBYOK()) {
 					console.log();
 					console.log(await formatAuthProvenance());
@@ -1243,18 +1569,44 @@ const authCommand = defineCommand({
 				name: "logout",
 				description: "Clear stored OAuth tokens"
 			},
-			args: { quiet: {
-				type: "boolean",
-				alias: "q",
-				default: false,
-				description: "Suppress info/success output"
-			} },
+			args: { ...OUTPUT_ARGS },
 			async run({ args }) {
-				setQuiet(Boolean(args.quiet));
+				applyOutputMode(args);
 				await clearTokens();
+				const config = await loadConfig();
+				if (config.serviceAccountPath) {
+					delete config.serviceAccountPath;
+					await saveConfig(config);
+					logger.info("Cleared saved service-account path");
+				}
 			}
 		}),
-		refresh: refreshCommand
+		refresh: refreshCommand,
+		scopes: defineCommand({
+			meta: {
+				name: "scopes",
+				description: "Print granted OAuth scopes (one per line); exits 1 if any required scope is missing"
+			},
+			args: { ...OUTPUT_ARGS },
+			async run({ args }) {
+				const { json } = applyOutputMode(args);
+				const { liveToken, scopes, missing } = await resolveLiveAuthState();
+				if (!liveToken) {
+					if (json) console.log(JSON.stringify({
+						scopes: [],
+						missing: null
+					}, null, 2));
+					else logger.error("Not authenticated");
+					process.exit(1);
+				}
+				if (json) console.log(JSON.stringify({
+					scopes,
+					missing
+				}, null, 2));
+				else for (const s of scopes) console.log(s);
+				if (missing.length > 0) process.exit(1);
+			}
+		})
 	}
 });
 const showCommand = defineCommand({
@@ -1262,24 +1614,12 @@ const showCommand = defineCommand({
 		name: "show",
 		description: "Show current config"
 	},
-	args: {
-		json: {
-			type: "boolean",
-			default: false,
-			description: "Output config as a single JSON object (suppresses path header)"
-		},
-		quiet: {
-			type: "boolean",
-			alias: "q",
-			default: false,
-			description: "Suppress info/success output"
-		}
-	},
+	args: { ...OUTPUT_ARGS },
 	async run({ args }) {
-		setQuiet(Boolean(args.quiet) || Boolean(args.json));
+		const { json } = applyOutputMode(args);
 		const config = await loadConfig();
 		const configPath = getConfigPath();
-		if (args.json) {
+		if (json) {
 			console.log(JSON.stringify({
 				path: configPath,
 				config
@@ -1303,7 +1643,8 @@ const VALID_KEYS = [
 	"dataDir",
 	"defaultLimit",
 	"defaultSearchType",
-	"defaultDataState"
+	"defaultDataState",
+	"serviceAccountPath"
 ];
 const NUMERIC_KEYS = new Set(["defaultLimit"]);
 const configCommand = defineCommand({
@@ -1329,15 +1670,10 @@ const configCommand = defineCommand({
 					description: "Value to set",
 					required: true
 				},
-				quiet: {
-					type: "boolean",
-					alias: "q",
-					default: false,
-					description: "Suppress info/success output"
-				}
+				...OUTPUT_ARGS
 			},
 			async run({ args }) {
-				setQuiet(Boolean(args.quiet));
+				applyOutputMode(args);
 				if (!VALID_KEYS.includes(args.key)) {
 					logger.error(`Invalid key: ${args.key}`);
 					logger.info(`Valid keys: ${VALID_KEYS.join(", ")}`);
@@ -1365,15 +1701,10 @@ const configCommand = defineCommand({
 					description: `Config key to remove (${VALID_KEYS.join(", ")})`,
 					required: true
 				},
-				quiet: {
-					type: "boolean",
-					alias: "q",
-					default: false,
-					description: "Suppress info/success output"
-				}
+				...OUTPUT_ARGS
 			},
 			async run({ args }) {
-				setQuiet(Boolean(args.quiet));
+				applyOutputMode(args);
 				if (!VALID_KEYS.includes(args.key)) {
 					logger.error(`Invalid key: ${args.key}`);
 					logger.info(`Valid keys: ${VALID_KEYS.join(", ")}`);
@@ -1399,21 +1730,9 @@ const configCommand = defineCommand({
 				name: "validate",
 				description: "Validate the saved config (defaultSite is verified, dataDir exists/writable)"
 			},
-			args: {
-				json: {
-					type: "boolean",
-					default: false,
-					description: "Output as JSON"
-				},
-				quiet: {
-					type: "boolean",
-					alias: "q",
-					default: false,
-					description: "Suppress info/success output"
-				}
-			},
+			args: { ...OUTPUT_ARGS },
 			async run({ args }) {
-				setQuiet(Boolean(args.quiet) || Boolean(args.json));
+				const { json } = applyOutputMode(args);
 				const { resolveDataDir } = await import("./_chunks/config.mjs").then((n) => n.t);
 				const fs = await import("node:fs/promises");
 				const config = await loadConfig();
@@ -1459,7 +1778,31 @@ const configCommand = defineCommand({
 					level: "fail",
 					message: `unknown format: ${config.defaultFormat}`
 				});
-				if (args.json) {
+				const { SearchTypes } = await import("gscdump/query");
+				const allowedSearchTypes = Object.values(SearchTypes);
+				if (config.defaultSearchType && !allowedSearchTypes.includes(config.defaultSearchType)) issues.push({
+					key: "defaultSearchType",
+					level: "fail",
+					message: `unknown search type: ${config.defaultSearchType} (allowed: ${allowedSearchTypes.join(", ")})`
+				});
+				const allowedDataStates = [
+					"all",
+					"final",
+					"hourly_all"
+				];
+				if (config.defaultDataState && !allowedDataStates.includes(config.defaultDataState)) issues.push({
+					key: "defaultDataState",
+					level: "fail",
+					message: `unknown data state: ${config.defaultDataState} (allowed: ${allowedDataStates.join(", ")})`
+				});
+				if (config.serviceAccountPath) {
+					if (!await fs.stat(config.serviceAccountPath).catch(() => null)) issues.push({
+						key: "serviceAccountPath",
+						level: "fail",
+						message: `${displayPath(config.serviceAccountPath)} does not exist`
+					});
+				}
+				if (json) {
 					console.log(JSON.stringify({
 						ok: !issues.some((i) => i.level === "fail"),
 						issues
@@ -1798,12 +2141,9 @@ const doctorCommand = defineCommand({
 		name: "doctor",
 		description: "Run health checks (env, auth, scopes, time, dataDir, store, GSC reachability + ping, defaultSite)"
 	},
-	args: { json: {
-		type: "boolean",
-		default: false,
-		description: "Output as JSON"
-	} },
+	args: { ...OUTPUT_ARGS },
 	async run({ args }) {
+		const { json } = applyOutputMode(args);
 		const envResult = await checkEnv();
 		const [authResult, timeChecks, dataDirChecks, watermarkChecks, gscApi, indexingApi, siteVerificationApi] = await Promise.all([
 			checkAuth$1(envResult.envKeys),
@@ -1830,7 +2170,7 @@ const doctorCommand = defineCommand({
 			...siteVerificationApi,
 			...sitesChecks
 		];
-		if (args.json) {
+		if (json) {
 			console.log(JSON.stringify({
 				checks: all,
 				ok: all.every((c) => c.status !== "fail")
@@ -1904,20 +2244,10 @@ const dumpCommand = defineCommand({
 			default: false,
 			description: "Compact every closed month into a single file before exporting"
 		},
-		"json": {
-			type: "boolean",
-			default: false,
-			description: "Emit a JSON summary of what was exported"
-		},
-		"quiet": {
-			type: "boolean",
-			alias: "q",
-			default: false,
-			description: "Suppress progress output"
-		}
+		...OUTPUT_ARGS
 	},
 	async run({ args }) {
-		setQuiet(Boolean(args.quiet) || Boolean(args.json));
+		const { json, quiet } = applyOutputMode(args);
 		const format = String(args.format);
 		if (!FORMATS.includes(format)) {
 			logger.error(`Invalid --format: ${format}. Allowed: ${FORMATS.join(", ")}`);
@@ -1935,12 +2265,12 @@ const dumpCommand = defineCommand({
 			logger.warn("No sites with local data. Run `gscdump sync` first.");
 			process.exit(0);
 		}
-		if (args.compact) for (const siteUrl of targets) await compactClosedMonths(store, siteUrl, args.quiet);
+		if (args.compact) for (const siteUrl of targets) await compactClosedMonths(store, siteUrl, quiet);
 		const summary = [];
 		for (const siteUrl of targets) {
 			const entries = (await listLiveEntries(store, siteUrl)).filter((e) => !tablesFilter || tablesFilter.has(e.table));
 			if (entries.length === 0) {
-				if (!args.json && !args.quiet) logger.warn(`No data for ${siteUrl}; skipping`);
+				if (!quiet) logger.warn(`No data for ${siteUrl}; skipping`);
 				continue;
 			}
 			if (format === "parquet") {
@@ -1963,7 +2293,7 @@ const dumpCommand = defineCommand({
 				});
 			}
 		}
-		if (args.json) {
+		if (json) {
 			console.log(JSON.stringify({
 				outDir,
 				sites: summary
@@ -2092,20 +2422,10 @@ const inspectSubCommand = defineCommand({
 			default: "4",
 			description: "Concurrent in-flight inspect calls (default: 4)"
 		},
-		json: {
-			type: "boolean",
-			default: false,
-			description: "Emit a JSON summary of inspection results"
-		},
-		quiet: {
-			type: "boolean",
-			alias: "q",
-			default: false,
-			description: "Suppress progress output"
-		}
+		...OUTPUT_ARGS
 	},
 	async run({ args }) {
-		setQuiet(Boolean(args.quiet) || Boolean(args.json));
+		const { json, quiet } = applyOutputMode(args);
 		const ctx = await createCommandContext({
 			needsAuth: true,
 			needsStore: true
@@ -2115,7 +2435,6 @@ const inspectSubCommand = defineCommand({
 		const siteUrl = await ctx.resolveSite(args.site ? String(args.site) : void 0);
 		const limit = args.limit ? Number.parseInt(String(args.limit), 10) : INSPECTION_QPD_PER_PROPERTY;
 		const concurrency = Math.max(1, Number.parseInt(String(args.concurrency), 10) || 4);
-		const quiet = Boolean(args.quiet) || Boolean(args.json);
 		const urls = (await readUrlList({ file: args.file ? String(args.file) : void 0 })).slice(0, limit);
 		if (urls.length === 0) {
 			logger.warn("No URLs to inspect.");
@@ -2163,7 +2482,7 @@ const inspectSubCommand = defineCommand({
 			userId: store.userId,
 			siteId: store.siteIdFor(siteUrl)
 		}, records);
-		if (args.json) console.log(JSON.stringify({
+		if (json) console.log(JSON.stringify({
 			site: siteUrl,
 			inspected: records.length,
 			failed,
@@ -2187,6 +2506,7 @@ const showSubCommand = defineCommand({
 		description: "Print the latest inspection record for a URL from the local entity store"
 	},
 	args: {
+		...OUTPUT_ARGS,
 		site: {
 			type: "string",
 			alias: "s",
@@ -2196,14 +2516,10 @@ const showSubCommand = defineCommand({
 			type: "positional",
 			required: true,
 			description: "URL to look up"
-		},
-		json: {
-			type: "boolean",
-			default: false,
-			description: "Output as JSON"
 		}
 	},
 	async run({ args }) {
+		const { json } = applyOutputMode(args);
 		const ctx = await createCommandContext({
 			needsAuth: true,
 			needsStore: true
@@ -2218,7 +2534,7 @@ const showSubCommand = defineCommand({
 			logger.warn(`No inspection record for ${args.url}`);
 			process.exit(1);
 		}
-		if (args.json) {
+		if (json) {
 			console.log(JSON.stringify(record, null, 2));
 			return;
 		}
@@ -2240,24 +2556,15 @@ const sitemapsSnapshotSubCommand = defineCommand({
 		description: "Fetch current sitemap state from GSC and persist to the local entity store"
 	},
 	args: {
+		...OUTPUT_ARGS,
 		site: {
 			type: "string",
 			alias: "s",
 			description: "Site URL (e.g., sc-domain:example.com); defaults to config.defaultSite or prompt"
-		},
-		quiet: {
-			type: "boolean",
-			alias: "q",
-			default: false,
-			description: "Suppress progress output"
-		},
-		json: {
-			type: "boolean",
-			default: false,
-			description: "Emit the snapshot JSON to stdout"
 		}
 	},
 	async run({ args }) {
+		const { json, quiet } = applyOutputMode(args);
 		const ctx = await createCommandContext({
 			needsAuth: true,
 			needsStore: true
@@ -2265,7 +2572,6 @@ const sitemapsSnapshotSubCommand = defineCommand({
 		const client = ctx.client;
 		const store = ctx.store;
 		const siteUrl = await ctx.resolveSite(args.site ? String(args.site) : void 0);
-		const quiet = Boolean(args.quiet);
 		const apiSitemaps = await client.sitemaps.list(siteUrl);
 		const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
 		const records = apiSitemaps.filter((s) => typeof s.path === "string").map((s) => ({
@@ -2289,7 +2595,7 @@ const sitemapsSnapshotSubCommand = defineCommand({
 			userId: store.userId,
 			siteId: store.siteIdFor(siteUrl)
 		}, records);
-		if (args.json) {
+		if (json) {
 			console.log(JSON.stringify({
 				site: siteUrl,
 				capturedAt,
@@ -2314,6 +2620,7 @@ const sitemapsShowSubCommand = defineCommand({
 		description: "Print the latest captured sitemap state for a feedpath"
 	},
 	args: {
+		...OUTPUT_ARGS,
 		site: {
 			type: "string",
 			alias: "s",
@@ -2323,14 +2630,10 @@ const sitemapsShowSubCommand = defineCommand({
 			type: "positional",
 			required: true,
 			description: "Sitemap path (feedpath)"
-		},
-		json: {
-			type: "boolean",
-			default: false,
-			description: "Output as JSON"
 		}
 	},
 	async run({ args }) {
+		const { json } = applyOutputMode(args);
 		const ctx = await createCommandContext({
 			needsAuth: true,
 			needsStore: true
@@ -2345,7 +2648,7 @@ const sitemapsShowSubCommand = defineCommand({
 			logger.warn(`No sitemap record for ${args.path}`);
 			process.exit(1);
 		}
-		if (args.json) {
+		if (json) {
 			console.log(JSON.stringify(record, null, 2));
 			return;
 		}
@@ -2398,14 +2701,10 @@ const indexingSubCommand = defineCommand({
 				default: "4",
 				description: "Concurrent in-flight getMetadata calls (default: 4)"
 			},
-			quiet: {
-				type: "boolean",
-				alias: "q",
-				default: false,
-				description: "Suppress progress output"
-			}
+			...OUTPUT_ARGS
 		},
 		async run({ args }) {
+			const { quiet } = applyOutputMode(args);
 			const ctx = await createCommandContext({
 				needsAuth: true,
 				needsStore: true
@@ -2414,7 +2713,6 @@ const indexingSubCommand = defineCommand({
 			const store = ctx.store;
 			const siteUrl = await ctx.resolveSite(args.site ? String(args.site) : void 0);
 			const concurrency = Math.max(1, Number.parseInt(String(args.concurrency), 10) || 4);
-			const quiet = Boolean(args.quiet);
 			const urls = await readUrlList({ file: args.file ? String(args.file) : void 0 });
 			if (urls.length === 0) {
 				logger.warn("No URLs to fetch metadata for.");
@@ -2490,6 +2788,14 @@ function parseRetries(v) {
 	const n = Number.parseInt(String(v), 10);
 	return Number.isFinite(n) && n >= 0 ? n : void 0;
 }
+async function resolveUrlSource(args) {
+	const fromSitemap = args["from-sitemap"];
+	if (fromSitemap) return fetchSitemapUrls(String(fromSitemap)).catch((e) => {
+		logger.error(`Sitemap fetch failed: ${e.message}`);
+		process.exit(1);
+	});
+	return readUrlList$1(args);
+}
 const submitCommand$1 = defineCommand({
 	meta: {
 		name: "submit",
@@ -2501,21 +2807,11 @@ const submitCommand$1 = defineCommand({
 			required: true,
 			description: "URL to submit"
 		},
-		json: {
-			type: "boolean",
-			default: false,
-			description: "Output as JSON"
-		},
-		quiet: {
-			type: "boolean",
-			alias: "q",
-			default: false,
-			description: "Suppress info/success output"
-		},
+		...OUTPUT_ARGS,
 		...RETRIES_ARG
 	},
 	async run({ args }) {
-		setQuiet(Boolean(args.quiet) || Boolean(args.json));
+		applyOutputMode(args);
 		const result = await requestIndexing((await createCommandContext({
 			needsAuth: true,
 			fetchOptions: { retry: parseRetries(args.retries) }
@@ -2539,21 +2835,11 @@ const removeCommand = defineCommand({
 			required: true,
 			description: "URL to mark removed"
 		},
-		json: {
-			type: "boolean",
-			default: false,
-			description: "Output as JSON"
-		},
-		quiet: {
-			type: "boolean",
-			alias: "q",
-			default: false,
-			description: "Suppress info/success output"
-		},
+		...OUTPUT_ARGS,
 		...RETRIES_ARG
 	},
 	async run({ args }) {
-		setQuiet(Boolean(args.quiet) || Boolean(args.json));
+		applyOutputMode(args);
 		const result = await requestIndexing((await createCommandContext({
 			needsAuth: true,
 			fetchOptions: { retry: parseRetries(args.retries) }
@@ -2590,7 +2876,7 @@ const statusCommand = defineCommand({
 		}
 	},
 	async run({ args }) {
-		setQuiet(Boolean(args.quiet) || Boolean(args.json));
+		applyOutputMode(args);
 		const meta = await getIndexingMetadata((await createCommandContext({ needsAuth: true })).client, args.url).catch(gscErrorHandler);
 		if (args.json) {
 			console.log(JSON.stringify(meta, null, 2));
@@ -2610,31 +2896,65 @@ const statusCommand = defineCommand({
 	}
 });
 const INDEXING_DAILY_QUOTA = 200;
+const INDEXING_PER_MINUTE_QUOTA = 600;
+const quotaCommand = defineCommand({
+	meta: {
+		name: "quota",
+		description: "Show documented Indexing API quotas (no live counters; quota usage is not exposed by the API)"
+	},
+	args: { ...OUTPUT_ARGS },
+	async run({ args }) {
+		const { json } = applyOutputMode(args);
+		const payload = {
+			perDay: INDEXING_DAILY_QUOTA,
+			perMinute: INDEXING_PER_MINUTE_QUOTA,
+			note: "Documented defaults. Google does not expose live counters; track yours by counting submit calls.",
+			docs: "https://developers.google.com/search/apis/indexing-api/v3/quota-pricing"
+		};
+		if (json) {
+			console.log(JSON.stringify(payload, null, 2));
+			return;
+		}
+		console.log();
+		console.log(`  \x1B[1mIndexing API quota\x1B[0m`);
+		console.log(`    Per day:    ${payload.perDay}`);
+		console.log(`    Per minute: ${payload.perMinute}`);
+		console.log();
+		console.log(`  \x1B[90m${payload.note}\x1B[0m`);
+		console.log(`  \x1B[90mDocs: ${payload.docs}\x1B[0m`);
+		console.log();
+	}
+});
 const indexingCommand = defineCommand({
 	meta: {
 		name: "indexing",
 		description: "Notify Google about URL updates/removals (Indexing API)"
 	},
 	subCommands: {
-		submit: submitCommand$1,
-		remove: removeCommand,
-		status: statusCommand,
-		batch: defineCommand({
+		"submit": submitCommand$1,
+		"remove": removeCommand,
+		"status": statusCommand,
+		"batch": defineCommand({
 			meta: {
 				name: "batch",
 				description: "Submit many URLs from a file or stdin (one URL per line)"
 			},
 			args: {
+				...OUTPUT_ARGS,
 				"urls": {
 					type: "positional",
 					required: false,
-					description: "URLs (or use --file/stdin)"
+					description: "URLs (or use --file/--from-sitemap/stdin)"
 				},
 				"file": {
 					type: "string",
 					alias: "f",
 					description: "File with URLs (one per line)"
 				},
+				"from-sitemap": {
+					type: "string",
+					description: "Sitemap URL (or sitemap index) to pull URLs from"
+				},
 				"type": {
 					type: "string",
 					default: "URL_UPDATED",
@@ -2651,17 +2971,6 @@ const indexingCommand = defineCommand({
 					default: "1",
 					description: "Concurrent in-flight requests"
 				},
-				"quiet": {
-					type: "boolean",
-					alias: "q",
-					default: false,
-					description: "Suppress progress output"
-				},
-				"json": {
-					type: "boolean",
-					default: false,
-					description: "Output as JSON"
-				},
 				"yes": {
 					type: "boolean",
 					alias: "y",
@@ -2674,10 +2983,10 @@ const indexingCommand = defineCommand({
 				}
 			},
 			async run({ args }) {
-				setQuiet(Boolean(args.quiet) || Boolean(args.json));
-				const urls = await readUrlList$1(args);
+				applyOutputMode(args);
+				const urls = await resolveUrlSource(args);
 				if (urls.length === 0) {
-					logger.error("No URLs provided. Pass URLs as args, --file, or stdin.");
+					logger.error("No URLs provided. Pass URLs as args, --file, --from-sitemap, or stdin.");
 					process.exit(1);
 				}
 				const type = String(args.type);
@@ -2710,7 +3019,71 @@ const indexingCommand = defineCommand({
 				}
 				if (!args.quiet) logger.success(`Submitted ${results.length}/${urls.length} URLs`);
 			}
-		})
+		}),
+		"batch-status": defineCommand({
+			meta: {
+				name: "batch-status",
+				description: "Get indexing notification metadata for many URLs"
+			},
+			args: {
+				...OUTPUT_ARGS,
+				"urls": {
+					type: "positional",
+					required: false,
+					description: "URLs (or use --file/--from-sitemap/stdin)"
+				},
+				"file": {
+					type: "string",
+					alias: "f",
+					description: "File with URLs (one per line)"
+				},
+				"from-sitemap": {
+					type: "string",
+					description: "Sitemap URL (or sitemap index) to pull URLs from"
+				},
+				"delay-ms": {
+					type: "string",
+					default: "100",
+					description: "Delay between requests"
+				},
+				"concurrency": {
+					type: "string",
+					alias: "c",
+					default: "1",
+					description: "Concurrent in-flight requests"
+				},
+				"retries": {
+					type: "string",
+					description: "Override per-call retry count (default: 3)"
+				}
+			},
+			async run({ args }) {
+				applyOutputMode(args);
+				const urls = await resolveUrlSource(args);
+				if (urls.length === 0) {
+					logger.error("No URLs provided. Pass URLs as args, --file, --from-sitemap, or stdin.");
+					process.exit(1);
+				}
+				const ctx = await createCommandContext({
+					needsAuth: true,
+					fetchOptions: { retry: parseRetries(args.retries) }
+				});
+				const delayMs = Number.parseInt(String(args["delay-ms"]), 10);
+				const concurrency = Math.max(1, Number.parseInt(String(args.concurrency), 10) || 1);
+				if (!args.json && !args.quiet) logger.info(`Fetching status for ${urls.length} URLs ...`);
+				const results = await runSequentialBatch(urls, (url) => getIndexingMetadata(ctx.client, url), {
+					delayMs,
+					concurrency,
+					onProgress: args.json || args.quiet ? void 0 : (r, i, total) => logger.info(`[${i + 1}/${total}] ${r.url}`)
+				}).catch(gscErrorHandler);
+				if (args.json) {
+					console.log(JSON.stringify(results, null, 2));
+					return;
+				}
+				if (!args.quiet) logger.success(`Fetched ${results.length}/${urls.length} URLs`);
+			}
+		}),
+		"quota": quotaCommand
 	}
 });
 const ENV_LINE_RE = /^([^=]+)=(.*)$/;
@@ -2758,15 +3131,10 @@ const initCommand = defineCommand({
 			default: false,
 			description: "Skip dataDir prompt (auth-only setup)"
 		},
-		"quiet": {
-			type: "boolean",
-			alias: "q",
-			default: false,
-			description: "Suppress info/success output"
-		}
+		...OUTPUT_ARGS
 	},
 	async run({ args }) {
-		setQuiet(Boolean(args.quiet));
+		applyOutputMode(args);
 		const config = await loadConfig();
 		if (config.clientId && config.clientSecret && !args.force) {
 			logger.info("Already configured");
@@ -2946,111 +3314,111 @@ function printInspection(url, inspection) {
 	}
 	console.log();
 }
-const inspectCommand = defineCommand({
+const batchCommand = defineCommand({
 	meta: {
-		name: "inspect",
-		description: "Inspect URL indexing status (single URL; use `inspect batch` for many)"
+		name: "batch",
+		description: "Inspect many URLs from a file or stdin (one URL per line)"
 	},
 	args: {
-		site: {
+		...OUTPUT_ARGS,
+		"site": {
 			type: "string",
 			alias: "s",
 			description: "Site URL (defaults to config.defaultSite or prompt)"
 		},
-		url: {
+		"urls": {
 			type: "positional",
-			required: true,
-			description: "URL to inspect"
+			required: false,
+			description: "URLs (or use --file/--from-sitemap/stdin)"
 		},
-		json: {
-			type: "boolean",
-			default: false,
-			description: "Output as JSON"
+		"file": {
+			type: "string",
+			alias: "f",
+			description: "File with URLs (one per line)"
 		},
-		quiet: {
-			type: "boolean",
-			alias: "q",
-			default: false,
-			description: "Suppress info/success output"
+		"from-sitemap": {
+			type: "string",
+			description: "Sitemap URL (or sitemap index) to pull URLs from"
+		},
+		"delay-ms": {
+			type: "string",
+			default: "200",
+			description: "Delay between requests"
+		},
+		"concurrency": {
+			type: "string",
+			alias: "c",
+			default: "1",
+			description: "Concurrent in-flight requests"
 		}
 	},
-	subCommands: { batch: defineCommand({
-		meta: {
-			name: "batch",
-			description: "Inspect many URLs from a file or stdin (one URL per line)"
-		},
-		args: {
-			"site": {
-				type: "string",
-				alias: "s",
-				description: "Site URL (defaults to config.defaultSite or prompt)"
-			},
-			"urls": {
-				type: "positional",
-				required: false,
-				description: "URLs (or use --file/stdin)"
-			},
-			"file": {
-				type: "string",
-				alias: "f",
-				description: "File with URLs (one per line)"
-			},
-			"delay-ms": {
-				type: "string",
-				default: "200",
-				description: "Delay between requests"
-			},
-			"concurrency": {
-				type: "string",
-				alias: "c",
-				default: "1",
-				description: "Concurrent in-flight requests"
-			},
-			"quiet": {
-				type: "boolean",
-				alias: "q",
-				default: false,
-				description: "Suppress progress output"
-			},
-			"json": {
-				type: "boolean",
-				default: false,
-				description: "Output as JSON"
-			}
+	async run({ args }) {
+		const { json, quiet } = applyOutputMode(args);
+		const urls = args["from-sitemap"] ? await fetchSitemapUrls(String(args["from-sitemap"])).catch((e) => {
+			logger.error(`Sitemap fetch failed: ${e.message}`);
+			process.exit(1);
+		}) : await readUrlList$1(args);
+		if (urls.length === 0) {
+			logger.error("No URLs provided. Pass URLs as args, --file, --from-sitemap, or stdin.");
+			process.exit(1);
+		}
+		const ctx = await createCommandContext({ needsAuth: true });
+		const siteUrl = await ctx.resolveSite(args.site ? String(args.site) : void 0);
+		const delayMs = Number.parseInt(String(args["delay-ms"]), 10);
+		const concurrency = Math.max(1, Number.parseInt(String(args.concurrency), 10) || 1);
+		if (!quiet) logger.info(`Inspecting ${urls.length} URLs ...`);
+		const results = await batchInspectUrls(ctx.client, siteUrl, urls, {
+			delayMs,
+			concurrency,
+			onProgress: quiet ? void 0 : (r, i, total) => logger.info(`[${i + 1}/${total}] ${r.url} ${r.isIndexed ? "PASS" : "FAIL"}`)
+		}).catch(gscErrorHandler);
+		if (json) {
+			const flattened = results.map((r) => {
+				const indexStatus = r.inspection?.indexStatusResult;
+				return {
+					url: r.url,
+					verdict: indexStatus?.verdict || null,
+					coverageState: indexStatus?.coverageState || null,
+					indexingState: indexStatus?.indexingState || null,
+					lastCrawlTime: indexStatus?.lastCrawlTime || null,
+					isIndexed: r.isIndexed,
+					raw: r.inspection
+				};
+			});
+			console.log(JSON.stringify(flattened, null, 2));
+			return;
+		}
+		const indexed = results.filter((r) => r.isIndexed).length;
+		if (!quiet) logger.success(`Inspected ${results.length} URLs (${indexed} indexed, ${results.length - indexed} not)`);
+	}
+});
+const inspectCommand = defineCommand({
+	meta: {
+		name: "inspect",
+		description: "Inspect URL indexing status (single URL; use `inspect batch` for many)"
+	},
+	args: {
+		...OUTPUT_ARGS,
+		site: {
+			type: "string",
+			alias: "s",
+			description: "Site URL (defaults to config.defaultSite or prompt)"
 		},
-		async run({ args }) {
-			setQuiet(Boolean(args.quiet) || Boolean(args.json));
-			const urls = await readUrlList$1(args);
-			if (urls.length === 0) {
-				logger.error("No URLs provided. Pass URLs as args, --file, or stdin.");
-				process.exit(1);
-			}
-			const ctx = await createCommandContext({ needsAuth: true });
-			const siteUrl = await ctx.resolveSite(args.site ? String(args.site) : void 0);
-			const delayMs = Number.parseInt(String(args["delay-ms"]), 10);
-			const concurrency = Math.max(1, Number.parseInt(String(args.concurrency), 10) || 1);
-			if (!args.json && !args.quiet) logger.info(`Inspecting ${urls.length} URLs ...`);
-			const results = await batchInspectUrls(ctx.client, siteUrl, urls, {
-				delayMs,
-				concurrency,
-				onProgress: args.json || args.quiet ? void 0 : (r, i, total) => logger.info(`[${i + 1}/${total}] ${r.url} ${r.isIndexed ? "PASS" : "FAIL"}`)
-			}).catch(gscErrorHandler);
-			if (args.json) {
-				console.log(JSON.stringify(results, null, 2));
-				return;
-			}
-			const indexed = results.filter((r) => r.isIndexed).length;
-			if (!args.quiet) logger.success(`Inspected ${results.length} URLs (${indexed} indexed, ${results.length - indexed} not)`);
+		url: {
+			type: "positional",
+			required: true,
+			description: "URL to inspect"
 		}
-	}) },
+	},
+	subCommands: { batch: batchCommand },
 	async run({ args }) {
-		setQuiet(Boolean(args.quiet) || Boolean(args.json));
+		const { json } = applyOutputMode(args);
 		const ctx = await createCommandContext({ needsAuth: true });
 		const siteUrl = await ctx.resolveSite(args.site ? String(args.site) : void 0);
 		const result = await ctx.client.inspect(siteUrl, args.url).catch(gscErrorHandler);
 		const inspection = result?.inspectionResult;
 		const indexStatus = inspection?.indexStatusResult;
-		if (args.json) {
+		if (json) {
 			console.log(JSON.stringify({
 				url: args.url,
 				verdict: indexStatus?.verdict || null,
@@ -3622,6 +3990,222 @@ async function writeOutput(opts) {
 function isKnownTable$1(name) {
 	return allTables().includes(name);
 }
+const REPORT_IDS = defaultReportRegistry.listReportIds();
+const PERIOD_ALIASES = {
+	"7d": "last-7d",
+	"28d": "last-28d",
+	"30d": "last-30d",
+	"90d": "last-90d",
+	"180d": "last-180d",
+	"365d": "last-365d",
+	"last-7d": "last-7d",
+	"last-28d": "last-28d",
+	"last-30d": "last-30d",
+	"last-90d": "last-90d",
+	"last-180d": "last-180d",
+	"last-365d": "last-365d",
+	"mtd": "mtd",
+	"ytd": "ytd",
+	"custom": "custom"
+};
+const COMPARISON_ALIASES = {
+	"none": "none",
+	"prev": "prev-period",
+	"prev-period": "prev-period",
+	"prior": "prev-period",
+	"prior-period": "prev-period",
+	"yoy": "yoy"
+};
+function resolvePeriod(input, fallback) {
+	if (!input) return fallback;
+	const preset = PERIOD_ALIASES[input.toLowerCase()];
+	if (!preset) throw new Error(`Unknown --period "${input}". Supported: 7d, 28d, 30d, 90d, 180d, 365d, mtd, ytd, custom.`);
+	return preset;
+}
+function resolveComparison(input, fallback) {
+	if (!input) return fallback;
+	const mode = COMPARISON_ALIASES[input.toLowerCase()];
+	if (!mode) throw new Error(`Unknown --vs "${input}". Supported: none, prev-period, yoy.`);
+	return mode;
+}
+function reportArgsToCitty(spec) {
+	const out = {};
+	for (const [key, def] of Object.entries(spec)) out[key] = {
+		type: def.type === "boolean" ? "boolean" : "string",
+		description: def.description,
+		default: def.default == null ? void 0 : String(def.default),
+		alias: def.alias,
+		required: def.required
+	};
+	return out;
+}
+function buildReportParams(report, args) {
+	const params = {};
+	for (const [key, def] of Object.entries(report.argsSpec)) {
+		const raw = args[key];
+		if (raw == null || raw === "") continue;
+		if (def.type === "number") {
+			const n = Number(raw);
+			if (Number.isFinite(n)) params[toCamel(key)] = n;
+		} else if (def.type === "boolean") params[toCamel(key)] = !!raw;
+		else params[toCamel(key)] = raw;
+	}
+	return params;
+}
+function toCamel(kebab) {
+	return kebab.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function makeReportCommand(report) {
+	const reportArgs = reportArgsToCitty(report.argsSpec);
+	return defineCommand({
+		meta: {
+			name: report.id,
+			description: report.description
+		},
+		args: {
+			"site": {
+				type: "string",
+				alias: "s",
+				description: "Site URL"
+			},
+			"period": {
+				type: "string",
+				description: "Window: 7d|28d|90d|mtd|ytd|custom",
+				default: presetToFlag(report.defaultPeriod)
+			},
+			"vs": {
+				type: "string",
+				description: "Comparison: none|prev-period|yoy",
+				default: report.defaultComparison
+			},
+			"start": {
+				type: "string",
+				description: "Custom start date (YYYY-MM-DD)"
+			},
+			"end": {
+				type: "string",
+				description: "Custom end date (YYYY-MM-DD)"
+			},
+			"prev-start": {
+				type: "string",
+				description: "Override comparison start"
+			},
+			"prev-end": {
+				type: "string",
+				description: "Override comparison end"
+			},
+			"live": {
+				type: "boolean",
+				default: false,
+				description: "Force live GSC API; bypass local store"
+			},
+			"json": {
+				type: "boolean",
+				default: false,
+				description: "Emit full ReportResult JSON"
+			},
+			"explain": {
+				type: "boolean",
+				default: false,
+				description: "Print plan steps + window without executing"
+			},
+			"dry-run": {
+				type: "boolean",
+				default: false,
+				description: "Alias for --explain"
+			},
+			...reportArgs
+		},
+		async run({ args }) {
+			const preset = resolvePeriod(args.period, report.defaultPeriod);
+			const comparison = resolveComparison(args.vs, report.defaultComparison);
+			const window = resolveWindow({
+				preset,
+				comparison,
+				start: args.start,
+				end: args.end
+			});
+			if (args["prev-start"] && args["prev-end"]) window.comparison = {
+				start: String(args["prev-start"]),
+				end: String(args["prev-end"])
+			};
+			const params = buildReportParams(report, args);
+			if (args.explain || args["dry-run"]) {
+				const dry = await dryRunReport(report, {
+					site: args.site ? String(args.site) : "(unresolved)",
+					window,
+					params,
+					registryVersion: defaultReportRegistry.version
+				});
+				console.log(JSON.stringify({
+					id: report.id,
+					window,
+					comparison,
+					plan: dry.steps
+				}, null, 2));
+				return;
+			}
+			const { source, siteUrl } = await resolveAnalysisSource({
+				site: args.site,
+				live: !!args.live,
+				json: !!args.json
+			});
+			const result = await runReport(report, {
+				source,
+				analyzers: defaultAnalyzerRegistry,
+				ctx: {
+					site: siteUrl,
+					window,
+					params,
+					registryVersion: defaultReportRegistry.version
+				}
+			});
+			if (args.json) {
+				console.log(JSON.stringify(result, null, 2));
+				return;
+			}
+			console.log(formatReport(result));
+			if (result.meta.degraded) logger.warn(`degraded: ${result.meta.steps.filter((s) => s.status === "error").map((s) => `${s.key}(${s.error})`).join(", ")}`);
+		}
+	});
+}
+function presetToFlag(preset) {
+	if (preset === "mtd" || preset === "ytd" || preset === "custom") return preset;
+	return preset.replace(/^last-/, "");
+}
+const reportCommand = defineCommand({
+	meta: {
+		name: "report",
+		description: "Run an intent-keyed report (composes analyzers into bounded sections)"
+	},
+	subCommands: {
+		list: defineCommand({
+			meta: {
+				name: "list",
+				description: "List available report ids"
+			},
+			args: { json: {
+				type: "boolean",
+				default: false,
+				description: "Output as JSON"
+			} },
+			async run({ args }) {
+				const reports = defaultReportRegistry.listReports().map((r) => ({
+					id: r.id,
+					description: r.description,
+					defaultPeriod: r.defaultPeriod,
+					defaultComparison: r.defaultComparison
+				}));
+				if (args.json) {
+					console.log(JSON.stringify(reports, null, 2));
+					return;
+				}
+				for (const r of reports) console.log(`${r.id.padEnd(16)} ${r.description}`);
+			}
+		}),
+		...Object.fromEntries(REPORT_IDS.map((id) => [id, makeReportCommand(defaultReportRegistry.getReport(id))]))
+	}
+});
 const sitemapsCommand = defineCommand({
 	meta: {
 		name: "sitemaps",
@@ -3634,16 +4218,12 @@ const sitemapsCommand = defineCommand({
 				description: "List sitemaps for a site"
 			},
 			args: {
+				...OUTPUT_ARGS,
 				site: {
 					type: "string",
 					alias: "s",
 					description: "Site URL (e.g., sc-domain:example.com or https://example.com/)"
 				},
-				json: {
-					type: "boolean",
-					default: false,
-					description: "Output as JSON"
-				},
 				pending: {
 					type: "boolean",
 					default: false,
@@ -3656,12 +4236,10 @@ const sitemapsCommand = defineCommand({
 				}
 			},
 			async run({ args }) {
+				const { json } = applyOutputMode(args);
 				const ctx = await createCommandContext({ needsAuth: true });
 				const siteUrl = await ctx.resolveSite(args.site ? String(args.site) : void 0);
-				let sitemaps = (await ctx.client.sitemaps.list(siteUrl).catch((e) => {
-					logger.error(`Failed to fetch sitemaps: ${e.message}`);
-					process.exit(1);
-				})).map((sm) => ({
+				let sitemaps = (await ctx.client.sitemaps.list(siteUrl).catch(gscErrorHandler)).map((sm) => ({
 					path: sm.path,
 					type: sm.type || void 0,
 					isPending: sm.isPending || false,
@@ -3672,7 +4250,7 @@ const sitemapsCommand = defineCommand({
 				}));
 				if (args.pending) sitemaps = sitemaps.filter((sm) => sm.isPending);
 				if (args.errored) sitemaps = sitemaps.filter((sm) => sm.errors > 0);
-				if (args.json) {
+				if (json) {
 					console.log(JSON.stringify(sitemaps, null, 2));
 					return;
 				}
@@ -3697,6 +4275,7 @@ const sitemapsCommand = defineCommand({
 				description: "Get details for a specific sitemap"
 			},
 			args: {
+				...OUTPUT_ARGS,
 				site: {
 					type: "string",
 					alias: "s",
@@ -3706,19 +4285,15 @@ const sitemapsCommand = defineCommand({
 					type: "positional",
 					required: true,
 					description: "Sitemap URL"
-				},
-				json: {
-					type: "boolean",
-					default: false,
-					description: "Output as JSON"
 				}
 			},
 			async run({ args }) {
+				const { json } = applyOutputMode(args);
 				const ctx = await createCommandContext({ needsAuth: true });
 				const siteUrl = await ctx.resolveSite(args.site ? String(args.site) : void 0);
 				const client = ctx.client;
 				const sitemap = await fetchSitemap(client, siteUrl, args.url).catch(gscErrorHandler);
-				if (args.json) {
+				if (json) {
 					console.log(JSON.stringify(sitemap, null, 2));
 					return;
 				}
@@ -3743,6 +4318,7 @@ const sitemapsCommand = defineCommand({
 				description: "Submit a sitemap to GSC"
 			},
 			args: {
+				...OUTPUT_ARGS,
 				site: {
 					type: "string",
 					alias: "s",
@@ -3755,12 +4331,18 @@ const sitemapsCommand = defineCommand({
 				}
 			},
 			async run({ args }) {
+				const { json } = applyOutputMode(args);
 				const ctx = await createCommandContext({ needsAuth: true });
 				const siteUrl = await ctx.resolveSite(args.site ? String(args.site) : void 0);
-				await ctx.client.sitemaps.submit(siteUrl, args.url).catch((e) => {
-					logger.error(`Submit failed: ${e.message}`);
-					process.exit(1);
-				});
+				await ctx.client.sitemaps.submit(siteUrl, args.url).catch(gscErrorHandler);
+				if (json) {
+					console.log(JSON.stringify({
+						siteUrl,
+						feedpath: args.url,
+						status: "submitted"
+					}, null, 2));
+					return;
+				}
 				logger.success(`Submitted sitemap: ${args.url}`);
 			}
 		}),
@@ -3770,6 +4352,7 @@ const sitemapsCommand = defineCommand({
 				description: "Delete a sitemap from GSC"
 			},
 			args: {
+				...OUTPUT_ARGS,
 				site: {
 					type: "string",
 					alias: "s",
@@ -3782,13 +4365,94 @@ const sitemapsCommand = defineCommand({
 				}
 			},
 			async run({ args }) {
+				const { json } = applyOutputMode(args);
 				const ctx = await createCommandContext({ needsAuth: true });
 				const siteUrl = await ctx.resolveSite(args.site ? String(args.site) : void 0);
-				await ctx.client.sitemaps.delete(siteUrl, args.url).catch((e) => {
-					logger.error(`Delete failed: ${e.message}`);
+				await ctx.client.sitemaps.delete(siteUrl, args.url).catch(gscErrorHandler);
+				if (json) {
+					console.log(JSON.stringify({
+						siteUrl,
+						feedpath: args.url,
+						status: "deleted"
+					}, null, 2));
+					return;
+				}
+				logger.success(`Deleted sitemap: ${args.url}`);
+			}
+		}),
+		discover: defineCommand({
+			meta: {
+				name: "discover",
+				description: "Probe a domain's robots.txt + common paths for an advertised sitemap (no auth needed)"
+			},
+			args: {
+				...OUTPUT_ARGS,
+				domain: {
+					type: "positional",
+					required: true,
+					description: "Domain (e.g., example.com)"
+				}
+			},
+			async run({ args }) {
+				const { json } = applyOutputMode(args);
+				const domain = String(args.domain).replace(/^https?:\/\//, "").replace(/\/.*$/, "");
+				const url = await discoverSitemap(domain).catch(() => null);
+				if (json) {
+					console.log(JSON.stringify({
+						domain,
+						sitemap: url
+					}, null, 2));
+					return;
+				}
+				if (!url) {
+					logger.warn(`No sitemap discovered for ${domain}`);
+					process.exit(1);
+				}
+				logger.success(`Discovered sitemap: ${url}`);
+			}
+		}),
+		urls: defineCommand({
+			meta: {
+				name: "urls",
+				description: "Fetch a sitemap (or sitemap index) and dump its <loc> URLs (no auth needed)"
+			},
+			args: {
+				...OUTPUT_ARGS,
+				"url": {
+					type: "positional",
+					required: true,
+					description: "Sitemap URL (index files are followed)"
+				},
+				"limit": {
+					type: "string",
+					alias: "l",
+					description: "Stop after N URLs across all nested sitemaps"
+				},
+				"max-depth": {
+					type: "string",
+					description: "Max sitemap-index nesting depth (default: 3)"
+				}
+			},
+			async run({ args }) {
+				const { json } = applyOutputMode(args);
+				const limit = args.limit ? Number.parseInt(String(args.limit), 10) : void 0;
+				const maxDepth = args["max-depth"] ? Number.parseInt(String(args["max-depth"]), 10) : void 0;
+				const urls = await fetchSitemapUrls(String(args.url), {
+					limit,
+					maxDepth
+				}).catch((e) => {
+					logger.error(`Sitemap fetch failed: ${e.message}`);
 					process.exit(1);
 				});
-				logger.success(`Deleted sitemap: ${args.url}`);
+				if (json) {
+					console.log(JSON.stringify({
+						sitemap: args.url,
+						count: urls.length,
+						urls
+					}, null, 2));
+					return;
+				}
+				for (const u of urls) console.log(u);
 			}
 		})
 	}
@@ -3847,281 +4511,442 @@ function printPlacementInstructions(method, siteUrl, token) {
 			break;
 		}
 		case "ANALYTICS":
-			console.log(`  Make sure your Google Analytics tracking tag is installed on the site, then run \`gscdump sites verify\`.`);
+			console.log(`  Make sure the Google Analytics tracking tag is installed on the site.`);
+			console.log(`  Expected tracking ID:`);
+			console.log();
+			console.log(`    \x1B[2m${token}\x1B[0m`);
 			break;
 		case "TAG_MANAGER":
-			console.log(`  Make sure your Google Tag Manager container snippet is installed on the site, then run \`gscdump sites verify\`.`);
+			console.log(`  Make sure the Google Tag Manager container snippet is installed on the site.`);
+			console.log(`  Expected container ID:`);
+			console.log();
+			console.log(`    \x1B[2m${token}\x1B[0m`);
 			break;
 	}
 	console.log();
 	console.log(`  \x1B[90mThen run:\x1B[0m gscdump sites verify ${siteUrl} --method ${method}`);
 	console.log();
 }
-const sitesCommand = defineCommand({
+const addCommand = defineCommand({
 	meta: {
-		name: "sites",
-		description: "List GSC sites; manage properties (add/delete) and verify ownership"
+		name: "add",
+		description: "Register a property in Search Console (pass --verify to chain token + verify in one call)"
 	},
 	args: {
-		"json": {
-			type: "boolean",
-			default: false,
-			description: "Output as JSON for scripting"
+		url: {
+			type: "positional",
+			required: true,
+			description: "Property URL (https://example.com/ or sc-domain:example.com)"
 		},
-		"with-sitemaps": {
+		verify: {
 			type: "boolean",
 			default: false,
-			description: "Include sitemaps for each owned site"
+			description: "After adding, fetch a verification token and trigger Google's validation"
 		},
-		"owner-only": {
-			type: "boolean",
-			default: false,
-			description: "Filter to permissionLevel=siteOwner"
+		method: {
+			type: "string",
+			alias: "m",
+			description: "Verification method (used with --verify; default: META for URL-prefix, DNS_TXT for sc-domain:)"
 		},
-		"quiet": {
+		...OUTPUT_ARGS
+	},
+	async run({ args }) {
+		applyOutputMode(args);
+		const ctx = await createCommandContext({ needsAuth: true });
+		await addSite(ctx.client, args.url).catch(gscErrorHandler);
+		if (!args.verify) {
+			if (args.json) {
+				console.log(JSON.stringify({
+					siteUrl: args.url,
+					status: "added",
+					verified: false
+				}, null, 2));
+				return;
+			}
+			logger.success(`Added: ${args.url}`);
+			logger.info(`Property is in unverified state. Verify ownership next:`);
+			const method = pickDefaultMethod(args.url);
+			console.log(`    \x1B[2mgscdump sites verify-token ${args.url} --method ${method}\x1B[0m`);
+			return;
+		}
+		const method = validateMethod(args.url, args.method ?? pickDefaultMethod(args.url));
+		const tokenResult = await getVerificationToken(ctx.client, args.url, method).catch(gscErrorHandler);
+		if (args.json) {
+			console.log(JSON.stringify({
+				siteUrl: args.url,
+				status: "added",
+				method,
+				token: tokenResult.token,
+				site: tokenResult.site,
+				verified: false,
+				next: "Place the token, then run `gscdump sites verify <url> --method <m>`"
+			}, null, 2));
+			return;
+		}
+		logger.success(`Added: ${args.url}`);
+		printPlacementInstructions(method, args.url, tokenResult.token);
+		const ok = await confirm({
+			message: "Token placed? Trigger Google verification now?",
+			initialValue: true
+		});
+		if (isCancel(ok) || !ok) {
+			logger.info("Skipped verification. Run `gscdump sites verify` once the token is live.");
+			return;
+		}
+		const resource = await verifySite(ctx.client, args.url, method).catch(gscErrorHandler);
+		logger.success(`Verified: ${args.url}`);
+		if (resource.owners?.length) {
+			console.log();
+			console.log(`  Owners:`);
+			for (const o of resource.owners) console.log(`    \x1B[90m└─\x1B[0m ${o}`);
+		}
+	}
+});
+const deleteCommand = defineCommand({
+	meta: {
+		name: "delete",
+		description: "Remove a property from Search Console"
+	},
+	args: {
+		url: {
+			type: "positional",
+			required: true,
+			description: "Property URL to remove"
+		},
+		yes: {
 			type: "boolean",
-			alias: "q",
+			alias: "y",
 			default: false,
-			description: "Suppress info/success output"
-		}
+			description: "Skip confirmation prompt"
+		},
+		...OUTPUT_ARGS
 	},
-	subCommands: {
-		"add": defineCommand({
-			meta: {
-				name: "add",
-				description: "Register a property in Search Console (unverified state — verify ownership separately)"
-			},
-			args: {
-				url: {
-					type: "positional",
-					required: true,
-					description: "Property URL (https://example.com/ or sc-domain:example.com)"
-				},
-				json: {
-					type: "boolean",
-					default: false,
-					description: "Output as JSON"
-				},
-				quiet: {
-					type: "boolean",
-					alias: "q",
-					default: false,
-					description: "Suppress info/success output"
-				}
-			},
-			async run({ args }) {
-				setQuiet(Boolean(args.quiet) || Boolean(args.json));
-				await addSite((await createCommandContext({ needsAuth: true })).client, args.url).catch(gscErrorHandler);
-				if (args.json) {
-					console.log(JSON.stringify({
-						siteUrl: args.url,
-						status: "added",
-						verified: false
-					}, null, 2));
-					return;
-				}
-				logger.success(`Added: ${args.url}`);
-				logger.info(`Property is in unverified state. Verify ownership next:`);
-				const method = pickDefaultMethod(args.url);
-				console.log(`    \x1B[2mgscdump sites verify-token ${args.url} --method ${method}\x1B[0m`);
-			}
-		}),
-		"delete": defineCommand({
-			meta: {
-				name: "delete",
-				description: "Remove a property from Search Console"
-			},
-			args: {
-				url: {
-					type: "positional",
-					required: true,
-					description: "Property URL to remove"
-				},
-				yes: {
-					type: "boolean",
-					alias: "y",
-					default: false,
-					description: "Skip confirmation prompt"
-				},
-				json: {
-					type: "boolean",
-					default: false,
-					description: "Output as JSON"
-				},
-				quiet: {
-					type: "boolean",
-					alias: "q",
-					default: false,
-					description: "Suppress info/success output"
-				}
-			},
-			async run({ args }) {
-				setQuiet(Boolean(args.quiet) || Boolean(args.json));
-				if (!args.yes && !args.json) {
-					const ok = await confirm({
-						message: `Remove ${args.url} from Search Console? Local synced data is unaffected.`,
-						initialValue: false
-					});
-					if (isCancel(ok) || !ok) {
-						logger.info("Cancelled");
-						process.exit(0);
-					}
-				}
-				await deleteSite((await createCommandContext({ needsAuth: true })).client, args.url).catch(gscErrorHandler);
-				if (args.json) {
-					console.log(JSON.stringify({
-						siteUrl: args.url,
-						status: "deleted"
-					}, null, 2));
-					return;
-				}
-				logger.success(`Removed: ${args.url}`);
-			}
-		}),
-		"verify-token": defineCommand({
-			meta: {
-				name: "verify-token",
-				description: "Get a verification token to place on the site or in DNS"
-			},
-			args: {
-				url: {
-					type: "positional",
-					required: true,
-					description: "Property URL"
-				},
-				method: {
-					type: "string",
-					alias: "m",
-					description: "META, FILE, DNS_TXT, DNS_CNAME, ANALYTICS, TAG_MANAGER (default: META for URL-prefix, DNS_TXT for sc-domain:)"
-				},
-				json: {
-					type: "boolean",
-					default: false,
-					description: "Output as JSON"
-				},
-				quiet: {
-					type: "boolean",
-					alias: "q",
-					default: false,
-					description: "Suppress info/success output"
-				}
-			},
-			async run({ args }) {
-				setQuiet(Boolean(args.quiet) || Boolean(args.json));
-				const method = validateMethod(args.url, args.method ?? pickDefaultMethod(args.url));
-				const result = await getVerificationToken((await createCommandContext({ needsAuth: true })).client, args.url, method).catch(gscErrorHandler);
-				if (args.json) {
-					console.log(JSON.stringify({
-						siteUrl: args.url,
-						method,
-						token: result.token,
-						site: result.site
-					}, null, 2));
-					return;
-				}
-				printPlacementInstructions(method, args.url, result.token);
+	async run({ args }) {
+		applyOutputMode(args);
+		if (!args.yes && !args.json) {
+			const ok = await confirm({
+				message: `Remove ${args.url} from Search Console? Local synced data is unaffected.`,
+				initialValue: false
+			});
+			if (isCancel(ok) || !ok) {
+				logger.info("Cancelled");
+				process.exit(0);
 			}
-		}),
-		"verify": defineCommand({
-			meta: {
-				name: "verify",
-				description: "Trigger verification — Google fetches/validates the token you placed"
-			},
-			args: {
-				url: {
-					type: "positional",
-					required: true,
-					description: "Property URL"
-				},
-				method: {
-					type: "string",
-					alias: "m",
-					description: "Verification method to validate (must match the one used for verify-token)"
-				},
-				json: {
-					type: "boolean",
-					default: false,
-					description: "Output as JSON"
-				},
-				quiet: {
-					type: "boolean",
-					alias: "q",
-					default: false,
-					description: "Suppress info/success output"
-				}
-			},
-			async run({ args }) {
-				setQuiet(Boolean(args.quiet) || Boolean(args.json));
-				const method = validateMethod(args.url, args.method ?? pickDefaultMethod(args.url));
-				const resource = await verifySite((await createCommandContext({ needsAuth: true })).client, args.url, method).catch(gscErrorHandler);
-				if (args.json) {
-					console.log(JSON.stringify({
-						siteUrl: args.url,
-						method,
-						resource
-					}, null, 2));
-					return;
-				}
-				logger.success(`Verified: ${args.url}`);
-				if (resource.owners?.length) {
-					console.log();
-					console.log(`  Owners:`);
-					for (const o of resource.owners) console.log(`    \x1B[90m└─\x1B[0m ${o}`);
-				}
+		}
+		await deleteSite((await createCommandContext({ needsAuth: true })).client, args.url).catch(gscErrorHandler);
+		if (args.json) {
+			console.log(JSON.stringify({
+				siteUrl: args.url,
+				status: "deleted"
+			}, null, 2));
+			return;
+		}
+		logger.success(`Removed: ${args.url}`);
+	}
+});
+const verifyTokenCommand = defineCommand({
+	meta: {
+		name: "verify-token",
+		description: "Get a verification token to place on the site or in DNS"
+	},
+	args: {
+		url: {
+			type: "positional",
+			required: true,
+			description: "Property URL"
+		},
+		method: {
+			type: "string",
+			alias: "m",
+			description: "META, FILE, DNS_TXT, DNS_CNAME, ANALYTICS, TAG_MANAGER (default: META for URL-prefix, DNS_TXT for sc-domain:)"
+		},
+		...OUTPUT_ARGS
+	},
+	async run({ args }) {
+		applyOutputMode(args);
+		const method = validateMethod(args.url, args.method ?? pickDefaultMethod(args.url));
+		const result = await getVerificationToken((await createCommandContext({ needsAuth: true })).client, args.url, method).catch(gscErrorHandler);
+		if (args.json) {
+			console.log(JSON.stringify({
+				siteUrl: args.url,
+				method,
+				token: result.token,
+				site: result.site
+			}, null, 2));
+			return;
+		}
+		printPlacementInstructions(method, args.url, result.token);
+	}
+});
+const verifyCommand = defineCommand({
+	meta: {
+		name: "verify",
+		description: "Trigger verification — Google fetches/validates the token you placed"
+	},
+	args: {
+		url: {
+			type: "positional",
+			required: true,
+			description: "Property URL"
+		},
+		method: {
+			type: "string",
+			alias: "m",
+			description: "Verification method to validate (must match the one used for verify-token)"
+		},
+		...OUTPUT_ARGS
+	},
+	async run({ args }) {
+		applyOutputMode(args);
+		const method = validateMethod(args.url, args.method ?? pickDefaultMethod(args.url));
+		const resource = await verifySite((await createCommandContext({ needsAuth: true })).client, args.url, method).catch(gscErrorHandler);
+		if (args.json) {
+			console.log(JSON.stringify({
+				siteUrl: args.url,
+				method,
+				resource
+			}, null, 2));
+			return;
+		}
+		logger.success(`Verified: ${args.url}`);
+		if (resource.owners?.length) {
+			console.log();
+			console.log(`  Owners:`);
+			for (const o of resource.owners) console.log(`    \x1B[90m└─\x1B[0m ${o}`);
+		}
+	}
+});
+const verifyGetCommand = defineCommand({
+	meta: {
+		name: "verify-get",
+		description: "Get a single verified WebResource by id"
+	},
+	args: {
+		id: {
+			type: "positional",
+			required: true,
+			description: "WebResource id (from `sites verify-list`)"
+		},
+		...OUTPUT_ARGS
+	},
+	async run({ args }) {
+		applyOutputMode(args);
+		const resource = await getVerifiedSite((await createCommandContext({ needsAuth: true })).client, args.id).catch(gscErrorHandler);
+		if (args.json) {
+			console.log(JSON.stringify(resource, null, 2));
+			return;
+		}
+		const ident = resource.site?.identifier ?? resource.id ?? "?";
+		const type = resource.site?.type === "INET_DOMAIN" ? "domain" : "site";
+		console.log();
+		console.log(`  \x1B[1m${ident}\x1B[0m \x1B[90m(${type})\x1B[0m`);
+		console.log(`  \x1B[90mid:\x1B[0m ${resource.id ?? "?"}`);
+		if (resource.owners?.length) {
+			console.log(`  Owners:`);
+			for (const o of resource.owners) console.log(`    \x1B[90m└─\x1B[0m ${o}`);
+		}
+		console.log();
+	}
+});
+const unverifyCommand = defineCommand({
+	meta: {
+		name: "unverify",
+		description: "Drop your verified ownership of a WebResource (remove the placed token first!)"
+	},
+	args: {
+		id: {
+			type: "positional",
+			required: true,
+			description: "WebResource id (from `sites verify-list`)"
+		},
+		yes: {
+			type: "boolean",
+			alias: "y",
+			default: false,
+			description: "Skip confirmation prompt"
+		},
+		...OUTPUT_ARGS
+	},
+	async run({ args }) {
+		applyOutputMode(args);
+		if (!args.yes && !args.json) {
+			const ok = await confirm({
+				message: `Unverify WebResource ${args.id}? Remove any placed verification token first or Google may re-verify.`,
+				initialValue: false
+			});
+			if (isCancel(ok) || !ok) {
+				logger.info("Cancelled");
+				process.exit(0);
 			}
-		})
+		}
+		await unverifySite((await createCommandContext({ needsAuth: true })).client, args.id).catch(gscErrorHandler);
+		if (args.json) {
+			console.log(JSON.stringify({
+				id: args.id,
+				status: "unverified"
+			}, null, 2));
+			return;
+		}
+		logger.success(`Unverified: ${args.id}`);
+	}
+});
+const verifyListCommand = defineCommand({
+	meta: {
+		name: "verify-list",
+		description: "List verified WebResources from the Site Verification API (distinct from Search Console properties)"
 	},
+	args: { ...OUTPUT_ARGS },
 	async run({ args }) {
-		setQuiet(Boolean(args.quiet) || Boolean(args.json));
-		const ctx = await createCommandContext({ needsAuth: true });
-		const ownerOnly = Boolean(args["owner-only"]);
-		if (args["with-sitemaps"]) {
-			const all = await fetchSitesWithSitemaps(ctx.client).catch(gscErrorHandler);
-			const sites = ownerOnly ? all.filter((s) => s.permissionLevel === "siteOwner") : all;
+		applyOutputMode(args);
+		const resources = await listVerifiedSites((await createCommandContext({ needsAuth: true })).client).catch(gscErrorHandler);
+		if (args.json) {
+			console.log(JSON.stringify(resources, null, 2));
+			return;
+		}
+		if (resources.length === 0) {
+			logger.warn("No verified WebResources found");
+			return;
+		}
+		logger.success(`${resources.length} verified WebResources:`);
+		console.log();
+		for (const r of resources) {
+			const id = r.id ?? "?";
+			const site = r.site;
+			const ident = site?.identifier ?? id;
+			const type = site?.type === "INET_DOMAIN" ? "domain" : "site";
+			console.log(`  \x1B[1m${ident}\x1B[0m \x1B[90m(${type})\x1B[0m`);
+			if (r.owners?.length) for (const o of r.owners) console.log(`    \x1B[90m└─\x1B[0m ${o}`);
+		}
+	}
+});
+const getCommand = defineCommand({
+	meta: {
+		name: "get",
+		description: "Show a single property's permissionLevel from the sites list"
+	},
+	args: {
+		url: {
+			type: "positional",
+			required: true,
+			description: "Property URL"
+		},
+		...OUTPUT_ARGS
+	},
+	async run({ args }) {
+		applyOutputMode(args);
+		const site = (await (await createCommandContext({ needsAuth: true })).loadSites()).find((s) => s.siteUrl === args.url);
+		if (!site) {
 			if (args.json) {
-				const enriched = sites.map((s) => ({
-					...s,
-					sitemapCounts: {
-						total: s.sitemaps.length,
-						pending: s.sitemaps.filter((sm) => sm.isPending).length,
-						errored: s.sitemaps.filter((sm) => Number(sm.errors) > 0).length
-					}
-				}));
-				console.log(JSON.stringify(enriched, null, 2));
-				return;
-			}
-			if (sites.length === 0) {
-				logger.warn(ownerOnly ? "No owned sites found" : "No verified sites found");
-				return;
-			}
-			logger.success(`Found ${sites.length} ${ownerOnly ? "owned" : "verified"} sites:`);
-			console.log();
-			for (const site of sites) {
-				const perm = site.permissionLevel === "siteOwner" ? "\x1B[32m" : "\x1B[90m";
-				console.log(`  ${site.siteUrl} ${perm}(${site.permissionLevel})\x1B[0m`);
-				for (const sm of site.sitemaps) {
-					const pending = sm.isPending ? " \x1B[33m(pending)\x1B[0m" : "";
-					console.log(`    \x1B[90m└─\x1B[0m ${sm.path}${pending}`);
-				}
+				console.log(JSON.stringify(null));
+				process.exit(1);
 			}
+			logger.error(`Not found: ${args.url}`);
+			process.exit(1);
+		}
+		if (args.json) {
+			console.log(JSON.stringify(site, null, 2));
 			return;
 		}
-		const all = await ctx.loadSites();
+		const perm = site.permissionLevel === "siteOwner" ? "\x1B[32m" : "\x1B[90m";
+		console.log();
+		console.log(`  \x1B[1m${site.siteUrl}\x1B[0m`);
+		console.log(`  Permission: ${perm}${site.permissionLevel}\x1B[0m`);
+		console.log();
+	}
+});
+const LIST_ARGS = {
+	...OUTPUT_ARGS,
+	"with-sitemaps": {
+		type: "boolean",
+		default: false,
+		description: "Include sitemaps for each owned site"
+	},
+	"owner-only": {
+		type: "boolean",
+		default: false,
+		description: "Filter to permissionLevel=siteOwner"
+	}
+};
+async function runListSites(args) {
+	applyOutputMode(args);
+	const ctx = await createCommandContext({ needsAuth: true });
+	const ownerOnly = Boolean(args["owner-only"]);
+	if (args["with-sitemaps"]) {
+		const all = await fetchSitesWithSitemaps(ctx.client).catch(gscErrorHandler);
 		const sites = ownerOnly ? all.filter((s) => s.permissionLevel === "siteOwner") : all;
 		if (args.json) {
-			console.log(JSON.stringify(sites, null, 2));
+			const enriched = sites.map((s) => ({
+				...s,
+				sitemapCounts: {
+					total: s.sitemaps.length,
+					pending: s.sitemaps.filter((sm) => sm.isPending).length,
+					errored: s.sitemaps.filter((sm) => Number(sm.errors) > 0).length
+				}
+			}));
+			console.log(JSON.stringify(enriched, null, 2));
 			return;
 		}
 		if (sites.length === 0) {
 			logger.warn(ownerOnly ? "No owned sites found" : "No verified sites found");
 			return;
 		}
-		logger.success(`Found ${sites.length} ${ownerOnly ? "owned " : ""}sites:`);
+		logger.success(`Found ${sites.length} ${ownerOnly ? "owned" : "verified"} sites:`);
 		console.log();
 		for (const site of sites) {
 			const perm = site.permissionLevel === "siteOwner" ? "\x1B[32m" : "\x1B[90m";
 			console.log(`  ${site.siteUrl} ${perm}(${site.permissionLevel})\x1B[0m`);
+			for (const sm of site.sitemaps) {
+				const pending = sm.isPending ? " \x1B[33m(pending)\x1B[0m" : "";
+				console.log(`    \x1B[90m└─\x1B[0m ${sm.path}${pending}`);
+			}
 		}
+		return;
+	}
+	const all = await ctx.loadSites();
+	const sites = ownerOnly ? all.filter((s) => s.permissionLevel === "siteOwner") : all;
+	if (args.json) {
+		console.log(JSON.stringify(sites, null, 2));
+		return;
+	}
+	if (sites.length === 0) {
+		logger.warn(ownerOnly ? "No owned sites found" : "No verified sites found");
+		return;
+	}
+	logger.success(`Found ${sites.length} ${ownerOnly ? "owned " : ""}sites:`);
+	console.log();
+	for (const site of sites) {
+		const perm = site.permissionLevel === "siteOwner" ? "\x1B[32m" : "\x1B[90m";
+		console.log(`  ${site.siteUrl} ${perm}(${site.permissionLevel})\x1B[0m`);
+	}
+}
+const sitesCommand = defineCommand({
+	meta: {
+		name: "sites",
+		description: "List GSC sites; manage properties (add/delete) and verify ownership"
+	},
+	args: LIST_ARGS,
+	subCommands: {
+		"list": defineCommand({
+			meta: {
+				name: "list",
+				description: "List GSC sites (alias of bare `sites`)"
+			},
+			args: LIST_ARGS,
+			async run({ args }) {
+				await runListSites(args);
+			}
+		}),
+		"add": addCommand,
+		"delete": deleteCommand,
+		"get": getCommand,
+		"verify-token": verifyTokenCommand,
+		"verify": verifyCommand,
+		"verify-list": verifyListCommand,
+		"verify-get": verifyGetCommand,
+		"unverify": unverifyCommand
+	},
+	async run({ args }) {
+		await runListSites(args);
 	}
 });
 const compactCommand = defineCommand({
@@ -4152,20 +4977,10 @@ const compactCommand = defineCommand({
 			default: false,
 			description: "Report tier counts per (table, site) without compacting"
 		},
-		"json": {
-			type: "boolean",
-			default: false,
-			description: "Output a JSON summary"
-		},
-		"quiet": {
-			type: "boolean",
-			alias: "q",
-			default: false,
-			description: "Suppress progress output"
-		}
+		...OUTPUT_ARGS
 	},
 	async run({ args }) {
-		setQuiet(Boolean(args.quiet) || Boolean(args.json));
+		const { json } = applyOutputMode(args);
 		const store = (await createCommandContext({ needsStore: true })).store;
 		const siteId = args.site ? store.siteIdFor(String(args.site)) : void 0;
 		const dryRun = Boolean(args["dry-run"]);
@@ -4187,7 +5002,7 @@ const compactCommand = defineCommand({
 					...countByTier(group)
 				});
 			}
-			if (args.json) {
+			if (json) {
 				console.log(JSON.stringify({
 					thresholds,
 					plan: report
@@ -4222,7 +5037,7 @@ const compactCommand = defineCommand({
 				});
 			}
 		}
-		if (args.json) {
+		if (json) {
 			console.log(JSON.stringify({
 				thresholds,
 				compacted: summary
@@ -4314,20 +5129,10 @@ const exportCommand = defineCommand({
 			default: false,
 			description: "Overwrite the output file if it already exists"
 		},
-		json: {
-			type: "boolean",
-			default: false,
-			description: "Output a JSON summary instead of formatted text"
-		},
-		quiet: {
-			type: "boolean",
-			alias: "q",
-			default: false,
-			description: "Suppress info/success output"
-		}
+		...OUTPUT_ARGS
 	},
 	async run({ args }) {
-		setQuiet(Boolean(args.quiet) || Boolean(args.json));
+		const { json } = applyOutputMode(args);
 		const store = (await createCommandContext({ needsStore: true })).store;
 		const siteId = args.site ? store.siteIdFor(args.site) : void 0;
 		const result = await exportToDuckDB({
@@ -4338,7 +5143,7 @@ const exportCommand = defineCommand({
 			outPath: args.out,
 			force: args.force
 		});
-		if (args.json) {
+		if (json) {
 			console.log(JSON.stringify(result, null, 2));
 			return;
 		}
@@ -4374,20 +5179,10 @@ const gcCommand = defineCommand({
 			default: false,
 			description: "List retired manifest entries past the grace window without deleting"
 		},
-		"json": {
-			type: "boolean",
-			default: false,
-			description: "Output a JSON summary"
-		},
-		"quiet": {
-			type: "boolean",
-			alias: "q",
-			default: false,
-			description: "Suppress progress output"
-		}
+		...OUTPUT_ARGS
 	},
 	async run({ args }) {
-		setQuiet(Boolean(args.quiet) || Boolean(args.json));
+		const { json } = applyOutputMode(args);
 		const store = (await createCommandContext({ needsStore: true })).store;
 		const siteId = args.site ? store.siteIdFor(String(args.site)) : void 0;
 		const graceMs = Number(args["grace-hours"]) * 36e5;
@@ -4408,7 +5203,7 @@ const gcCommand = defineCommand({
 					objectKey: e.objectKey
 				});
 			}
-			if (args.json) {
+			if (json) {
 				console.log(JSON.stringify({
 					graceHours: Number(args["grace-hours"]),
 					candidates
@@ -4425,7 +5220,7 @@ const gcCommand = defineCommand({
 			userId: store.userId,
 			siteId
 		}, graceMs);
-		if (args.json) {
+		if (json) {
 			console.log(JSON.stringify({
 				graceHours: Number(args["grace-hours"]),
 				deleted: result.deleted
@@ -4446,25 +5241,15 @@ const rollupsCommand = defineCommand({
 			description: "Rebuild post-sync rollups (daily totals, weekly totals, top-N tables) for a site"
 		},
 		args: {
+			...OUTPUT_ARGS,
 			site: {
 				type: "string",
 				alias: "s",
 				description: "Restrict to a single site (default: all sites with local data)"
-			},
-			json: {
-				type: "boolean",
-				default: false,
-				description: "Output a JSON summary"
-			},
-			quiet: {
-				type: "boolean",
-				alias: "q",
-				default: false,
-				description: "Suppress progress output"
 			}
 		},
 		async run({ args }) {
-			setQuiet(Boolean(args.quiet) || Boolean(args.json));
+			const { json } = applyOutputMode(args);
 			const store = (await createCommandContext({ needsStore: true })).store;
 			const explicitSiteId = args.site ? store.siteIdFor(String(args.site)) : void 0;
 			const allSiteIds = /* @__PURE__ */ new Set();
@@ -4477,7 +5262,7 @@ const rollupsCommand = defineCommand({
 				for (const e of entries) if (e.siteId) allSiteIds.add(e.siteId);
 			}
 			if (allSiteIds.size === 0) {
-				if (args.json) console.log(JSON.stringify({
+				if (json) console.log(JSON.stringify({
 					sites: [],
 					totalBytes: 0
 				}, null, 2));
@@ -4508,11 +5293,11 @@ const rollupsCommand = defineCommand({
 						bytes: r.bytes,
 						objectKey: r.objectKey
 					});
-					if (!args.json) console.log(`  ${r.id.padEnd(20)} ${(r.bytes / 1024).toFixed(1).padStart(8)} KB  ${r.objectKey}`);
+					if (!json) console.log(`  ${r.id.padEnd(20)} ${(r.bytes / 1024).toFixed(1).padStart(8)} KB  ${r.objectKey}`);
 				}
 				summary.push(site);
 			}
-			if (args.json) {
+			if (json) {
 				console.log(JSON.stringify({
 					sites: summary,
 					totalBytes
@@ -4529,24 +5314,14 @@ const statsCommand = defineCommand({
 		description: "Show row/byte counts per table and on-disk footprint"
 	},
 	args: {
-		json: {
-			type: "boolean",
-			default: false,
-			description: "Output as JSON"
-		},
+		...OUTPUT_ARGS,
 		site: {
 			type: "string",
 			description: "Limit to one site URL (sc-domain:example.com, https://example.com/, ...)"
-		},
-		quiet: {
-			type: "boolean",
-			alias: "q",
-			default: false,
-			description: "Suppress info/success output"
 		}
 	},
 	async run({ args }) {
-		setQuiet(Boolean(args.quiet) || Boolean(args.json));
+		const { json } = applyOutputMode(args);
 		const store = (await createCommandContext({ needsStore: true })).store;
 		let siteId;
 		if (args.site) {
@@ -4578,7 +5353,7 @@ const statsCommand = defineCommand({
 			files: 0,
 			bytes: 0
 		}));
-		if (args.json) {
+		if (json) {
 			const payload = {
 				dataDir: store.dataDir,
 				disk,
@@ -4664,11 +5439,98 @@ const storeCommand = defineCommand({
 		description: "Manage the local DuckDB/Parquet store"
 	},
 	subCommands: {
-		stats: statsCommand,
-		compact: compactCommand,
-		gc: gcCommand,
-		export: exportCommand,
-		rollups: rollupsCommand
+		"stats": statsCommand,
+		"compact": compactCommand,
+		"gc": gcCommand,
+		"export": exportCommand,
+		"rollups": rollupsCommand,
+		"rm-site": defineCommand({
+			meta: {
+				name: "rm-site",
+				description: "Delete every parquet, manifest, watermark, and sync-state record for a single site"
+			},
+			args: {
+				site: {
+					type: "positional",
+					required: true,
+					description: "Site URL (e.g. sc-domain:example.com)"
+				},
+				yes: {
+					type: "boolean",
+					alias: "y",
+					default: false,
+					description: "Skip confirmation prompt"
+				},
+				...OUTPUT_ARGS
+			},
+			async run({ args }) {
+				const { json } = applyOutputMode(args);
+				const store = (await createCommandContext({ needsStore: true })).store;
+				const siteId = store.siteIdFor(String(args.site));
+				if (!args.yes && !json) {
+					const ok = await confirm({
+						message: `Delete ALL local data for ${args.site}? This is irreversible.`,
+						initialValue: false
+					});
+					if (isCancel(ok) || !ok) {
+						logger.info("Cancelled");
+						process.exit(0);
+					}
+				}
+				const result = await store.engine.purgeTenant({
+					userId: store.userId,
+					siteId
+				});
+				if (json) {
+					console.log(JSON.stringify(result, null, 2));
+					return;
+				}
+				logger.success(`Removed local data for ${args.site}`);
+				console.log(`  Objects deleted:    ${result.objectsDeleted}`);
+				console.log(`  Manifest entries:   ${result.entriesRemoved}`);
+				console.log(`  Watermarks:         ${result.watermarksRemoved}`);
+				console.log(`  Sync states:        ${result.syncStatesRemoved}`);
+			}
+		}),
+		"reset": defineCommand({
+			meta: {
+				name: "reset",
+				description: "Wipe the entire local store (every site, every table). Irreversible."
+			},
+			args: {
+				yes: {
+					type: "boolean",
+					alias: "y",
+					default: false,
+					description: "Skip confirmation prompt"
+				},
+				...OUTPUT_ARGS
+			},
+			async run({ args }) {
+				const { json } = applyOutputMode(args);
+				const store = (await createCommandContext({ needsStore: true })).store;
+				if (!args.yes && !json) {
+					const ok = await confirm({
+						message: `Wipe the entire local store under ${store.dataDir}? This deletes data for ALL sites.`,
+						initialValue: false
+					});
+					if (isCancel(ok) || !ok) {
+						logger.info("Cancelled");
+						process.exit(0);
+					}
+				}
+				const result = await store.engine.purgeTenant({ userId: store.userId });
+				if (json) {
+					console.log(JSON.stringify(result, null, 2));
+					return;
+				}
+				logger.success("Local store reset");
+				console.log(`  Objects deleted:    ${result.objectsDeleted}`);
+				console.log(`  Manifest entries:   ${result.entriesRemoved}`);
+				console.log(`  Watermarks:         ${result.watermarksRemoved}`);
+				console.log(`  Sync states:        ${result.syncStatesRemoved}`);
+			}
+		})
 	}
 });
 const DEFAULT_TABLES = [
@@ -4844,12 +5706,7 @@ const syncCommand = defineCommand({
 			type: "boolean",
 			description: "Sync the last 450 days (full GSC history)"
 		},
-		"quiet": {
-			type: "boolean",
-			alias: "q",
-			default: false,
-			description: "Suppress progress output"
-		},
+		...OUTPUT_ARGS,
 		"force": {
 			type: "boolean",
 			default: false,
@@ -4860,11 +5717,6 @@ const syncCommand = defineCommand({
 			default: false,
 			description: "Print watermarks + sync-state summary instead of syncing"
 		},
-		"json": {
-			type: "boolean",
-			default: false,
-			description: "With --status: emit JSON"
-		},
 		"concurrency": {
 			type: "string",
 			alias: "c",
@@ -4887,8 +5739,9 @@ const syncCommand = defineCommand({
 		}
 	},
 	async run({ args }) {
+		const { json, quiet } = applyOutputMode(args);
 		if (args.status) {
-			await printSyncStatus(await loadConfig(), args.site ? String(args.site) : void 0, Boolean(args.json));
+			await printSyncStatus(await loadConfig(), args.site ? String(args.site) : void 0, json);
 			return;
 		}
 		const ctx = await createCommandContext({
@@ -4923,7 +5776,7 @@ const syncCommand = defineCommand({
 			logger.warn(`All requested types (${requestedTypes.join(", ")}) are marked empty for this site. Pass --force-types to re-probe.`);
 			return;
 		}
-		if (skippedTypes.length > 0 && !args.quiet) logger.info(`Skipping ${skippedTypes.join(", ")} (marked empty for this site; pass --force-types to re-probe).`);
+		if (skippedTypes.length > 0 && !quiet) logger.info(`Skipping ${skippedTypes.join(", ")} (marked empty for this site; pass --force-types to re-probe).`);
 		const endDate = args.end ? String(args.end) : daysAgo(DEFAULT_PENDING_DAYS);
 		let startDate;
 		if (args.start) startDate = String(args.start);
@@ -4953,7 +5806,7 @@ const syncCommand = defineCommand({
 				return;
 			}
 			args.force = true;
-			if (!args.quiet) logger.info(`--retry-failed: ${dates.length} date(s) to retry`);
+			if (!quiet) logger.info(`--retry-failed: ${dates.length} date(s) to retry`);
 		}
 		if (args["dry-run"]) {
 			const plan = [];
@@ -4962,7 +5815,7 @@ const syncCommand = defineCommand({
 				searchType: type,
 				date
 			});
-			if (args.json) {
+			if (json) {
 				console.log(JSON.stringify({
 					siteUrl,
 					range: {
@@ -4985,7 +5838,7 @@ const syncCommand = defineCommand({
 			logger.info("Pass without --dry-run to execute.");
 			return;
 		}
-		if (!args.quiet) {
+		if (!quiet) {
 			logger.info(`Syncing ${siteUrl} (${tables.join(", ")}) [${types.join(", ")}] → ${displayPath(store.dataDir)}`);
 			logger.info(`Range: ${startDate} → ${endDate} (${dates.length} days)`);
 		}
@@ -5002,7 +5855,7 @@ const syncCommand = defineCommand({
 				label
 			});
 		}
-		const progress = createProgressTracker(dates.length * jobs.length, Boolean(args.quiet));
+		const progress = createProgressTracker(dates.length * jobs.length, quiet);
 		if (serialTables) for (const job of jobs) totals[job.label] = await syncTable(store, siteUrl, job.table, job.type, dates, client, concurrency, args.force, progress);
 		else {
 			const results = await Promise.all(jobs.map((job) => syncTable(store, siteUrl, job.table, job.type, dates, client, concurrency, args.force, progress)));
@@ -5012,7 +5865,7 @@ const syncCommand = defineCommand({
 		}
 		progress.done();
 		const seconds = ((Date.now() - start) / 1e3).toFixed(1);
-		if (!args.quiet) {
+		if (!quiet) {
 			logger.success(`Synced ${siteUrl} in ${seconds}s`);
 			for (const [t, n] of Object.entries(totals)) {
 				const suffix = [n.skipped > 0 ? `${n.skipped} skipped` : null, n.failed > 0 ? `\x1B[31m${n.failed} failed\x1B[0m` : null].filter(Boolean).join(", ");
@@ -5041,7 +5894,7 @@ const syncCommand = defineCommand({
 					userId: store.userId,
 					siteId
 				}, toMark);
-				if (!args.quiet) logger.info(`Marked empty for future syncs: ${toMark.join(", ")} (0 rows across ${dates.length} days; pass --force-types to re-probe).`);
+				if (!quiet) logger.info(`Marked empty for future syncs: ${toMark.join(", ")} (0 rows across ${dates.length} days; pass --force-types to re-probe).`);
 			}
 		}
 		if (forceTypes && emptyTypesDoc.emptyTypes.length > 0) {
@@ -5052,13 +5905,13 @@ const syncCommand = defineCommand({
 					userId: store.userId,
 					siteId
 				}, toClear);
-				if (!args.quiet) logger.info(`Cleared empty markers for: ${toClear.join(", ")} (re-probe found data).`);
+				if (!quiet) logger.info(`Cleared empty markers for: ${toClear.join(", ")} (re-probe found data).`);
 			}
 		}
 		const noRollups = Boolean(args["no-rollups"]);
 		const anyRowsSynced = Object.values(totals).some((t) => t.rows > 0);
 		if (!noRollups && anyRowsSynced) {
-			if (!args.quiet) logger.info(`Rebuilding rollups for [${siteId}] (${DEFAULT_ROLLUPS.length} rollups)…`);
+			if (!quiet) logger.info(`Rebuilding rollups for [${siteId}] (${DEFAULT_ROLLUPS.length} rollups)…`);
 			const rollupStart = Date.now();
 			const results = await rebuildRollups({
 				engine: store.engine,
@@ -5072,7 +5925,7 @@ const syncCommand = defineCommand({
 				logger.warn(`Rollup rebuild failed: ${err.message}`);
 				return [];
 			});
-			if (!args.quiet && results.length > 0) {
+			if (!quiet && results.length > 0) {
 				const kb = results.reduce((a, r) => a + r.bytes, 0) / 1024;
 				const ms = Date.now() - rollupStart;
 				logger.success(`Rebuilt ${results.length} rollup(s) in ${ms}ms — ${kb.toFixed(1)} KB`);
@@ -5160,10 +6013,11 @@ function shouldShowSplash() {
 function applyGlobalArgs() {
 	const argv = process.argv;
 	if (argv.includes("--no-color") || process.env.NO_COLOR) setNoColor(true);
-	const profile = pluckArgValue(argv, "--profile") ?? process.env.GSCDUMP_PROFILE;
-	const configDir = pluckArgValue(argv, "--config-dir") ?? process.env.GSCDUMP_CONFIG_DIR;
-	if (configDir) setConfigDir(configDir);
-	else if (profile) setConfigDir(path.join(os.homedir(), ".config", "gscdump", "profiles", profile));
+	const profile = pluckArgValue(argv, "--profile");
+	applyProfileFromCli({
+		configDir: pluckArgValue(argv, "--config-dir") ?? process.env.GSCDUMP_CONFIG_DIR ?? null,
+		profile
+	});
 	if (argv.includes("-v") && !argv.includes("--version")) {
 		const i = argv.indexOf("-v");
 		argv[i] = "--version";
@@ -5205,8 +6059,10 @@ runMain(defineCommand({
 		indexing: indexingCommand,
 		entities: entitiesCommand,
 		analyze: analyzeCommand,
+		report: reportCommand,
 		auth: authCommand,
 		config: configCommand,
+		profile: profileCommand,
 		doctor: doctorCommand,
 		mcp: mcpCommand
 	},