@gscdump/cli 0.3.1 → 0.6.1

package/dist/index.mjs

@@ -1,43 +1,82 @@
 #!/usr/bin/env node
-import "node:module";
 import process from "node:process";
 import { defineCommand, runMain } from "citty";
-import fs from "node:fs/promises";
+import { defaultAnalyzerRegistry } from "@gscdump/analysis/registry";
+import { AnalyzerCapabilityError, analyzeFromSource, createEngineQuerySource, createGscApiQuerySource } from "@gscdump/analysis";
+import { cancel, isCancel, multiselect, select, text } from "@clack/prompts";
+import { daysAgo, fetchSitemap, formatErrorForCli, getDateRange, googleSearchConsole, progressBar } from "gscdump";
+import fs, { readFile, rm } from "node:fs/promises";
 import { createServer } from "node:http";
 import path from "node:path";
-import { cancel, isCancel, multiselect, select, text } from "@clack/prompts";
 import { OAuth2Client } from "google-auth-library";
 import os from "node:os";
 import { consola } from "consola";
-import { batchInspectUrls, batchRequestIndexing, deleteSitemap, fetchSitemap, fetchSitemaps, fetchSites, fetchSitesWithSitemaps, formatErrorForCli, getIndexingMetadata, googleSearchConsole, inspectUrl, requestIndexing, submitSitemap } from "gscdump";
-import { between, country, date, device, gsc, page, query, searchAppearance } from "gscdump/query";
+import { createNodeHarness } from "@gscdump/engine/node-harness";
+import { TABLE_DIMS, transformGscRow } from "@gscdump/engine/ingest";
+import { allTables, inferTable } from "@gscdump/engine/schema";
+import { Buffer } from "node:buffer";
+import { createEmptyTypesStore, createIndexingMetadataStore, createInspectionStore, createSitemapStore } from "@gscdump/engine/entities";
+import { createGscMcpServer } from "@gscdump/mcp/server";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
-
-//#region rolldown:runtime
-var __defProp = Object.defineProperty;
-var __exportAll = (all, symbols) => {
-	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
+import { SearchTypes, between, country, date, device, gsc, page, query, searchAppearance } from "gscdump/query";
+import { DuckDBInstance } from "@duckdb/node-api";
+import { sqlEscape } from "@gscdump/engine/sql";
+import { DEFAULT_ROLLUPS, rebuildRollups } from "@gscdump/engine/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";
 	}
-	if (symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
+};
+var LocalStoreEmptyError = class extends Error {
+	constructor(siteUrl) {
+		super(`no local data synced for ${siteUrl} (run \`gscdump sync\` first)`);
+		this.name = "LocalStoreEmptyError";
 	}
-	return target;
 };
-
-//#endregion
-//#region src/config.ts
+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;
+	});
+}
 let configDir = path.join(os.homedir(), ".config", "gscdump");
 function getConfigDir() {
 	return configDir;
 }
-const DEFAULT_CLOUD_URL = "https://cloud.gscdump.com";
+function defaultDataDir() {
+	return path.join(os.homedir(), ".gscdump", "data");
+}
+function resolveDataDir(config) {
+	return expandTilde(config.dataDir ?? defaultDataDir());
+}
+function expandTilde(p) {
+	if (p === "~") return os.homedir();
+	if (p.startsWith("~/")) return path.join(os.homedir(), p.slice(2));
+	return p;
+}
 async function loadConfig() {
 	return fs.readFile(path.join(configDir, "config.json"), "utf-8").then((data) => JSON.parse(data)).catch(() => ({}));
 }
@@ -51,28 +90,14 @@ async function saveConfig(config) {
 function getConfigPath() {
 	return path.join(configDir, "config.json");
 }
-
-//#endregion
-//#region src/utils.ts
 const VERSION = "1.0.0";
 const logger = consola.withTag("gscdump");
-/**
-* Handles GSC API errors with helpful messages and suggestions.
-* Exits process with code 1.
-*/
-function handleGscError(error) {
+function gscErrorHandler(error) {
 	console.error();
 	console.error(formatErrorForCli(error));
 	console.error();
 	process.exit(1);
 }
-/**
-* Creates a .catch() handler for GSC API errors.
-* Use: somePromise.catch(gscErrorHandler)
-*/
-function gscErrorHandler(error) {
-	return handleGscError(error);
-}
 const gradientColors = [
 	(s) => `\x1B[38;2;52;211;153m${s}\x1B[0m`,
 	(s) => `\x1B[38;2;45;212;191m${s}\x1B[0m`,
@@ -80,9 +105,9 @@ const gradientColors = [
 	(s) => `\x1B[38;2;56;189;248m${s}\x1B[0m`,
 	(s) => `\x1B[38;2;96;165;250m${s}\x1B[0m`
 ];
-function applyGradient(text$1) {
-	return [...text$1].map((char, i) => {
-		const colorIndex = Math.floor(i / text$1.length * gradientColors.length);
+function applyGradient(text) {
+	return [...text].map((char, i) => {
+		const colorIndex = Math.floor(i / text.length * gradientColors.length);
 		return gradientColors[Math.min(colorIndex, gradientColors.length - 1)](char);
 	}).join("");
 }
@@ -91,15 +116,27 @@ function showSplash() {
 	console.log(`  ${applyGradient("GSC Dump")} v${VERSION}`);
 	console.log();
 }
-function progressBar(current, total, label, width = 30) {
-	const percent = Math.min(current / total, 1);
-	const filled = Math.round(width * percent);
-	const empty = width - filled;
-	return `  ${`\x1B[36m${"█".repeat(filled)}\x1B[0m\x1B[90m${"░".repeat(empty)}\x1B[0m`} \x1B[90m${current}/${total}\x1B[0m ${label}`;
-}
 function clearLine() {
 	process.stdout.write("\r\x1B[K");
 }
+function formatAge(ms) {
+	const delta = Date.now() - ms;
+	if (delta < 6e4) return "just now";
+	if (delta < 36e5) return `${Math.floor(delta / 6e4)}m ago`;
+	if (delta < 864e5) return `${Math.floor(delta / 36e5)}h ago`;
+	return `${Math.floor(delta / 864e5)}d ago`;
+}
+async function runWithConcurrency(items, concurrency, processor) {
+	const cursor = { i: 0 };
+	async function worker() {
+		while (true) {
+			const i = cursor.i++;
+			if (i >= items.length) return;
+			await processor(items[i], i);
+		}
+	}
+	await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, worker));
+}
 function toCSV(data, columns) {
 	return [columns.join(","), ...data.map((row) => columns.map((col) => {
 		const val = row[col];
@@ -140,21 +177,7 @@ function exportToCSV(output) {
 	])}`);
 	return sections.join("\n\n");
 }
-
-//#endregion
-//#region src/auth.ts
-var auth_exports = /* @__PURE__ */ __exportAll({
-	authenticate: () => authenticate,
-	authenticateCloud: () => authenticateCloud,
-	clearCloudTokens: () => clearCloudTokens,
-	clearTokens: () => clearTokens,
-	getAuth: () => getAuth,
-	getAuthCredentials: () => getAuthCredentials,
-	loadCloudTokens: () => loadCloudTokens,
-	loadTokens: () => loadTokens,
-	saveCloudTokens: () => saveCloudTokens,
-	saveTokens: () => saveTokens
-});
+const REDIRECT_URI_RE = /redirect_uri=[^&]+/;
 function getTokensPath() {
 	return path.join(getConfigDir(), "tokens.json");
 }
@@ -253,7 +276,7 @@ async function getAuthCodeViaLoopback(authUrl) {
 				return;
 			}
 			resolvedRedirectUri = `http://127.0.0.1:${addr.port}`;
-			const fullAuthUrl = authUrl.replace(/redirect_uri=[^&]+/, `redirect_uri=${encodeURIComponent(resolvedRedirectUri)}`);
+			const fullAuthUrl = authUrl.replace(REDIRECT_URI_RE, `redirect_uri=${encodeURIComponent(resolvedRedirectUri)}`);
 			console.log();
 			console.log("  \x1B[1mOpening browser for authorization...\x1B[0m");
 			console.log(`  \x1B[90mIf browser doesn't open, visit:\x1B[0m`);
@@ -318,156 +341,400 @@ async function authenticate(credentials, interactive) {
 	logger.success(`Tokens saved to ${getTokensPath()}`);
 	return oauth2Client;
 }
-function getCloudTokensPath() {
-	return path.join(getConfigDir(), "cloud-tokens.json");
-}
-async function loadCloudTokens() {
-	return fs.readFile(getCloudTokensPath(), "utf-8").then((data) => JSON.parse(data)).catch(() => null);
-}
-async function saveCloudTokens(tokens) {
-	await fs.mkdir(getConfigDir(), {
-		recursive: true,
-		mode: 448
-	});
-	await fs.writeFile(getCloudTokensPath(), JSON.stringify(tokens, null, 2), { mode: 384 });
+async function getAuth(opts = {}) {
+	const { interactive = true } = opts;
+	return authenticate(await getAuthCredentials(interactive), interactive);
 }
-async function clearCloudTokens() {
-	await fs.rm(getCloudTokensPath()).catch(() => {});
-	logger.success("Logged out from cloud");
+function createLocalStore(opts) {
+	return createNodeHarness(opts);
 }
-async function authenticateCloud(cloudUrl, interactive) {
-	const existingTokens = await loadCloudTokens();
-	if (existingTokens) {
-		const oauth2Client = new OAuth2Client();
-		oauth2Client.setCredentials({
-			access_token: existingTokens.accessToken,
-			refresh_token: existingTokens.refreshToken,
-			expiry_date: existingTokens.expiresAt
-		});
-		logger.success("Using cloud credentials");
-		return oauth2Client;
-	}
-	if (!interactive) {
-		logger.error("No cloud tokens. Run gscdump init to authenticate.");
-		process.exit(1);
-	}
-	const initRes = await fetch(`${cloudUrl}/api/cli/auth/init`, { method: "POST" }).then((r) => r.json()).catch((e) => {
-		logger.error(`Failed to connect to ${cloudUrl}: ${e.message}`);
-		process.exit(1);
-	});
-	console.log();
-	console.log("  \x1B[1mOpen this URL in your browser:\x1B[0m");
-	console.log(`  \x1B[36m${initRes.authUrl}\x1B[0m`);
-	console.log();
-	console.log(`  \x1B[90mCode: ${initRes.code}\x1B[0m`);
-	console.log();
-	logger.info("Waiting for authorization...");
-	const pollInterval = 2e3;
-	const maxAttempts = Math.ceil(initRes.expiresIn * 1e3 / pollInterval);
-	for (let i = 0; i < maxAttempts; i++) {
-		await new Promise((r) => setTimeout(r, pollInterval));
-		const pollRes = await fetch(`${cloudUrl}/api/cli/auth/poll?code=${initRes.code}`).then((r) => r.json()).catch(() => ({ status: "error" }));
-		if (pollRes.status === "complete" && pollRes.tokens) {
-			await saveCloudTokens(pollRes.tokens);
-			logger.success("Authenticated via cloud.gscdump.com");
-			const oauth2Client = new OAuth2Client();
-			oauth2Client.setCredentials({
-				access_token: pollRes.tokens.accessToken,
-				refresh_token: pollRes.tokens.refreshToken,
-				expiry_date: pollRes.tokens.expiresAt
-			});
-			return oauth2Client;
-		}
-		if (pollRes.status === "error") {
-			logger.error("Authorization failed");
+async function createCommandContext(opts = {}) {
+	const { needsAuth = false, needsStore = false, interactive = false } = opts;
+	const config = await loadConfig();
+	const auth = needsAuth ? await getAuth({
+		interactive,
+		config
+	}) : null;
+	const client = auth ? googleSearchConsole(auth) : null;
+	const store = needsStore ? createLocalStore({ dataDir: resolveDataDir(config) }) : null;
+	const loadSites = async () => {
+		if (!client) throw new Error("loadSites requires needsAuth: true");
+		return (await client.sites().catch((e) => {
+			logger.error(`Failed to fetch sites: ${e.message}`);
 			process.exit(1);
-		}
-	}
-	logger.error("Authorization timed out");
-	process.exit(1);
-}
-async function getAuth(opts = {}) {
-	const { interactive = true, config: providedConfig } = opts;
-	const config = providedConfig || await loadConfig();
-	if (!config.mode) {
-		if (!interactive) {
-			logger.error("Not configured. Run gscdump init first.");
+		})).filter((s) => s.siteUrl && s.permissionLevel !== "siteUnverifiedUser").map((s) => ({
+			siteUrl: s.siteUrl,
+			permissionLevel: s.permissionLevel || "unknown"
+		}));
+	};
+	const resolveSite = async (target) => {
+		const hint = target ?? config.defaultSite;
+		const sites = await loadSites();
+		if (sites.length === 0) {
+			logger.error("No verified sites found");
 			process.exit(1);
 		}
-		logger.warn("GSCDump not configured");
-		logger.info("Run: gscdump init");
-		process.exit(1);
-	}
-	if (config.mode === "cloud") return authenticateCloud(config.cloudUrl || DEFAULT_CLOUD_URL, interactive);
-	return authenticate(await getAuthCredentials(interactive), interactive);
+		if (hint) {
+			const match = sites.find((s) => s.siteUrl === hint || s.siteUrl.includes(hint));
+			if (match) return match.siteUrl;
+		}
+		if (sites.length === 1) return sites[0].siteUrl;
+		const selected = await select({
+			message: "Select a site",
+			options: sites.map((s) => ({
+				value: s.siteUrl,
+				label: s.siteUrl
+			}))
+		});
+		if (isCancel(selected)) {
+			cancel("Cancelled");
+			process.exit(0);
+		}
+		return selected;
+	};
+	return {
+		config,
+		auth,
+		client,
+		store,
+		loadSites,
+		resolveSite
+	};
 }
-
-//#endregion
-//#region src/commands/auth.ts
-const statusCommand = defineCommand({
-	meta: {
-		name: "status",
-		description: "Show current authentication status"
+const ANALYSIS_TOOLS = defaultAnalyzerRegistry.listAnalyzerIds();
+const TOOL_EXTRA_ARGS = {
+	brand: { "brand-terms": {
+		type: "string",
+		description: "Comma-separated brand terms (required)"
+	} },
+	movers: {
+		"prev-start": {
+			type: "string",
+			description: "Previous period start date (required)"
+		},
+		"prev-end": {
+			type: "string",
+			description: "Previous period end date (required)"
+		}
 	},
-	async run() {
-		const config = await loadConfig();
-		console.log();
-		console.log(`  Mode: ${config.mode ? `\x1B[36m${config.mode}\x1B[0m` : "\x1B[33mnot configured\x1B[0m"}`);
-		if (!config.mode) {
-			logger.info("Run gscdump init to configure");
-			return;
+	decay: {
+		"prev-start": {
+			type: "string",
+			description: "Previous period start date (required)"
+		},
+		"prev-end": {
+			type: "string",
+			description: "Previous period end date (required)"
+		}
+	},
+	concentration: { dimension: {
+		type: "string",
+		description: "Dimension: pages or keywords (default: pages)"
+	} },
+	seasonality: { metric: {
+		type: "string",
+		description: "Metric: clicks or impressions (default: clicks)"
+	} },
+	clustering: { "cluster-by": {
+		type: "string",
+		description: "Cluster by: prefix, intent, or both (default: both)"
+	} },
+	trends: {
+		"dimension": {
+			type: "string",
+			description: "Dimension: pages or keywords (default: pages)"
+		},
+		"weeks": {
+			type: "string",
+			description: "Rolling window size in weeks (default: 28)"
+		},
+		"min-weeks": {
+			type: "string",
+			description: "Minimum weeks with data to include an entity (default: weeks/4)"
 		}
-		if (config.mode === "cloud") {
-			console.log(`  Cloud: \x1B[36m${config.cloudUrl}\x1B[0m`);
-			const tokens = await loadCloudTokens();
-			if (!tokens) {
-				logger.warn("Not authenticated");
-				logger.info("Run gscdump init --force to re-authenticate");
+	}
+};
+function buildParams(tool, args) {
+	const params = {
+		type: tool,
+		startDate: args.start ? String(args.start) : void 0,
+		endDate: args.end ? String(args.end) : void 0,
+		limit: args.limit ? Number(args.limit) : void 0
+	};
+	if (args["brand-terms"]) params.brandTerms = String(args["brand-terms"]).split(",").map((t) => t.trim()).filter(Boolean);
+	if (args["prev-start"]) params.prevStartDate = String(args["prev-start"]);
+	if (args["prev-end"]) params.prevEndDate = String(args["prev-end"]);
+	if (args.dimension) params.dimension = String(args.dimension);
+	if (args.metric) params.metric = String(args.metric);
+	if (args["cluster-by"]) params.clusterBy = String(args["cluster-by"]);
+	if (args.weeks) params.weeks = Number(args.weeks);
+	if (args["min-weeks"]) params.minWeeksWithData = Number(args["min-weeks"]);
+	return params;
+}
+function makeToolCommand(tool) {
+	const extraArgs = TOOL_EXTRA_ARGS[tool] || {};
+	return defineCommand({
+		meta: {
+			name: tool,
+			description: `Run ${tool} analysis`
+		},
+		args: {
+			site: {
+				type: "string",
+				alias: "s",
+				description: "Site URL"
+			},
+			start: {
+				type: "string",
+				description: "Start date (YYYY-MM-DD)"
+			},
+			end: {
+				type: "string",
+				description: "End date (YYYY-MM-DD)"
+			},
+			limit: {
+				type: "string",
+				alias: "l",
+				default: "100",
+				description: "Max results"
+			},
+			format: {
+				type: "string",
+				alias: "f",
+				default: "table",
+				description: "Output: table, json, csv"
+			},
+			json: {
+				type: "boolean",
+				default: false,
+				description: "Output as JSON"
+			},
+			live: {
+				type: "boolean",
+				default: false,
+				description: "Force live GSC API; bypass local Parquet store"
+			},
+			...extraArgs
+		},
+		async run({ args }) {
+			const ctx = await createCommandContext({
+				needsAuth: true,
+				needsStore: !args.live
+			});
+			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 hasAccess = !!tokens.accessToken;
-			const hasRefresh = !!tokens.refreshToken;
-			const expiry = tokens.expiresAt ? new Date(tokens.expiresAt) : null;
-			const isExpired = expiry && expiry < /* @__PURE__ */ new Date();
-			logger.success("Authenticated");
-			console.log();
-			console.log(`  Access token:  ${hasAccess ? "\x1B[32mpresent\x1B[0m" : "\x1B[31mmissing\x1B[0m"}`);
-			console.log(`  Refresh token: ${hasRefresh ? "\x1B[32mpresent\x1B[0m" : "\x1B[31mmissing\x1B[0m"}`);
-			if (expiry) {
-				const status = isExpired ? "\x1B[33mexpired\x1B[0m" : "\x1B[32mvalid\x1B[0m";
-				console.log(`  Expires:       ${expiry.toISOString()} (${status})`);
-			}
-		} else {
-			const tokens = await loadTokens();
-			if (!tokens) {
-				logger.warn("Not authenticated");
-				logger.info("Run gscdump init --force to re-authenticate");
+			const result = await runLiveAnalysis(ctx.client, siteUrl, params).catch((e) => {
+				logger.error(`Analysis failed: ${e.message}`);
+				process.exit(1);
+			});
+			if (format === "json") {
+				console.log(JSON.stringify(result, null, 2));
 				return;
 			}
-			const hasAccess = !!tokens.access_token;
-			const hasRefresh = !!tokens.refresh_token;
-			const expiry = tokens.expiry_date ? new Date(tokens.expiry_date) : null;
-			const isExpired = expiry && expiry < /* @__PURE__ */ new Date();
-			logger.success("Authenticated");
-			console.log();
-			console.log(`  Access token:  ${hasAccess ? "\x1B[32mpresent\x1B[0m" : "\x1B[31mmissing\x1B[0m"}`);
-			console.log(`  Refresh token: ${hasRefresh ? "\x1B[32mpresent\x1B[0m" : "\x1B[31mmissing\x1B[0m"}`);
-			if (expiry) {
-				const status = isExpired ? "\x1B[33mexpired\x1B[0m" : "\x1B[32mvalid\x1B[0m";
-				console.log(`  Expires:       ${expiry.toISOString()} (${status})`);
-			}
+			renderResults(result.results, result.results.length, format);
+		}
+	});
+}
+const SPARK_CHARS = [
+	"▁",
+	"▂",
+	"▃",
+	"▄",
+	"▅",
+	"▆",
+	"▇",
+	"█"
+];
+const SPARK_GAP = "·";
+const PERCENT_COLS = {
+	growthRatio: "ratio_to_pct",
+	brandShare: "direct",
+	topNConcentration: "direct",
+	declinePercent: "direct",
+	ctr: "direct",
+	share: "direct",
+	vsAverage: "ratio_to_pct",
+	clicksChangePercent: "scaled",
+	impressionsChangePercent: "scaled"
+};
+function formatPct(val, style) {
+	const pct = style === "ratio_to_pct" ? (val - 1) * 100 : style === "direct" ? val * 100 : val;
+	if (!Number.isFinite(pct)) return "";
+	return `${pct > 0 ? "+" : ""}${pct.toFixed(0)}%`;
+}
+function isTimeSeries(arr) {
+	if (arr.length === 0) return false;
+	const first = arr[0];
+	if (typeof first !== "object" || first === null) return false;
+	const keys = Object.keys(first);
+	const hasBucket = keys.includes("week") || keys.includes("date") || keys.includes("month");
+	const hasMetric = keys.includes("clicks") || keys.includes("impressions") || keys.includes("value");
+	return hasBucket && hasMetric;
+}
+function pickBucketKey(first) {
+	if ("week" in first) return "week";
+	if ("date" in first) return "date";
+	return "month";
+}
+function pickMetricKey(first) {
+	if ("clicks" in first) return "clicks";
+	if ("impressions" in first) return "impressions";
+	return "value";
+}
+function computeAlignedSparklines(results, col) {
+	const allBuckets = /* @__PURE__ */ new Set();
+	const perRow = [];
+	let bucketKey = "week";
+	let metricKey = "clicks";
+	for (const r of results) {
+		const arr = r[col];
+		if (!Array.isArray(arr) || !isTimeSeries(arr)) {
+			perRow.push(null);
+			continue;
+		}
+		const first = arr[0];
+		bucketKey = pickBucketKey(first);
+		metricKey = pickMetricKey(first);
+		const m = /* @__PURE__ */ new Map();
+		for (const item of arr) {
+			const rec = item;
+			const key = String(rec[bucketKey]);
+			const val = Number(rec[metricKey] ?? 0);
+			allBuckets.add(key);
+			m.set(key, val);
 		}
+		perRow.push(m);
 	}
-});
-const logoutCommand = defineCommand({
+	const sorted = [...allBuckets].sort();
+	return perRow.map((m) => {
+		if (!m) return "";
+		const values = sorted.map((b) => m.has(b) ? m.get(b) : null);
+		const nonNull = values.filter((v) => v != null);
+		if (nonNull.length === 0) return SPARK_GAP.repeat(values.length);
+		const min = Math.min(...nonNull);
+		const range = Math.max(...nonNull) - min;
+		return values.map((v) => {
+			if (v == null) return SPARK_GAP;
+			if (range === 0) return SPARK_CHARS[0];
+			return SPARK_CHARS[Math.round((v - min) / range * (SPARK_CHARS.length - 1))];
+		}).join("");
+	});
+}
+function classifyCol(col, values) {
+	const firstNonNull = values.find((v) => v != null);
+	if (firstNonNull == null) return "text";
+	if (Array.isArray(firstNonNull) && isTimeSeries(firstNonNull)) return "series";
+	if (col in PERCENT_COLS && values.every((v) => v == null || typeof v === "number")) return "pct";
+	if (values.every((v) => v == null || typeof v === "number")) return values.some((v) => typeof v === "number" && !Number.isInteger(v)) ? "float" : "int";
+	return "text";
+}
+function formatCellKinded(val, col, kind) {
+	if (val == null) return "";
+	if (kind === "int") return typeof val === "number" ? String(val) : String(val);
+	if (kind === "float") return typeof val === "number" ? val.toFixed(2) : String(val);
+	if (kind === "pct") return typeof val === "number" ? formatPct(val, PERCENT_COLS[col]) : String(val);
+	if (Array.isArray(val)) return `[${val.length} item${val.length === 1 ? "" : "s"}]`;
+	if (typeof val === "object") return JSON.stringify(val);
+	return String(val);
+}
+function computeRowSeriesSparkline(results) {
+	if (results.length < 2) return null;
+	const first = results[0];
+	const bucketKey = "week" in first ? "week" : "date" in first ? "date" : "month" in first ? "month" : null;
+	if (!bucketKey) return null;
+	const metricKey = "value" in first ? "value" : "clicks" in first ? "clicks" : "impressions" in first ? "impressions" : null;
+	if (!metricKey) return null;
+	for (const r of results) if (!(bucketKey in r) || !(metricKey in r)) return null;
+	const values = [...results].sort((a, b) => String(a[bucketKey]).localeCompare(String(b[bucketKey]))).map((r) => Number(r[metricKey] ?? 0));
+	const nonNull = values.filter((v) => Number.isFinite(v));
+	if (nonNull.length === 0) return null;
+	const min = Math.min(...nonNull);
+	const range = Math.max(...nonNull) - min;
+	return {
+		spark: values.map((v) => {
+			if (range === 0) return SPARK_CHARS[0];
+			return SPARK_CHARS[Math.round((v - min) / range * (SPARK_CHARS.length - 1))];
+		}).join(""),
+		label: `${results.length} ${bucketKey}${results.length === 1 ? "" : "s"} of ${metricKey}`
+	};
+}
+function renderResults(results, total, format) {
+	if (format === "csv" && results.length > 0) {
+		const cols = Object.keys(results[0]);
+		console.log(toCSV(results, cols));
+		return;
+	}
+	if (results.length === 0) {
+		logger.warn("No results found");
+		return;
+	}
+	const cols = Object.keys(results[0]);
+	const kinds = cols.map((c) => classifyCol(c, results.map((r) => r[c])));
+	const sparklineByCol = {};
+	cols.forEach((c, i) => {
+		if (kinds[i] === "series") sparklineByCol[c] = computeAlignedSparklines(results, c);
+	});
+	const cellText = (row, rowIdx, colIdx) => {
+		const c = cols[colIdx];
+		const k = kinds[colIdx];
+		if (k === "series") return sparklineByCol[c][rowIdx];
+		return formatCellKinded(row[c], c, k);
+	};
+	const widths = cols.map((c, i) => {
+		let w = c.length;
+		const limit = Math.min(results.length, 20);
+		for (let j = 0; j < limit; j++) {
+			const len = cellText(results[j], j, i).length;
+			if (len > w) w = len;
+		}
+		return w;
+	});
+	console.log();
+	console.log(`  ${cols.map((c, i) => c.padEnd(widths[i])).join("  ")}`);
+	console.log(`  ${cols.map((_, i) => "─".repeat(widths[i])).join("  ")}`);
+	for (let r = 0; r < results.length; r++) console.log(`  ${cols.map((_, i) => cellText(results[r], r, i).padEnd(widths[i])).join("  ")}`);
+	const rowSeriesSparkline = computeRowSeriesSparkline(results);
+	if (rowSeriesSparkline) {
+		console.log();
+		console.log(`  trend: ${rowSeriesSparkline.spark}  (${rowSeriesSparkline.label})`);
+	}
+	console.log();
+	logger.success(`${results.length} results`);
+	if (total > results.length) logger.info(`Total: ${total} (showing ${results.length})`);
+}
+const analyzeCommand = defineCommand({
 	meta: {
-		name: "logout",
-		description: "Clear stored OAuth tokens"
+		name: "analyze",
+		description: "SEO analysis tools"
 	},
-	async run() {
-		if ((await loadConfig()).mode === "cloud") await clearCloudTokens();
-		else await clearTokens();
-	}
+	subCommands: Object.fromEntries(ANALYSIS_TOOLS.map((tool) => [tool, makeToolCommand(tool)]))
 });
 const authCommand = defineCommand({
 	meta: {
@@ -475,295 +742,620 @@ const authCommand = defineCommand({
 		description: "Manage authentication"
 	},
 	subCommands: {
-		status: statusCommand,
-		logout: logoutCommand
+		status: defineCommand({
+			meta: {
+				name: "status",
+				description: "Show current authentication status"
+			},
+			async run() {
+				const tokens = await loadTokens();
+				if (!tokens) {
+					logger.warn("Not authenticated");
+					logger.info("Run gscdump init to authenticate");
+					return;
+				}
+				const hasAccess = !!tokens.access_token;
+				const hasRefresh = !!tokens.refresh_token;
+				const expiry = tokens.expiry_date ? new Date(tokens.expiry_date) : null;
+				const isExpired = expiry && expiry < /* @__PURE__ */ new Date();
+				logger.success("Authenticated");
+				console.log();
+				console.log(`  Access token:  ${hasAccess ? "\x1B[32mpresent\x1B[0m" : "\x1B[31mmissing\x1B[0m"}`);
+				console.log(`  Refresh token: ${hasRefresh ? "\x1B[32mpresent\x1B[0m" : "\x1B[31mmissing\x1B[0m"}`);
+				if (expiry) {
+					const status = isExpired ? "\x1B[33mexpired\x1B[0m" : "\x1B[32mvalid\x1B[0m";
+					console.log(`  Expires:       ${expiry.toISOString()} (${status})`);
+				}
+			}
+		}),
+		logout: defineCommand({
+			meta: {
+				name: "logout",
+				description: "Clear stored OAuth tokens"
+			},
+			async run() {
+				await clearTokens();
+			}
+		})
 	}
 });
-
-//#endregion
-//#region src/commands/config.ts
-const showCommand = defineCommand({
+const configCommand = defineCommand({
 	meta: {
-		name: "show",
-		description: "Show current config"
+		name: "config",
+		description: "Manage configuration"
 	},
-	async run() {
-		const config = await loadConfig();
-		const configPath = getConfigPath();
-		logger.info(`Config: ${configPath}`);
-		console.log();
-		if (Object.keys(config).length === 0) {
-			logger.warn("No config set");
-			return;
-		}
-		console.log(JSON.stringify(config, null, 2));
+	subCommands: {
+		show: defineCommand({
+			meta: {
+				name: "show",
+				description: "Show current config"
+			},
+			async run() {
+				const config = await loadConfig();
+				const configPath = getConfigPath();
+				logger.info(`Config: ${configPath}`);
+				console.log();
+				if (Object.keys(config).length === 0) {
+					logger.warn("No config set");
+					return;
+				}
+				console.log(JSON.stringify(config, null, 2));
+			}
+		}),
+		set: defineCommand({
+			meta: {
+				name: "set",
+				description: "Set a config value"
+			},
+			args: {
+				key: {
+					type: "positional",
+					description: "Config key (defaultSite, defaultPeriod, defaultFormat, defaultDb)",
+					required: true
+				},
+				value: {
+					type: "positional",
+					description: "Value to set",
+					required: true
+				}
+			},
+			async run({ args }) {
+				const validKeys = [
+					"defaultSite",
+					"defaultPeriod",
+					"defaultFormat",
+					"defaultDb"
+				];
+				if (!validKeys.includes(args.key)) {
+					logger.error(`Invalid key: ${args.key}`);
+					logger.info(`Valid keys: ${validKeys.join(", ")}`);
+					process.exit(1);
+				}
+				const config = await loadConfig();
+				config[args.key] = args.value;
+				await saveConfig(config);
+				logger.success(`Set ${args.key} = ${args.value}`);
+			}
+		}),
+		unset: defineCommand({
+			meta: {
+				name: "unset",
+				description: "Remove a config value"
+			},
+			args: { key: {
+				type: "positional",
+				description: "Config key to remove",
+				required: true
+			} },
+			async run({ args }) {
+				const config = await loadConfig();
+				delete config[args.key];
+				await saveConfig(config);
+				logger.success(`Removed ${args.key}`);
+			}
+		}),
+		path: defineCommand({
+			meta: {
+				name: "path",
+				description: "Show config file path"
+			},
+			run() {
+				console.log(getConfigPath());
+			}
+		})
 	}
 });
-const setCommand = defineCommand({
+const DEFAULT_OUT = "./gscdump-export";
+const dumpCommand = defineCommand({
 	meta: {
-		name: "set",
-		description: "Set a config value"
+		name: "dump",
+		description: "Export live Parquet files from the local store to a directory"
 	},
 	args: {
-		key: {
-			type: "positional",
-			description: "Config key (defaultSite, defaultPeriod, defaultFormat, defaultDb)",
-			required: true
+		site: {
+			type: "string",
+			alias: "s",
+			description: "Site URL (e.g., sc-domain:example.com)"
 		},
-		value: {
-			type: "positional",
-			description: "Value to set",
-			required: true
+		out: {
+			type: "string",
+			alias: "o",
+			default: DEFAULT_OUT,
+			description: `Output directory (default: ${DEFAULT_OUT})`
+		},
+		compact: {
+			type: "boolean",
+			default: false,
+			description: "Compact every closed month into a single file before exporting"
+		},
+		quiet: {
+			type: "boolean",
+			alias: "q",
+			default: false,
+			description: "Suppress progress output"
 		}
 	},
 	async run({ args }) {
-		const validKeys = [
-			"defaultSite",
-			"defaultPeriod",
-			"defaultFormat",
-			"defaultDb"
-		];
-		if (!validKeys.includes(args.key)) {
-			logger.error(`Invalid key: ${args.key}`);
-			logger.info(`Valid keys: ${validKeys.join(", ")}`);
-			process.exit(1);
+		const ctx = await createCommandContext({
+			needsAuth: true,
+			needsStore: true
+		});
+		const siteUrl = await ctx.resolveSite(args.site ? String(args.site) : void 0);
+		const store = ctx.store;
+		const outDir = path.resolve(String(args.out));
+		if (args.compact) await compactClosedMonths(store, siteUrl, args.quiet);
+		const entries = await listLiveEntries(store, siteUrl);
+		if (entries.length === 0) {
+			logger.warn(`No data for ${siteUrl}. Run \`gscdump sync\` first.`);
+			process.exit(0);
 		}
-		const config = await loadConfig();
-		config[args.key] = args.value;
-		await saveConfig(config);
-		logger.success(`Set ${args.key} = ${args.value}`);
-	}
-});
-const unsetCommand = defineCommand({
-	meta: {
-		name: "unset",
-		description: "Remove a config value"
-	},
-	args: { key: {
-		type: "positional",
-		description: "Config key to remove",
-		required: true
-	} },
-	async run({ args }) {
-		const config = await loadConfig();
-		delete config[args.key];
-		await saveConfig(config);
-		logger.success(`Removed ${args.key}`);
-	}
-});
-const pathCommand = defineCommand({
-	meta: {
-		name: "path",
-		description: "Show config file path"
-	},
-	run() {
-		console.log(getConfigPath());
-	}
-});
-const configCommand = defineCommand({
-	meta: {
-		name: "config",
-		description: "Manage configuration"
-	},
-	subCommands: {
-		show: showCommand,
-		set: setCommand,
-		unset: unsetCommand,
-		path: pathCommand
+		await fs.mkdir(outDir, { recursive: true });
+		let copied = 0;
+		for (const entry of entries) {
+			const bytes = await store.engine.readObject(entry.objectKey);
+			const target = path.join(outDir, entry.objectKey);
+			await fs.mkdir(path.dirname(target), { recursive: true });
+			await fs.writeFile(target, Buffer.from(bytes));
+			copied++;
+		}
+		if (!args.quiet) logger.success(`Exported ${copied} file(s) to ${outDir}`);
 	}
 });
-
-//#endregion
-//#region src/commands/dump.ts
-const DUMP_DATA_TYPES = [
-	"pages",
-	"keywords",
-	"countries",
-	"devices"
-];
-function getDimensions(dataType) {
-	switch (dataType) {
-		case "pages": return [page, date];
-		case "keywords": return [query, date];
-		case "countries": return [country, date];
-		case "devices": return [device, date];
+async function listLiveEntries(store, siteUrl) {
+	const siteId = store.siteIdFor(siteUrl);
+	return (await Promise.all(allTables().map((table) => store.engine.listLive({
+		userId: store.userId,
+		siteId,
+		table
+	})))).flat();
+}
+async function compactClosedMonths(store, siteUrl, quiet) {
+	const siteId = store.siteIdFor(siteUrl);
+	for (const table of allTables()) {
+		if (!quiet) logger.info(`Compacting ${table} (raw→d7→d30→d90)`);
+		await store.engine.compactTiered({
+			userId: store.userId,
+			siteId,
+			table
+		});
 	}
 }
-const dumpCommand = defineCommand({
+const INSPECTION_QPD_PER_PROPERTY = 2e3;
+const INDEXING_NOT_FOUND_RE = /\b404\b|NOT_FOUND/i;
+async function readUrlList(opts) {
+	if (opts.file) return (await readFile(opts.file, "utf8")).split("\n").map((l) => l.trim()).filter(Boolean);
+	const chunks = [];
+	for await (const chunk of process.stdin) chunks.push(chunk);
+	return Buffer.concat(chunks).toString("utf8").split("\n").map((l) => l.trim()).filter(Boolean);
+}
+const inspectSubCommand = defineCommand({
 	meta: {
-		name: "dump",
-		description: "Export search analytics data via GSC API"
+		name: "inspect",
+		description: "Run URL Inspection for a list of URLs and persist results to the local entity store"
 	},
 	args: {
 		site: {
 			type: "string",
 			alias: "s",
+			required: true,
 			description: "Site URL (e.g., sc-domain:example.com)"
 		},
-		output: {
-			type: "string",
-			alias: "o",
-			description: "Output file path (default: stdout)"
-		},
-		format: {
+		file: {
 			type: "string",
 			alias: "f",
-			default: "json",
-			description: "Output format: json or csv"
-		},
-		start: {
-			type: "string",
-			description: "Start date (YYYY-MM-DD)"
-		},
-		end: {
-			type: "string",
-			description: "End date (YYYY-MM-DD)"
-		},
-		days: {
-			type: "string",
-			alias: "d",
-			default: "28",
-			description: "Number of days to fetch (default: 28)"
+			description: "Path to a file with one URL per line. If omitted, reads from stdin."
 		},
-		types: {
+		limit: {
 			type: "string",
-			alias: "t",
-			description: "Data types: pages,keywords,countries,devices"
+			description: `Max URLs to inspect this run (default: ${INSPECTION_QPD_PER_PROPERTY}, the per-property GSC daily quota)`
 		},
-		limit: {
+		concurrency: {
 			type: "string",
-			alias: "l",
-			default: "25000",
-			description: "Max rows per data type"
+			alias: "c",
+			default: "4",
+			description: "Concurrent in-flight inspect calls (default: 4)"
 		},
 		quiet: {
 			type: "boolean",
 			alias: "q",
 			default: false,
 			description: "Suppress progress output"
-		},
-		interactive: {
-			type: "boolean",
-			alias: "i",
-			default: false,
-			description: "Interactive mode - prompts for options"
 		}
 	},
 	async run({ args }) {
-		const config = await loadConfig();
-		const { getAuth: getAuth$1 } = await Promise.resolve().then(() => auth_exports);
-		const client = googleSearchConsole(await getAuth$1({
-			interactive: false,
-			config
-		}));
-		let siteUrl = String(args.site || config.defaultSite || "");
-		if (!siteUrl || args.interactive) {
-			const verified = (await client.sites()).filter((s) => s.permissionLevel !== "siteUnverifiedUser");
-			if (verified.length === 0) {
-				logger.error("No verified sites found");
-				process.exit(1);
+		const ctx = await createCommandContext({
+			needsAuth: true,
+			needsStore: true
+		});
+		const client = ctx.client;
+		const store = ctx.store;
+		const siteUrl = String(args.site);
+		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);
+		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.");
+			return;
+		}
+		if (urls.length === limit && limit < INSPECTION_QPD_PER_PROPERTY) logger.info(`Capping at --limit ${limit}`);
+		if (urls.length === INSPECTION_QPD_PER_PROPERTY) logger.info(`Hit per-property daily inspection quota (${INSPECTION_QPD_PER_PROPERTY}); remaining URLs will be queued for tomorrow.`);
+		const inspector = createInspectionStore({ dataSource: store.dataSource });
+		let completed = 0;
+		let failed = 0;
+		const records = [];
+		const failures = [];
+		await runWithConcurrency(urls, concurrency, async (url) => {
+			const result = await client.inspect(siteUrl, url).catch((err) => err);
+			if (result instanceof Error) {
+				failed++;
+				failures.push({
+					url,
+					error: result.message
+				});
+			} else {
+				const ix = result.inspectionResult;
+				const indexStatus = ix?.indexStatusResult;
+				records.push({
+					url,
+					inspectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+					indexStatus: indexStatus?.verdict ?? void 0,
+					lastCrawlTime: indexStatus?.lastCrawlTime ?? void 0,
+					googleCanonical: indexStatus?.googleCanonical ?? void 0,
+					userCanonical: indexStatus?.userCanonical ?? void 0,
+					coverageState: indexStatus?.coverageState ?? void 0,
+					robotsTxtState: indexStatus?.robotsTxtState ?? void 0,
+					indexingState: indexStatus?.indexingState ?? void 0,
+					pageFetchState: indexStatus?.pageFetchState ?? void 0,
+					mobileUsabilityVerdict: ix?.mobileUsabilityResult?.verdict ?? void 0,
+					richResultsVerdict: ix?.richResultsResult?.verdict ?? void 0,
+					raw: ix
+				});
 			}
-			const selected = await select({
-				message: "Select a site",
-				options: verified.map((s) => ({
-					value: s.siteUrl,
-					label: s.siteUrl
-				})),
-				initialValue: siteUrl || verified[0]?.siteUrl
-			});
-			if (isCancel(selected)) {
-				cancel("Cancelled");
-				process.exit(0);
+			completed++;
+			if (!quiet) process.stdout.write(`\r${progressBar(completed, urls.length, `${url.slice(0, 60)}`)}`);
+		});
+		if (!quiet) process.stdout.write("\n");
+		await inspector.writeBatch({
+			userId: store.userId,
+			siteId: store.siteIdFor(siteUrl)
+		}, records);
+		if (!quiet) {
+			logger.success(`Inspected ${records.length}/${urls.length} URL(s)`);
+			if (failed > 0) {
+				logger.warn(`${failed} failed:`);
+				for (const f of failures.slice(0, 5)) console.log(`  ${f.url}: ${f.error}`);
+				if (failures.length > 5) console.log(`  ... and ${failures.length - 5} more`);
 			}
-			siteUrl = selected;
 		}
-		let startDate;
-		let endDate;
-		if (args.start && args.end) {
-			startDate = String(args.start);
-			endDate = String(args.end);
-		} else if (args.interactive) {
-			const startInput = await text({
-				message: "Start date (YYYY-MM-DD)",
-				placeholder: (/* @__PURE__ */ new Date(Date.now() - Number(args.days) * 864e5)).toISOString().split("T")[0]
-			});
-			if (isCancel(startInput)) {
-				cancel("Cancelled");
-				process.exit(0);
+		if (failed > 0) process.exit(1);
+	}
+});
+const showSubCommand = defineCommand({
+	meta: {
+		name: "show",
+		description: "Print the latest inspection record for a URL from the local entity store"
+	},
+	args: {
+		site: {
+			type: "string",
+			alias: "s",
+			required: true,
+			description: "Site URL"
+		},
+		url: {
+			type: "positional",
+			required: true,
+			description: "URL to look up"
+		},
+		json: {
+			type: "boolean",
+			default: false,
+			description: "Output as JSON"
+		}
+	},
+	async run({ args }) {
+		const store = (await createCommandContext({ needsStore: true })).store;
+		const record = await createInspectionStore({ dataSource: store.dataSource }).getLatest({
+			userId: store.userId,
+			siteId: store.siteIdFor(String(args.site))
+		}, String(args.url));
+		if (!record) {
+			logger.warn(`No inspection record for ${args.url}`);
+			process.exit(1);
+		}
+		if (args.json) {
+			console.log(JSON.stringify(record, null, 2));
+			return;
+		}
+		console.log();
+		console.log(`  \x1B[1m${record.url}\x1B[0m`);
+		console.log(`  Inspected:    ${record.inspectedAt}`);
+		if (record.indexStatus) console.log(`  Index:        ${record.indexStatus}`);
+		if (record.lastCrawlTime) console.log(`  Last crawl:   ${record.lastCrawlTime}`);
+		if (record.googleCanonical) console.log(`  Canonical:    ${record.googleCanonical}`);
+		if (record.coverageState) console.log(`  Coverage:     ${record.coverageState}`);
+		if (record.mobileUsabilityVerdict) console.log(`  Mobile:       ${record.mobileUsabilityVerdict}`);
+		if (record.richResultsVerdict) console.log(`  Rich results: ${record.richResultsVerdict}`);
+		console.log();
+	}
+});
+const sitemapsSnapshotSubCommand = defineCommand({
+	meta: {
+		name: "snapshot",
+		description: "Fetch current sitemap state from GSC and persist to the local entity store"
+	},
+	args: {
+		site: {
+			type: "string",
+			alias: "s",
+			required: true,
+			description: "Site URL (e.g., sc-domain:example.com)"
+		},
+		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 ctx = await createCommandContext({
+			needsAuth: true,
+			needsStore: true
+		});
+		const client = ctx.client;
+		const store = ctx.store;
+		const siteUrl = String(args.site);
+		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) => ({
+			path: s.path,
+			capturedAt,
+			lastDownloaded: s.lastDownloaded ?? void 0,
+			lastSubmitted: s.lastSubmitted ?? void 0,
+			type: s.type ?? void 0,
+			isPending: s.isPending ?? void 0,
+			isSitemapsIndex: s.isSitemapsIndex ?? void 0,
+			errors: s.errors ?? void 0,
+			warnings: s.warnings ?? void 0,
+			contents: s.contents?.map((c) => ({
+				type: c.type ?? void 0,
+				submitted: c.submitted ?? void 0,
+				indexed: c.indexed ?? void 0
+			})),
+			raw: s
+		}));
+		await createSitemapStore({ dataSource: store.dataSource }).writeSnapshot({
+			userId: store.userId,
+			siteId: store.siteIdFor(siteUrl)
+		}, records);
+		if (args.json) {
+			console.log(JSON.stringify({
+				site: siteUrl,
+				capturedAt,
+				records
+			}, null, 2));
+			return;
+		}
+		if (!quiet) {
+			logger.success(`Captured ${records.length} sitemap(s) for ${siteUrl}`);
+			for (const r of records) {
+				const errors = r.errors && r.errors !== "0" ? ` \x1B[31merr=${r.errors}\x1B[0m` : "";
+				const warnings = r.warnings && r.warnings !== "0" ? ` \x1B[33mwarn=${r.warnings}\x1B[0m` : "";
+				const downloaded = r.lastDownloaded ? ` last=${r.lastDownloaded}` : "";
+				console.log(`  ${r.path}${downloaded}${errors}${warnings}`);
+			}
+		}
+	}
+});
+const sitemapsShowSubCommand = defineCommand({
+	meta: {
+		name: "show",
+		description: "Print the latest captured sitemap state for a feedpath"
+	},
+	args: {
+		site: {
+			type: "string",
+			alias: "s",
+			required: true,
+			description: "Site URL"
+		},
+		path: {
+			type: "positional",
+			required: true,
+			description: "Sitemap path (feedpath)"
+		},
+		json: {
+			type: "boolean",
+			default: false,
+			description: "Output as JSON"
+		}
+	},
+	async run({ args }) {
+		const store = (await createCommandContext({ needsStore: true })).store;
+		const record = await createSitemapStore({ dataSource: store.dataSource }).getLatest({
+			userId: store.userId,
+			siteId: store.siteIdFor(String(args.site))
+		}, String(args.path));
+		if (!record) {
+			logger.warn(`No sitemap record for ${args.path}`);
+			process.exit(1);
+		}
+		if (args.json) {
+			console.log(JSON.stringify(record, null, 2));
+			return;
+		}
+		console.log();
+		console.log(`  \x1B[1m${record.path}\x1B[0m`);
+		console.log(`  Captured:     ${record.capturedAt}`);
+		if (record.lastDownloaded) console.log(`  Downloaded:   ${record.lastDownloaded}`);
+		if (record.lastSubmitted) console.log(`  Submitted:    ${record.lastSubmitted}`);
+		if (record.type) console.log(`  Type:         ${record.type}`);
+		if (record.errors) console.log(`  Errors:       ${record.errors}`);
+		if (record.warnings) console.log(`  Warnings:     ${record.warnings}`);
+		if (record.contents?.length) {
+			console.log(`  Contents:`);
+			for (const c of record.contents) {
+				const bits = [
+					c.type,
+					c.submitted && `submitted=${c.submitted}`,
+					c.indexed && `indexed=${c.indexed}`
+				].filter(Boolean).join("  ");
+				console.log(`    ${bits}`);
+			}
+		}
+		console.log();
+	}
+});
+const indexingSubCommand = defineCommand({
+	meta: {
+		name: "indexing",
+		description: "Snapshot Indexing API metadata per URL"
+	},
+	subCommands: { snapshot: defineCommand({
+		meta: {
+			name: "snapshot",
+			description: "Fetch Indexing API metadata (latest update/remove per URL) and persist to the local entity store"
+		},
+		args: {
+			site: {
+				type: "string",
+				alias: "s",
+				required: true,
+				description: "Site URL (e.g., sc-domain:example.com)"
+			},
+			file: {
+				type: "string",
+				alias: "f",
+				description: "Path to a file with one URL per line. If omitted, reads from stdin."
+			},
+			concurrency: {
+				type: "string",
+				alias: "c",
+				default: "4",
+				description: "Concurrent in-flight getMetadata calls (default: 4)"
+			},
+			quiet: {
+				type: "boolean",
+				alias: "q",
+				default: false,
+				description: "Suppress progress output"
 			}
-			const endInput = await text({
-				message: "End date (YYYY-MM-DD)",
-				placeholder: (/* @__PURE__ */ new Date(Date.now() - 3 * 864e5)).toISOString().split("T")[0]
+		},
+		async run({ args }) {
+			const ctx = await createCommandContext({
+				needsAuth: true,
+				needsStore: true
 			});
-			if (isCancel(endInput)) {
-				cancel("Cancelled");
-				process.exit(0);
+			const client = ctx.client;
+			const store = ctx.store;
+			const siteUrl = String(args.site);
+			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.");
+				return;
 			}
-			startDate = String(startInput) || (/* @__PURE__ */ new Date(Date.now() - Number(args.days) * 864e5)).toISOString().split("T")[0];
-			endDate = String(endInput) || (/* @__PURE__ */ new Date(Date.now() - 3 * 864e5)).toISOString().split("T")[0];
-		} else {
-			const days = Number.parseInt(String(args.days), 10);
-			endDate = (/* @__PURE__ */ new Date(Date.now() - 3 * 864e5)).toISOString().split("T")[0];
-			startDate = (/* @__PURE__ */ new Date(Date.now() - (days + 3) * 864e5)).toISOString().split("T")[0];
-		}
-		let dataTypes;
-		if (args.types) dataTypes = String(args.types).split(",").filter((t) => DUMP_DATA_TYPES.includes(t));
-		else if (args.interactive) {
-			const selected = await multiselect({
-				message: "Select data types to export",
-				options: DUMP_DATA_TYPES.map((t) => ({
-					value: t,
-					label: t
-				})),
-				initialValues: ["pages", "keywords"]
+			const records = [];
+			const failures = [];
+			let completed = 0;
+			await runWithConcurrency(urls, concurrency, async (url) => {
+				const result = await client.indexing.getMetadata(url).catch((err) => err);
+				if (result instanceof Error) if (INDEXING_NOT_FOUND_RE.test(result.message)) records.push({
+					url,
+					capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+				});
+				else failures.push({
+					url,
+					error: result.message
+				});
+				else records.push({
+					url,
+					capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+					latestUpdateAt: result.latestUpdate?.notifyTime ?? void 0,
+					latestRemoveAt: result.latestRemove?.notifyTime ?? void 0,
+					raw: result
+				});
+				completed++;
+				if (!quiet) process.stdout.write(`\r${progressBar(completed, urls.length, url.slice(0, 60))}`);
 			});
-			if (isCancel(selected)) {
-				cancel("Cancelled");
-				process.exit(0);
+			if (!quiet) process.stdout.write("\n");
+			await createIndexingMetadataStore({ dataSource: store.dataSource }).writeBatch({
+				userId: store.userId,
+				siteId: store.siteIdFor(siteUrl)
+			}, records);
+			if (!quiet) {
+				logger.success(`Captured metadata for ${records.length}/${urls.length} URL(s)`);
+				if (failures.length > 0) {
+					logger.warn(`${failures.length} failed:`);
+					for (const f of failures.slice(0, 5)) console.log(`  ${f.url}: ${f.error}`);
+					if (failures.length > 5) console.log(`  ... and ${failures.length - 5} more`);
+				}
 			}
-			dataTypes = selected;
-		} else dataTypes = ["pages", "keywords"];
-		const rowLimit = Number.parseInt(String(args.limit), 10);
-		const format = String(args.format);
-		const output = {
-			siteUrl,
-			dateRange: {
-				start: startDate,
-				end: endDate
+			if (failures.length > 0) process.exit(1);
+		}
+	}) }
+});
+const entitiesCommand = defineCommand({
+	meta: {
+		name: "entities",
+		description: "Manage local entity snapshots (URL inspections, sitemaps, indexing metadata)"
+	},
+	subCommands: {
+		inspect: inspectSubCommand,
+		show: showSubCommand,
+		sitemaps: defineCommand({
+			meta: {
+				name: "sitemaps",
+				description: "Snapshot and inspect sitemap state per site"
 			},
-			exportedAt: (/* @__PURE__ */ new Date()).toISOString()
-		};
-		const totalSteps = dataTypes.length;
-		let currentStep = 0;
-		for (const dataType of dataTypes) {
-			currentStep++;
-			if (!args.quiet) {
-				clearLine();
-				process.stdout.write(progressBar(currentStep, totalSteps, dataType));
+			subCommands: {
+				snapshot: sitemapsSnapshotSubCommand,
+				show: sitemapsShowSubCommand
 			}
-			const dimensions = getDimensions(dataType);
-			const builder = gsc.select(...dimensions).where(between(date, startDate, endDate)).limit(rowLimit);
-			const rows = [];
-			for await (const batch of client.query(siteUrl, builder)) rows.push(...batch);
-			output[dataType] = {
-				total: rows.length,
-				data: rows
-			};
-		}
-		if (!args.quiet) {
-			clearLine();
-			logger.success(`Exported ${dataTypes.join(", ")} for ${siteUrl}`);
-		}
-		const content = format === "csv" ? exportToCSV(output) : JSON.stringify(output, null, 2);
-		if (args.output) {
-			await fs.writeFile(String(args.output), content);
-			if (!args.quiet) logger.info(`Written to ${args.output}`);
-		} else console.log(content);
+		}),
+		indexing: indexingSubCommand
 	}
 });
-
-//#endregion
-//#region src/commands/init.ts
+const ENV_LINE_RE = /^([^=]+)=(.*)$/;
+async function promptDataDir(existing) {
+	const fallback = existing ?? defaultDataDir();
+	const answer = await text({
+		message: "Where should Parquet data be stored?",
+		placeholder: fallback,
+		defaultValue: fallback
+	});
+	if (isCancel(answer)) process.exit(1);
+	return String(answer) || fallback;
+}
 async function loadEnvFile() {
 	const envPath = path.join(process.cwd(), ".env");
 	const content = await fs.readFile(envPath, "utf-8").catch(() => null);
@@ -772,7 +1364,7 @@ async function loadEnvFile() {
 	for (const line of content.split("\n")) {
 		const trimmed = line.trim();
 		if (!trimmed || trimmed.startsWith("#")) continue;
-		const match = trimmed.match(/^([^=]+)=(.*)$/);
+		const match = trimmed.match(ENV_LINE_RE);
 		if (match) {
 			const key = match[1].trim();
 			let value = match[2].trim();
@@ -785,7 +1377,7 @@ async function loadEnvFile() {
 const initCommand = defineCommand({
 	meta: {
 		name: "init",
-		description: "Set up GSCDump (choose cloud or local mode)"
+		description: "Set up GSCDump authentication"
 	},
 	args: { force: {
 		type: "boolean",
@@ -794,8 +1386,8 @@ const initCommand = defineCommand({
 	} },
 	async run({ args }) {
 		const config = await loadConfig();
-		if (config.mode && !args.force) {
-			logger.info(`Already configured in ${config.mode} mode`);
+		if (config.clientId && config.clientSecret && !args.force) {
+			logger.info("Already configured");
 			logger.info("Run with --force to reconfigure");
 			return;
 		}
@@ -808,9 +1400,9 @@ const initCommand = defineCommand({
 			if (envFile.GOOGLE_ACCESS_TOKEN) process.env.GOOGLE_ACCESS_TOKEN = envFile.GOOGLE_ACCESS_TOKEN;
 			await saveConfig({
 				...config,
-				mode: "local",
 				clientId: envFile.GOOGLE_CLIENT_ID,
-				clientSecret: envFile.GOOGLE_CLIENT_SECRET
+				clientSecret: envFile.GOOGLE_CLIENT_SECRET,
+				dataDir: config.dataDir ?? defaultDataDir()
 			});
 			const creds = (await authenticate({
 				clientId: envFile.GOOGLE_CLIENT_ID,
@@ -829,422 +1421,79 @@ const initCommand = defineCommand({
 		console.log("  \x1B[1mWelcome to GSCDump!\x1B[0m");
 		console.log("  \x1B[90mGoogle Search Console data extraction CLI\x1B[0m");
 		console.log();
-		const mode = await select({
-			message: "Choose your setup mode:",
-			options: [{
-				value: "cloud",
-				label: "Cloud (Recommended)",
-				hint: "Easy setup via cloud.gscdump.com - no API keys needed"
-			}, {
-				value: "local",
-				label: "Local",
-				hint: "Use your own Google OAuth credentials"
-			}]
+		const dataDir = await promptDataDir(config.dataDir);
+		const credentials = await getAuthCredentials(true);
+		await saveConfig({
+			...config,
+			dataDir,
+			clientId: credentials.clientId,
+			clientSecret: credentials.clientSecret
 		});
-		if (isCancel(mode)) process.exit(1);
-		if (mode === "cloud") {
-			const cloudUrl = config.cloudUrl || DEFAULT_CLOUD_URL;
-			await saveConfig({
-				...config,
-				mode: "cloud",
-				cloudUrl
-			});
-			await authenticateCloud(cloudUrl, true);
-		} else {
-			await saveConfig({
-				...config,
-				mode: "local"
-			});
-			await authenticate(await getAuthCredentials(true), true);
-		}
+		await authenticate(credentials, true);
 		console.log();
 		logger.success("Setup complete! Run gscdump to get started.");
 	}
 });
-
-//#endregion
-//#region src/mcp/handlers/analytics.ts
-async function collectRows(ctx, siteUrl, builder) {
-	const rows = [];
-	for await (const batch of ctx.client.query(siteUrl, builder)) rows.push(...batch);
-	return rows;
-}
-async function fetchPages(input, ctx) {
-	const builder = gsc.select(page, date).where(between(date, input.period.start, input.period.end)).limit(25e3);
-	const rows = await collectRows(ctx, input.siteUrl, builder);
-	return {
-		total: rows.length,
-		data: rows
-	};
-}
-async function fetchKeywords(input, ctx) {
-	const builder = gsc.select(query, date).where(between(date, input.period.start, input.period.end)).limit(25e3);
-	const rows = await collectRows(ctx, input.siteUrl, builder);
-	return {
-		total: rows.length,
-		data: rows
-	};
-}
-async function fetchCountries(input, ctx) {
-	const builder = gsc.select(country, date).where(between(date, input.period.start, input.period.end)).limit(25e3);
-	const rows = await collectRows(ctx, input.siteUrl, builder);
-	return {
-		total: rows.length,
-		data: rows
-	};
-}
-async function fetchDevices(input, ctx) {
-	const builder = gsc.select(device, date).where(between(date, input.period.start, input.period.end)).limit(25e3);
-	const rows = await collectRows(ctx, input.siteUrl, builder);
-	return {
-		total: rows.length,
-		data: rows
-	};
-}
-
-//#endregion
-//#region src/mcp/handlers/indexing.ts
-async function inspectUrl$1(input, ctx) {
-	return inspectUrl(ctx.client, input.siteUrl, input.inspectionUrl);
-}
-async function requestIndexing$1(input, ctx) {
-	return requestIndexing(ctx.client, input.url, { type: input.type || "URL_UPDATED" }).catch((e) => ({
-		url: input.url,
-		type: input.type || "URL_UPDATED",
-		error: e.message
-	}));
-}
-async function getIndexingStatus(input, ctx) {
-	return getIndexingMetadata(ctx.client, input.url).catch((e) => ({
-		url: input.url,
-		error: e.message
-	}));
-}
-async function batchRequestIndexing$1(input, ctx) {
-	const results = await batchRequestIndexing(ctx.client, input.urls, {
-		type: input.type || "URL_UPDATED",
-		delayMs: input.delayMs || 100
-	});
-	return {
-		results,
-		success: results.length,
-		failed: 0
-	};
-}
-async function batchInspectUrls$1(input, ctx) {
-	const results = await batchInspectUrls(ctx.client, input.siteUrl, input.urls, { delayMs: input.delayMs || 200 });
-	return {
-		results,
-		indexed: results.filter((r) => r.isIndexed).length,
-		notIndexed: results.filter((r) => !r.isIndexed).length
-	};
-}
-
-//#endregion
-//#region src/mcp/handlers/query.ts
-const DIMENSION_MAP$1 = {
-	page,
-	query,
-	date,
-	country,
-	device,
-	searchAppearance
-};
-async function customQuery(input, ctx) {
-	const dimensions = input.dimensions.filter((d) => d in DIMENSION_MAP$1).map((d) => DIMENSION_MAP$1[d]);
-	if (dimensions.length === 0) throw new Error("At least one valid dimension required");
-	const builder = gsc.select(...dimensions).where(between(date, input.period.start, input.period.end)).limit(input.rowLimit || 25e3);
-	const rows = [];
-	for await (const batch of ctx.client.query(input.siteUrl, builder)) rows.push(...batch);
-	return {
-		total: rows.length,
-		data: rows
-	};
-}
-
-//#endregion
-//#region src/mcp/handlers/sites.ts
-async function listSites(_input, ctx) {
-	return fetchSites(ctx.client);
-}
-async function listSitesWithSitemaps(_input, ctx) {
-	return fetchSitesWithSitemaps(ctx.client);
-}
-async function listSitemaps(input, ctx) {
-	return fetchSitemaps(ctx.client, input.siteUrl);
-}
-async function getSitemap(input, ctx) {
-	return fetchSitemap(ctx.client, input.siteUrl, input.feedpath);
-}
-async function submitSitemap$1(input, ctx) {
-	await submitSitemap(ctx.client, input.siteUrl, input.feedpath);
-	return { success: true };
-}
-async function deleteSitemap$1(input, ctx) {
-	await deleteSitemap(ctx.client, input.siteUrl, input.feedpath);
-	return { success: true };
-}
-
-//#endregion
-//#region src/mcp/types.ts
-const periodSchema = z.object({
-	start: z.string().describe("Start date (YYYY-MM-DD)"),
-	end: z.string().describe("End date (YYYY-MM-DD)")
-}).describe("Date range for the query");
-const siteUrlSchema = z.string().describe("GSC property URL (e.g., sc-domain:example.com or https://example.com/)");
-const queryOptionsSchema = z.object({
-	type: z.enum([
-		"web",
-		"image",
-		"video",
-		"news",
-		"discover",
-		"googleNews"
-	]).optional().describe("Data type"),
-	dataState: z.enum(["final", "all"]).optional().describe("Data state: final (settled) or all (includes fresh)"),
-	aggregationType: z.enum(["byPage", "byProperty"]).optional().describe("Aggregation: byPage or byProperty")
-}).optional();
-const listSitesInput = z.object({});
-const listSitemapsInput = z.object({ siteUrl: siteUrlSchema });
-const fetchAnalyticsInput = z.object({
-	siteUrl: siteUrlSchema,
-	period: periodSchema,
-	comparePrevious: z.boolean().optional().describe("Include previous period comparison"),
-	options: queryOptionsSchema
-});
-const fetchPageInput = z.object({
-	siteUrl: siteUrlSchema,
-	period: periodSchema,
-	url: z.string().describe("Page URL to fetch details for")
-});
-const fetchKeywordInput = z.object({
-	siteUrl: siteUrlSchema,
-	period: periodSchema,
-	keyword: z.string().describe("Keyword to fetch details for")
-});
-const inspectUrlInput = z.object({
-	siteUrl: siteUrlSchema,
-	inspectionUrl: z.string().describe("URL to inspect")
-});
-const requestIndexingInput = z.object({
-	url: z.string().describe("URL to request indexing for"),
-	type: z.enum(["URL_UPDATED", "URL_DELETED"]).optional().describe("Notification type")
-});
-const getIndexingStatusInput = z.object({ url: z.string().describe("URL to get indexing status for") });
-const customQueryInput = z.object({
-	siteUrl: siteUrlSchema,
-	period: periodSchema,
-	dimensions: z.array(z.enum([
-		"date",
-		"query",
-		"page",
-		"country",
-		"device",
-		"searchAppearance"
-	])).describe("Dimensions to group by"),
-	rowLimit: z.number().optional().describe("Max rows (default 25000)"),
-	options: queryOptionsSchema
-});
-const sitemapInput = z.object({
-	siteUrl: siteUrlSchema,
-	feedpath: z.string().describe("Sitemap URL (e.g., https://example.com/sitemap.xml)")
-});
-const batchRequestIndexingInput = z.object({
-	urls: z.array(z.string()).describe("URLs to request indexing for"),
-	type: z.enum(["URL_UPDATED", "URL_DELETED"]).optional().describe("Notification type"),
-	delayMs: z.number().optional().describe("Delay between requests in ms (default 100)")
-});
-const batchInspectUrlsInput = z.object({
-	siteUrl: siteUrlSchema,
-	urls: z.array(z.string()).describe("URLs to inspect"),
-	delayMs: z.number().optional().describe("Delay between requests in ms (default 200)")
+const inspectCommand = defineCommand({
+	meta: {
+		name: "inspect",
+		description: "Inspect a specific URL's indexing status"
+	},
+	args: {
+		site: {
+			type: "string",
+			alias: "s",
+			required: true,
+			description: "Site URL (e.g., sc-domain:example.com)"
+		},
+		url: {
+			type: "positional",
+			required: true,
+			description: "URL to inspect"
+		},
+		json: {
+			type: "boolean",
+			default: false,
+			description: "Output as JSON"
+		}
+	},
+	async run({ args }) {
+		const result = await (await createCommandContext({ needsAuth: true })).client.inspect(args.site, args.url).catch((e) => {
+			logger.error(`Inspection failed: ${e.message}`);
+			process.exit(1);
+		});
+		const indexStatus = (result?.inspectionResult)?.indexStatusResult;
+		if (args.json) {
+			console.log(JSON.stringify({
+				url: args.url,
+				verdict: indexStatus?.verdict || null,
+				coverageState: indexStatus?.coverageState || null,
+				indexingState: indexStatus?.indexingState || null,
+				lastCrawlTime: indexStatus?.lastCrawlTime || null,
+				isIndexed: indexStatus?.verdict === "PASS",
+				raw: result
+			}, null, 2));
+			return;
+		}
+		console.log();
+		console.log(`  \x1B[1mURL:\x1B[0m ${args.url}`);
+		console.log();
+		const verdictColor = indexStatus?.verdict === "PASS" ? "\x1B[32m" : "\x1B[31m";
+		console.log(`  Verdict:        ${verdictColor}${indexStatus?.verdict || "N/A"}\x1B[0m`);
+		if (indexStatus?.coverageState) console.log(`  Coverage:       ${indexStatus.coverageState}`);
+		if (indexStatus?.indexingState) console.log(`  Indexing:       ${indexStatus.indexingState}`);
+		if (indexStatus?.lastCrawlTime) console.log(`  Last Crawl:     ${indexStatus.lastCrawlTime}`);
+		if (indexStatus?.robotsTxtState) console.log(`  Robots.txt:     ${indexStatus.robotsTxtState}`);
+		if (indexStatus?.pageFetchState) console.log(`  Page Fetch:     ${indexStatus.pageFetchState}`);
+		if (indexStatus?.googleCanonical) console.log(`  Google Canon:   ${indexStatus.googleCanonical}`);
+		if (indexStatus?.userCanonical) console.log(`  User Canon:     ${indexStatus.userCanonical}`);
+		console.log();
+	}
 });
-
-//#endregion
-//#region src/mcp/server/index.ts
-function createGscMcpServer(options) {
-	const { name = "gscdump", version = "1.0.0", getAuth: getAuth$1 } = options;
-	const server = new McpServer({
-		name,
-		version
-	});
-	const auth = async () => Promise.resolve(getAuth$1());
-	const getContext = async () => {
-		const a = await auth();
-		return {
-			auth: a,
-			client: googleSearchConsole(a)
-		};
-	};
-	server.registerTool("list-sites", {
-		description: "List all Google Search Console sites the user has access to",
-		inputSchema: listSitesInput.shape
-	}, async (args) => {
-		const result = await listSites(args, await getContext());
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	});
-	server.registerTool("list-sites-with-sitemaps", {
-		description: "List all GSC sites with their sitemaps",
-		inputSchema: listSitesInput.shape
-	}, async (args) => {
-		const result = await listSitesWithSitemaps(args, await getContext());
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	});
-	server.registerTool("list-sitemaps", {
-		description: "List sitemaps for a specific site",
-		inputSchema: listSitemapsInput.shape
-	}, async (args) => {
-		const result = await listSitemaps(args, await getContext());
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	});
-	server.registerTool("get-sitemap", {
-		description: "Get details for a specific sitemap",
-		inputSchema: sitemapInput.shape
-	}, async (args) => {
-		const result = await getSitemap(args, await getContext());
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	});
-	server.registerTool("submit-sitemap", {
-		description: "Submit a sitemap to Google Search Console",
-		inputSchema: sitemapInput.shape
-	}, async (args) => {
-		const result = await submitSitemap$1(args, await getContext());
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	});
-	server.registerTool("delete-sitemap", {
-		description: "Delete a sitemap from Google Search Console",
-		inputSchema: sitemapInput.shape
-	}, async (args) => {
-		const result = await deleteSitemap$1(args, await getContext());
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	});
-	server.registerTool("fetch-pages", {
-		description: "Fetch page analytics data for a site",
-		inputSchema: fetchAnalyticsInput.shape
-	}, async (args) => {
-		const result = await fetchPages(args, await getContext());
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	});
-	server.registerTool("fetch-keywords", {
-		description: "Fetch keyword/query analytics data for a site",
-		inputSchema: fetchAnalyticsInput.shape
-	}, async (args) => {
-		const result = await fetchKeywords(args, await getContext());
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	});
-	server.registerTool("fetch-countries", {
-		description: "Fetch country analytics data for a site",
-		inputSchema: fetchAnalyticsInput.shape
-	}, async (args) => {
-		const result = await fetchCountries(args, await getContext());
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	});
-	server.registerTool("fetch-devices", {
-		description: "Fetch device analytics data for a site",
-		inputSchema: fetchAnalyticsInput.shape
-	}, async (args) => {
-		const result = await fetchDevices(args, await getContext());
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	});
-	server.registerTool("custom-query", {
-		description: "Run a custom search analytics query with specified dimensions",
-		inputSchema: customQueryInput.shape
-	}, async (args) => {
-		const result = await customQuery(args, await getContext());
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	});
-	server.registerTool("inspect-url", {
-		description: "Inspect a URL in Google Search Console to check its indexing status",
-		inputSchema: inspectUrlInput.shape
-	}, async (args) => {
-		const result = await inspectUrl$1(args, await getContext());
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	});
-	server.registerTool("request-indexing", {
-		description: "Request Google to index or remove a URL via the Indexing API",
-		inputSchema: requestIndexingInput.shape
-	}, async (args) => {
-		const result = await requestIndexing$1(args, await getContext());
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	});
-	server.registerTool("get-indexing-status", {
-		description: "Get indexing status metadata for a URL",
-		inputSchema: getIndexingStatusInput.shape
-	}, async (args) => {
-		const result = await getIndexingStatus(args, await getContext());
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	});
-	server.registerTool("batch-request-indexing", {
-		description: "Batch request indexing for multiple URLs with rate limiting",
-		inputSchema: batchRequestIndexingInput.shape
-	}, async (args) => {
-		const result = await batchRequestIndexing$1(args, await getContext());
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	});
-	server.registerTool("batch-inspect-urls", {
-		description: "Batch inspect multiple URLs to check their indexing status",
-		inputSchema: batchInspectUrlsInput.shape
-	}, async (args) => {
-		const result = await batchInspectUrls$1(args, await getContext());
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(result, null, 2)
-		}] };
-	});
-	return server;
-}
-
-//#endregion
-//#region src/commands/mcp.ts
 async function checkAuth() {
 	if ((process.env.GOOGLE_ACCESS_TOKEN || process.env.GOOGLE_REFRESH_TOKEN) && process.env.GOOGLE_CLIENT_ID && process.env.GOOGLE_CLIENT_SECRET) return { ok: true };
 	const config = await loadConfig();
-	if (!config.mode) return {
+	if (!config.clientId && !config.clientSecret) return {
 		ok: false,
 		error: `GSCDump not configured.
 
@@ -1256,20 +1505,9 @@ Or provide env vars: GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET, GOOGLE_ACCESS_TOKEN
 
 Then restart your MCP client.`
 	};
-	if (config.mode === "cloud") {
-		if (!await loadCloudTokens()) return {
-			ok: false,
-			error: `Cloud authentication expired or missing.
-
-Run this command to re-authenticate:
-
-  npx @gscdump/cli init
-
-Then restart your MCP client.`
-		};
-	} else if (!await loadTokens()) return {
-		ok: false,
-		error: `Local authentication missing.
+	if (!await loadTokens()) return {
+		ok: false,
+		error: `Authentication missing.
 
 Run this command to authenticate:
 
@@ -1299,10 +1537,15 @@ const mcpCommand = defineCommand({
 		await server.connect(transport);
 	}
 });
-
-//#endregion
-//#region src/commands/query.ts
-const DIMENSION_MAP = {
+const DIMENSIONS = [
+	"page",
+	"query",
+	"date",
+	"country",
+	"device",
+	"searchAppearance"
+];
+const DIM_COLUMNS = {
 	page,
 	query,
 	date,
@@ -1310,10 +1553,38 @@ const DIMENSION_MAP = {
 	device,
 	searchAppearance
 };
+async function runLiveQuery(client, siteUrl, opts) {
+	const allRows = [];
+	let startRow = 0;
+	while (true) {
+		const rows = ((await client._rawQuery(siteUrl, {
+			startDate: opts.startDate,
+			endDate: opts.endDate,
+			dimensions: opts.dimensions,
+			rowLimit: opts.rowLimit,
+			startRow
+		})).rows || []).map((row) => {
+			const result = {
+				clicks: row.clicks ?? 0,
+				impressions: row.impressions ?? 0,
+				ctr: row.ctr ?? 0,
+				position: row.position ?? 0
+			};
+			opts.dimensions.forEach((dim, i) => {
+				result[dim] = row.keys?.[i];
+			});
+			return result;
+		});
+		allRows.push(...rows);
+		if (rows.length < opts.rowLimit) break;
+		startRow += rows.length;
+	}
+	return { rows: allRows };
+}
 const queryCommand = defineCommand({
 	meta: {
 		name: "query",
-		description: "Run custom search analytics queries"
+		description: "Run a search analytics query (local Parquet by default, --live hits GSC API)"
 	},
 	args: {
 		site: {
@@ -1324,7 +1595,7 @@ const queryCommand = defineCommand({
 		dimensions: {
 			type: "string",
 			alias: "d",
-			description: "Dimensions: page,query,date,country,device,searchAppearance"
+			description: `Dimensions: ${DIMENSIONS.join(",")}`
 		},
 		start: {
 			type: "string",
@@ -1351,6 +1622,19 @@ const queryCommand = defineCommand({
 			default: "json",
 			description: "Output format: json or csv"
 		},
+		sql: {
+			type: "string",
+			description: "Raw DuckDB SQL using {{FILES}} as the file list placeholder (bypasses builder)"
+		},
+		table: {
+			type: "string",
+			description: "Analytics table for --sql (default: pages)"
+		},
+		live: {
+			type: "boolean",
+			default: false,
+			description: "Bypass local store; hit the GSC API directly"
+		},
 		quiet: {
 			type: "boolean",
 			alias: "q",
@@ -1365,291 +1649,1150 @@ const queryCommand = defineCommand({
 		}
 	},
 	async run({ args }) {
-		const config = await loadConfig();
-		const { getAuth: getAuth$1 } = await Promise.resolve().then(() => auth_exports);
-		const client = googleSearchConsole(await getAuth$1({
-			interactive: false,
-			config
-		}));
-		let siteUrl = String(args.site || config.defaultSite || "");
-		if (!siteUrl || args.interactive) {
-			const verified = (await client.sites()).filter((s) => s.permissionLevel !== "siteUnverifiedUser");
-			if (verified.length === 0) {
-				logger.error("No verified sites found");
+		if (args.sql) {
+			await runRawSqlMode({
+				sql: String(args.sql),
+				site: args.site ? String(args.site) : void 0,
+				table: args.table ? String(args.table) : "pages",
+				output: args.output ? String(args.output) : void 0,
+				quiet: Boolean(args.quiet)
+			});
+			return;
+		}
+		const dimNames = await resolveDimensions(args);
+		const { startDate, endDate } = await resolveRange(args);
+		const rowLimit = Number.parseInt(String(args.limit), 10);
+		const format = String(args.format);
+		const ctx = await createCommandContext({
+			needsAuth: true,
+			needsStore: !args.live,
+			interactive: Boolean(args.interactive)
+		});
+		const siteUrl = await ctx.resolveSite(args.site ? String(args.site) : void 0);
+		if (args.live) {
+			if (!args.quiet) logger.info(`Querying ${siteUrl} via live GSC API...`);
+			const result = await runLiveQuery(ctx.client, siteUrl, {
+				startDate,
+				endDate,
+				dimensions: dimNames,
+				rowLimit
+			}).catch((e) => {
+				logger.error(`Query failed: ${e.message}`);
 				process.exit(1);
-			}
-			const selected = await select({
-				message: "Select a site",
-				options: verified.map((s) => ({
-					value: s.siteUrl,
-					label: s.siteUrl
-				})),
-				initialValue: siteUrl || verified[0]?.siteUrl
 			});
-			if (isCancel(selected)) {
-				cancel("Cancelled");
-				process.exit(0);
-			}
-			siteUrl = selected;
-		}
-		let dimensions;
-		if (args.dimensions) dimensions = String(args.dimensions).split(",").filter((d) => d in DIMENSION_MAP).map((d) => DIMENSION_MAP[d]);
-		else if (args.interactive) {
-			const selected = await multiselect({
-				message: "Select dimensions",
-				options: Object.keys(DIMENSION_MAP).map((d) => ({
-					value: d,
-					label: d
-				})),
-				initialValues: ["page", "query"]
+			await writeOutput({
+				output: {
+					siteUrl,
+					dimensions: dimNames,
+					dateRange: {
+						start: startDate,
+						end: endDate
+					},
+					total: result.rows.length,
+					data: result.rows
+				},
+				format,
+				path: args.output ? String(args.output) : void 0,
+				quiet: Boolean(args.quiet)
 			});
-			if (isCancel(selected)) {
-				cancel("Cancelled");
-				process.exit(0);
+			return;
+		}
+		if (!args.quiet) logger.info(`Querying ${siteUrl} from local Parquet store...`);
+		const state = buildLocalState(dimNames, startDate, endDate, rowLimit);
+		const store = ctx.store;
+		const table = inferTable(dimNames);
+		await assertRangeCovered(store, siteUrl, table, startDate, endDate);
+		const result = await store.engine.query({
+			userId: store.userId,
+			siteId: store.siteIdFor(siteUrl),
+			table
+		}, state).catch((e) => {
+			logger.error(`Query failed: ${e.message}`);
+			process.exit(1);
+		});
+		await writeOutput({
+			output: {
+				siteUrl,
+				dimensions: dimNames,
+				dateRange: {
+					start: startDate,
+					end: endDate
+				},
+				total: result.rows.length,
+				data: result.rows
+			},
+			format,
+			path: args.output ? String(args.output) : void 0,
+			quiet: Boolean(args.quiet)
+		});
+	}
+});
+async function resolveDimensions(args) {
+	if (args.dimensions) return String(args.dimensions).split(",").filter((d) => DIMENSIONS.includes(d));
+	if (args.interactive) {
+		const selected = await multiselect({
+			message: "Select dimensions",
+			options: DIMENSIONS.map((d) => ({
+				value: d,
+				label: d
+			})),
+			initialValues: ["page", "query"]
+		});
+		if (isCancel(selected)) {
+			cancel("Cancelled");
+			process.exit(0);
+		}
+		return selected;
+	}
+	return ["page", "query"];
+}
+async function resolveRange(args) {
+	if (args.start && args.end) return {
+		startDate: String(args.start),
+		endDate: String(args.end)
+	};
+	if (args.interactive) {
+		const startInput = await text({
+			message: "Start date (YYYY-MM-DD)",
+			placeholder: daysAgo(28)
+		});
+		if (isCancel(startInput)) {
+			cancel("Cancelled");
+			process.exit(0);
+		}
+		const endInput = await text({
+			message: "End date (YYYY-MM-DD)",
+			placeholder: daysAgo(3)
+		});
+		if (isCancel(endInput)) {
+			cancel("Cancelled");
+			process.exit(0);
+		}
+		return {
+			startDate: String(startInput) || daysAgo(28),
+			endDate: String(endInput) || daysAgo(3)
+		};
+	}
+	return {
+		startDate: daysAgo(31),
+		endDate: daysAgo(3)
+	};
+}
+function buildLocalState(dimNames, startDate, endDate, rowLimit) {
+	const dims = dimNames.map((d) => DIM_COLUMNS[d]).filter((c) => Boolean(c));
+	return gsc.select(...dims).where(between(date, startDate, endDate)).limit(rowLimit).getState();
+}
+async function assertRangeCovered(store, siteUrl, table, startDate, endDate) {
+	const wm = (await store.engine.getWatermarks({
+		userId: store.userId,
+		siteId: store.siteIdFor(siteUrl),
+		table
+	}))[0];
+	if (!wm) {
+		logger.error(`No data synced for ${siteUrl} / ${table}. Run \`gscdump sync\` first, or pass --live.`);
+		process.exit(1);
+	}
+	if (endDate > wm.newestDateSynced) {
+		logger.error(`Requested end=${endDate} is newer than last sync (${wm.newestDateSynced}). Run \`gscdump sync\` first, or pass --live.`);
+		process.exit(1);
+	}
+	if (startDate < wm.oldestDateSynced) {
+		logger.error(`Requested start=${startDate} is older than first sync (${wm.oldestDateSynced}). Run \`gscdump sync --start=${startDate}\` first, or pass --live.`);
+		process.exit(1);
+	}
+}
+async function runRawSqlMode(opts) {
+	if (!isKnownTable$1(opts.table)) {
+		logger.error(`Unknown table "${opts.table}". Known: ${allTables().join(", ")}`);
+		process.exit(1);
+	}
+	const ctx = await createCommandContext({
+		needsAuth: true,
+		needsStore: true
+	});
+	const siteUrl = await ctx.resolveSite(opts.site);
+	const store = ctx.store;
+	if (!opts.quiet) logger.info(`Running raw SQL over table "${opts.table}" for ${siteUrl}`);
+	const { rows, sql } = await store.runRawSql({
+		sql: opts.sql,
+		siteUrl,
+		table: opts.table
+	}).catch((e) => {
+		logger.error(`SQL failed: ${e.message}`);
+		process.exit(1);
+	});
+	const payload = JSON.stringify({
+		sql,
+		total: rows.length,
+		data: rows
+	}, null, 2);
+	if (opts.output) {
+		await fs.writeFile(opts.output, payload);
+		if (!opts.quiet) logger.info(`Written to ${opts.output}`);
+	} else console.log(payload);
+}
+async function writeOutput(opts) {
+	const content = opts.format === "csv" ? exportToCSV(opts.output) : JSON.stringify(opts.output, null, 2);
+	if (opts.path) {
+		await fs.writeFile(opts.path, content);
+		if (!opts.quiet) logger.info(`Written to ${opts.path}`);
+	} else console.log(content);
+}
+function isKnownTable$1(name) {
+	return allTables().includes(name);
+}
+function requireSite(target) {
+	if (!target) {
+		logger.error("Site URL required (-s)");
+		process.exit(1);
+	}
+	return target;
+}
+const sitemapsCommand = defineCommand({
+	meta: {
+		name: "sitemaps",
+		description: "Manage sitemaps"
+	},
+	subCommands: {
+		list: defineCommand({
+			meta: {
+				name: "list",
+				description: "List sitemaps for a site"
+			},
+			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"
+				}
+			},
+			async run({ args }) {
+				const config = await loadConfig();
+				const siteUrl = requireSite(args.site || config.defaultSite);
+				const sitemaps = (await (await createCommandContext({ needsAuth: true })).client.sitemaps.list(siteUrl).catch((e) => {
+					logger.error(`Failed to fetch sitemaps: ${e.message}`);
+					process.exit(1);
+				})).map((sm) => ({
+					path: sm.path,
+					type: sm.type || void 0,
+					isPending: sm.isPending || false,
+					errors: Number(sm.errors) || 0,
+					warnings: Number(sm.warnings) || 0,
+					lastDownloaded: sm.lastDownloaded || null
+				}));
+				if (args.json) {
+					console.log(JSON.stringify(sitemaps, null, 2));
+					return;
+				}
+				if (sitemaps.length === 0) {
+					logger.warn("No sitemaps found");
+					return;
+				}
+				logger.success(`Found ${sitemaps.length} sitemaps:`);
+				console.log();
+				for (const sm of sitemaps) {
+					const pending = sm.isPending ? " \x1B[33m(pending)\x1B[0m" : "";
+					const errors = sm.errors ? ` \x1B[31m${sm.errors} errors\x1B[0m` : "";
+					const warnings = sm.warnings ? ` \x1B[33m${sm.warnings} warnings\x1B[0m` : "";
+					console.log(`  ${sm.path}${pending}${errors}${warnings}`);
+				}
 			}
-			dimensions = selected.map((d) => DIMENSION_MAP[d]);
-		} else dimensions = [page, query];
-		let startDate;
-		let endDate;
-		if (args.start && args.end) {
-			startDate = String(args.start);
-			endDate = String(args.end);
-		} else if (args.interactive) {
-			const startInput = await text({
-				message: "Start date (YYYY-MM-DD)",
-				placeholder: (/* @__PURE__ */ new Date(Date.now() - 28 * 864e5)).toISOString().split("T")[0]
-			});
-			if (isCancel(startInput)) {
-				cancel("Cancelled");
-				process.exit(0);
+		}),
+		get: defineCommand({
+			meta: {
+				name: "get",
+				description: "Get details for a specific sitemap"
+			},
+			args: {
+				site: {
+					type: "string",
+					alias: "s",
+					required: true,
+					description: "Site URL"
+				},
+				url: {
+					type: "positional",
+					required: true,
+					description: "Sitemap URL"
+				},
+				json: {
+					type: "boolean",
+					default: false,
+					description: "Output as JSON"
+				}
+			},
+			async run({ args }) {
+				const client = (await createCommandContext({ needsAuth: true })).client;
+				const sitemap = await fetchSitemap(client, args.site, args.url).catch(gscErrorHandler);
+				if (args.json) {
+					console.log(JSON.stringify(sitemap, null, 2));
+					return;
+				}
+				console.log();
+				console.log(`  \x1B[1mPath:\x1B[0m ${sitemap.path}`);
+				console.log(`  \x1B[1mType:\x1B[0m ${sitemap.type || "sitemap"}`);
+				console.log(`  \x1B[1mLast Submitted:\x1B[0m ${sitemap.lastSubmitted || "N/A"}`);
+				console.log(`  \x1B[1mLast Downloaded:\x1B[0m ${sitemap.lastDownloaded || "N/A"}`);
+				console.log(`  \x1B[1mPending:\x1B[0m ${sitemap.isPending ? "Yes" : "No"}`);
+				console.log(`  \x1B[1mErrors:\x1B[0m ${sitemap.errors || 0}`);
+				console.log(`  \x1B[1mWarnings:\x1B[0m ${sitemap.warnings || 0}`);
+				if (sitemap.contents?.length) {
+					console.log();
+					console.log("  \x1B[1mContents:\x1B[0m");
+					for (const c of sitemap.contents) console.log(`    ${c.type}: ${c.submitted} submitted, ${c.indexed} indexed`);
+				}
 			}
-			const endInput = await text({
-				message: "End date (YYYY-MM-DD)",
-				placeholder: (/* @__PURE__ */ new Date(Date.now() - 3 * 864e5)).toISOString().split("T")[0]
-			});
-			if (isCancel(endInput)) {
-				cancel("Cancelled");
-				process.exit(0);
+		}),
+		submit: defineCommand({
+			meta: {
+				name: "submit",
+				description: "Submit a sitemap to GSC"
+			},
+			args: {
+				site: {
+					type: "string",
+					alias: "s",
+					required: true,
+					description: "Site URL"
+				},
+				url: {
+					type: "positional",
+					required: true,
+					description: "Sitemap URL to submit"
+				}
+			},
+			async run({ args }) {
+				await (await createCommandContext({ needsAuth: true })).client.sitemaps.submit(args.site, args.url).catch((e) => {
+					logger.error(`Submit failed: ${e.message}`);
+					process.exit(1);
+				});
+				logger.success(`Submitted sitemap: ${args.url}`);
 			}
-			startDate = String(startInput) || (/* @__PURE__ */ new Date(Date.now() - 28 * 864e5)).toISOString().split("T")[0];
-			endDate = String(endInput) || (/* @__PURE__ */ new Date(Date.now() - 3 * 864e5)).toISOString().split("T")[0];
-		} else {
-			endDate = (/* @__PURE__ */ new Date(Date.now() - 3 * 864e5)).toISOString().split("T")[0];
-			startDate = (/* @__PURE__ */ new Date(Date.now() - 31 * 864e5)).toISOString().split("T")[0];
-		}
-		const rowLimit = Number.parseInt(String(args.limit), 10);
-		const format = String(args.format);
-		const builder = gsc.select(...dimensions).where(between(date, startDate, endDate)).limit(rowLimit);
-		if (!args.quiet) logger.info(`Querying ${siteUrl}...`);
-		const rows = [];
-		for await (const batch of client.query(siteUrl, builder)) {
-			rows.push(...batch);
-			if (!args.quiet) {
-				clearLine();
-				process.stdout.write(progressBar(rows.length, rowLimit, `${rows.length} rows`));
+		}),
+		delete: defineCommand({
+			meta: {
+				name: "delete",
+				description: "Delete a sitemap from GSC"
+			},
+			args: {
+				site: {
+					type: "string",
+					alias: "s",
+					required: true,
+					description: "Site URL"
+				},
+				url: {
+					type: "positional",
+					required: true,
+					description: "Sitemap URL to delete"
+				}
+			},
+			async run({ args }) {
+				await (await createCommandContext({ needsAuth: true })).client.sitemaps.delete(args.site, args.url).catch((e) => {
+					logger.error(`Delete failed: ${e.message}`);
+					process.exit(1);
+				});
+				logger.success(`Deleted sitemap: ${args.url}`);
 			}
+		})
+	}
+});
+const sitesCommand = defineCommand({
+	meta: {
+		name: "sites",
+		description: "List available GSC sites"
+	},
+	args: { json: {
+		type: "boolean",
+		default: false,
+		description: "Output as JSON for scripting"
+	} },
+	async run({ args }) {
+		const sites = await (await createCommandContext({ needsAuth: true })).loadSites();
+		if (args.json) {
+			console.log(JSON.stringify(sites, null, 2));
+			return;
+		}
+		if (sites.length === 0) {
+			logger.warn("No verified sites found");
+			return;
+		}
+		logger.success(`Found ${sites.length} 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`);
 		}
-		if (!args.quiet) {
-			clearLine();
-			logger.success(`Fetched ${rows.length} rows`);
-		}
-		const output = {
-			siteUrl,
-			dimensions: dimensions.map((d) => String(d)),
-			dateRange: {
-				start: startDate,
-				end: endDate
-			},
-			total: rows.length,
-			data: rows
-		};
-		const content = format === "csv" ? exportToCSV(output) : JSON.stringify(output, null, 2);
-		if (args.output) {
-			await fs.writeFile(String(args.output), content);
-			if (!args.quiet) logger.info(`Written to ${args.output}`);
-		} else console.log(content);
 	}
 });
-
-//#endregion
-//#region src/commands/sitemaps.ts
-const listCommand = defineCommand({
+const compactCommand = defineCommand({
 	meta: {
-		name: "list",
-		description: "List sitemaps for a site"
+		name: "compact",
+		description: "Run tiered compaction (raw→d7 at 7d, d7→d30 at 30d, d30→d90 at 90d)"
 	},
 	args: {
-		site: {
+		"site": {
 			type: "string",
 			alias: "s",
-			required: true,
-			description: "Site URL (e.g., sc-domain:example.com or https://example.com/)"
+			description: "Restrict to a single site (default: all sites with local data)"
 		},
-		json: {
+		"raw-days": {
+			type: "string",
+			description: "Override raw→d7 age threshold in days (default: 7)"
+		},
+		"d7-days": {
+			type: "string",
+			description: "Override d7→d30 age threshold in days (default: 30)"
+		},
+		"d30-days": {
+			type: "string",
+			description: "Override d30→d90 age threshold in days (default: 90)"
+		},
+		"quiet": {
 			type: "boolean",
+			alias: "q",
 			default: false,
-			description: "Output as JSON"
+			description: "Suppress progress output"
 		}
 	},
 	async run({ args }) {
-		const sitemaps = await fetchSitemaps(googleSearchConsole(await getAuth({ interactive: false })), args.site).catch(gscErrorHandler);
-		if (args.json) {
-			console.log(JSON.stringify(sitemaps, null, 2));
-			return;
-		}
-		if (sitemaps.length === 0) {
-			logger.warn("No sitemaps found");
-			return;
-		}
-		logger.success(`Found ${sitemaps.length} sitemaps:`);
-		console.log();
-		for (const sm of sitemaps) {
-			const pending = sm.isPending ? " \x1B[33m(pending)\x1B[0m" : "";
-			const errors = sm.errors ? ` \x1B[31m${sm.errors} errors\x1B[0m` : "";
-			const warnings = sm.warnings ? ` \x1B[33m${sm.warnings} warnings\x1B[0m` : "";
-			console.log(`  ${sm.path}${pending}${errors}${warnings}`);
+		const store = (await createCommandContext({ needsStore: true })).store;
+		const siteId = args.site ? store.siteIdFor(String(args.site)) : void 0;
+		const quiet = Boolean(args.quiet);
+		const thresholds = {};
+		if (args["raw-days"]) thresholds.raw = Number(args["raw-days"]);
+		if (args["d7-days"]) thresholds.d7 = Number(args["d7-days"]);
+		if (args["d30-days"]) thresholds.d30 = Number(args["d30-days"]);
+		for (const table of allTables()) {
+			const entries = await store.engine.listLive({
+				userId: store.userId,
+				siteId,
+				table
+			});
+			const siteIds = new Set(entries.map((e) => e.siteId));
+			for (const targetSite of siteIds) {
+				if (!quiet) logger.info(`Compacting ${table} [${targetSite ?? "-"}] (raw→d7→d30→d90)`);
+				await store.engine.compactTiered({
+					userId: store.userId,
+					siteId: targetSite,
+					table
+				}, thresholds);
+			}
 		}
+		if (!quiet) logger.success(`compact: done`);
 	}
 });
-const getCommand = defineCommand({
+async function exportToDuckDB(opts) {
+	const outPath = path.resolve(opts.outPath);
+	if (opts.force) await rm(outPath, { force: true });
+	const instance = await DuckDBInstance.create(outPath);
+	const conn = await instance.connect();
+	const tables = [];
+	try {
+		for (const table of allTables()) {
+			const entries = await opts.engine.listLive({
+				userId: opts.userId,
+				siteId: opts.siteId,
+				table
+			});
+			if (entries.length === 0) continue;
+			const fileList = entries.map((e) => path.join(opts.dataDir, e.objectKey)).map((p) => `'${sqlEscape(p)}'`).join(", ");
+			await conn.run(`CREATE OR REPLACE TABLE ${table} AS SELECT * FROM read_parquet([${fileList}], union_by_name=true)`);
+			const rows = (await conn.runAndReadAll(`SELECT count(*)::BIGINT AS n FROM ${table}`)).getRowObjects();
+			const rowCount = Number(rows[0]?.n ?? 0);
+			tables.push({
+				table,
+				files: entries.length,
+				rows: rowCount
+			});
+		}
+	} finally {
+		conn.closeSync();
+		instance.closeSync();
+	}
+	return {
+		outPath,
+		tables,
+		totalRows: tables.reduce((acc, t) => acc + t.rows, 0)
+	};
+}
+const exportCommand = defineCommand({
 	meta: {
-		name: "get",
-		description: "Get details for a specific sitemap"
+		name: "export",
+		description: "Pack live Parquet partitions into a single .duckdb file for portable distribution (browser attach, CDN serving, etc.)"
 	},
 	args: {
-		site: {
+		out: {
 			type: "string",
-			alias: "s",
 			required: true,
-			description: "Site URL"
+			description: "Output path for the .duckdb file"
 		},
-		url: {
-			type: "positional",
-			required: true,
-			description: "Sitemap URL"
+		site: {
+			type: "string",
+			description: "Limit export to a single site URL (omit to include all)"
 		},
-		json: {
+		force: {
 			type: "boolean",
 			default: false,
-			description: "Output as JSON"
+			description: "Overwrite the output file if it already exists"
 		}
 	},
 	async run({ args }) {
-		const sitemap = await fetchSitemap(googleSearchConsole(await getAuth({ interactive: false })), args.site, args.url).catch(gscErrorHandler);
-		if (args.json) {
-			console.log(JSON.stringify(sitemap, null, 2));
+		const store = (await createCommandContext({ needsStore: true })).store;
+		const siteId = args.site ? store.siteIdFor(args.site) : void 0;
+		const result = await exportToDuckDB({
+			engine: store.engine,
+			dataDir: store.dataDir,
+			userId: store.userId,
+			siteId,
+			outPath: args.out,
+			force: args.force
+		});
+		if (result.tables.length === 0) {
+			console.log(`\n  No data to export. Run \`gscdump sync\` first.`);
 			return;
 		}
-		console.log();
-		console.log(`  \x1B[1mPath:\x1B[0m ${sitemap.path}`);
-		console.log(`  \x1B[1mType:\x1B[0m ${sitemap.type || "sitemap"}`);
-		console.log(`  \x1B[1mLast Submitted:\x1B[0m ${sitemap.lastSubmitted || "N/A"}`);
-		console.log(`  \x1B[1mLast Downloaded:\x1B[0m ${sitemap.lastDownloaded || "N/A"}`);
-		console.log(`  \x1B[1mPending:\x1B[0m ${sitemap.isPending ? "Yes" : "No"}`);
-		console.log(`  \x1B[1mErrors:\x1B[0m ${sitemap.errors || 0}`);
-		console.log(`  \x1B[1mWarnings:\x1B[0m ${sitemap.warnings || 0}`);
-		if (sitemap.contents?.length) {
-			console.log();
-			console.log("  \x1B[1mContents:\x1B[0m");
-			for (const c of sitemap.contents) console.log(`    ${c.type}: ${c.submitted} submitted, ${c.indexed} indexed`);
-		}
+		for (const t of result.tables) console.log(`  ${t.table.padEnd(15)} ${String(t.files).padStart(4)} parquet → ${t.table}  (${t.rows.toLocaleString()} rows)`);
+		console.log(`\n  Exported ${result.tables.length} table(s), ${result.totalRows.toLocaleString()} rows → ${result.outPath}`);
+		console.log(`\n  Attach from DuckDB:     \x1B[36mATTACH '${result.outPath}' AS gsc (READ_ONLY); SELECT * FROM gsc.pages LIMIT 10;\x1B[0m`);
+		console.log(`  Attach in a browser:    use DuckDB-WASM registerFileBuffer + \x1B[36mATTACH 'gsc.duckdb' AS gsc (READ_ONLY)\x1B[0m`);
 	}
 });
-const submitCommand = defineCommand({
+const DEFAULT_GRACE_HOURS = 24;
+const gcCommand = defineCommand({
 	meta: {
-		name: "submit",
-		description: "Submit a sitemap to GSC"
+		name: "gc",
+		description: "Delete orphaned object-store files not referenced by any manifest entry"
 	},
 	args: {
-		site: {
+		"grace-hours": {
+			type: "string",
+			default: String(DEFAULT_GRACE_HOURS),
+			description: `Spare orphans younger than this (default: ${DEFAULT_GRACE_HOURS}h)`
+		},
+		"site": {
 			type: "string",
 			alias: "s",
-			required: true,
-			description: "Site URL"
+			description: "Restrict to a single site (default: all sites)"
 		},
-		url: {
-			type: "positional",
-			required: true,
-			description: "Sitemap URL to submit"
+		"quiet": {
+			type: "boolean",
+			alias: "q",
+			default: false,
+			description: "Suppress progress output"
 		}
 	},
 	async run({ args }) {
-		await submitSitemap(googleSearchConsole(await getAuth({ interactive: false })), args.site, args.url).catch(gscErrorHandler);
-		logger.success(`Submitted sitemap: ${args.url}`);
+		const store = (await createCommandContext({ needsStore: true })).store;
+		const siteId = args.site ? store.siteIdFor(String(args.site)) : void 0;
+		const quiet = Boolean(args.quiet);
+		const graceMs = Number(args["grace-hours"]) * 36e5;
+		const result = await store.engine.gcOrphans({
+			userId: store.userId,
+			siteId
+		}, graceMs);
+		if (!quiet) logger.success(`gc: deleted ${result.deleted} orphan file(s)`);
 	}
 });
-const deleteCommand = defineCommand({
+const rollupsCommand = defineCommand({
+	meta: {
+		name: "rollups",
+		description: "Manage post-sync rollups"
+	},
+	subCommands: { rebuild: defineCommand({
+		meta: {
+			name: "rebuild",
+			description: "Rebuild post-sync rollups (daily totals, weekly totals, top-N tables) for a site"
+		},
+		args: {
+			site: {
+				type: "string",
+				alias: "s",
+				description: "Restrict to a single site (default: all sites with local data)"
+			},
+			quiet: {
+				type: "boolean",
+				alias: "q",
+				default: false,
+				description: "Suppress progress output"
+			}
+		},
+		async run({ args }) {
+			const store = (await createCommandContext({ needsStore: true })).store;
+			const explicitSiteId = args.site ? store.siteIdFor(String(args.site)) : void 0;
+			const quiet = Boolean(args.quiet);
+			const allSiteIds = /* @__PURE__ */ new Set();
+			if (explicitSiteId) allSiteIds.add(explicitSiteId);
+			else for (const table of allTables()) {
+				const entries = await store.engine.listLive({
+					userId: store.userId,
+					table
+				});
+				for (const e of entries) if (e.siteId) allSiteIds.add(e.siteId);
+			}
+			if (allSiteIds.size === 0) {
+				logger.warn("No sites with local data. Run `gscdump sync` first.");
+				return;
+			}
+			let totalBytes = 0;
+			for (const siteId of allSiteIds) {
+				if (!quiet) logger.info(`Rebuilding rollups for [${siteId}] (${DEFAULT_ROLLUPS.length} rollups)`);
+				const results = await rebuildRollups({
+					engine: store.engine,
+					dataSource: store.dataSource,
+					ctx: {
+						userId: store.userId,
+						siteId
+					},
+					defs: DEFAULT_ROLLUPS
+				});
+				for (const r of results) {
+					totalBytes += r.bytes;
+					if (!quiet) console.log(`  ${r.id.padEnd(20)} ${(r.bytes / 1024).toFixed(1).padStart(8)} KB  ${r.objectKey}`);
+				}
+			}
+			if (!quiet) logger.success(`Rebuilt rollups across ${allSiteIds.size} site(s) — total ${(totalBytes / 1024).toFixed(1)} KB`);
+		}
+	}) }
+});
+const statsCommand = defineCommand({
 	meta: {
-		name: "delete",
-		description: "Delete a sitemap from GSC"
+		name: "stats",
+		description: "Show row/byte counts per table and on-disk footprint"
 	},
 	args: {
+		json: {
+			type: "boolean",
+			default: false,
+			description: "Output as JSON"
+		},
 		site: {
 			type: "string",
-			alias: "s",
-			required: true,
-			description: "Site URL"
-		},
-		url: {
-			type: "positional",
-			required: true,
-			description: "Sitemap URL to delete"
+			description: "Limit to one site URL (sc-domain:example.com, https://example.com/, ...)"
 		}
 	},
 	async run({ args }) {
-		await deleteSitemap(googleSearchConsole(await getAuth({ interactive: false })), args.site, args.url).catch(gscErrorHandler);
-		logger.success(`Deleted sitemap: ${args.url}`);
+		const store = (await createCommandContext({ needsStore: true })).store;
+		const siteId = args.site ? store.siteIdFor(args.site) : void 0;
+		const perTable = await Promise.all(allTables().map(async (table) => {
+			const all = await store.engine.listAll({
+				userId: store.userId,
+				siteId,
+				table
+			});
+			return {
+				table,
+				live: all.filter((e) => e.retiredAt === void 0),
+				retired: all.filter((e) => e.retiredAt !== void 0)
+			};
+		}));
+		const watermarks = await store.engine.getWatermarks({
+			userId: store.userId,
+			siteId
+		});
+		const disk = await filesystemStats(store.dataDir).catch(() => ({
+			files: 0,
+			bytes: 0
+		}));
+		if (args.json) {
+			const payload = {
+				dataDir: store.dataDir,
+				disk,
+				tables: perTable.map(({ table, live, retired }) => ({
+					table,
+					liveFiles: live.length,
+					liveRows: sumRows(live),
+					liveBytes: sumBytes(live),
+					retiredFiles: retired.length,
+					retiredBytes: sumBytes(retired),
+					watermarks: watermarks.filter((w) => w.table === table).map((w) => ({
+						siteId: w.siteId ?? null,
+						newestDateSynced: w.newestDateSynced,
+						oldestDateSynced: w.oldestDateSynced,
+						lastSyncAt: w.lastSyncAt
+					}))
+				}))
+			};
+			console.log(JSON.stringify(payload, null, 2));
+			return;
+		}
+		console.log();
+		console.log(`  \x1B[1m${store.dataDir}\x1B[0m`);
+		console.log(`  \x1B[90mDisk: ${disk.files} file(s), ${formatBytes(disk.bytes)}\x1B[0m`);
+		console.log();
+		const totalRows = perTable.reduce((acc, t) => acc + sumRows(t.live), 0);
+		const totalBytes = perTable.reduce((acc, t) => acc + sumBytes(t.live), 0);
+		const totalFiles = perTable.reduce((acc, t) => acc + t.live.length, 0);
+		const totalRetiredFiles = perTable.reduce((acc, t) => acc + t.retired.length, 0);
+		const totalRetiredBytes = perTable.reduce((acc, t) => acc + sumBytes(t.retired), 0);
+		for (const { table, live, retired } of perTable) {
+			const rows = sumRows(live).toLocaleString();
+			const bytes = formatBytes(sumBytes(live));
+			const retiredSuffix = retired.length > 0 ? ` \x1B[90m(+${retired.length} retired, ${formatBytes(sumBytes(retired))})\x1B[0m` : "";
+			console.log(`  ${table.padEnd(15)} \x1B[36m${String(live.length).padStart(4)}\x1B[0m files, ${rows.padStart(10)} rows, ${bytes}${retiredSuffix}`);
+		}
+		console.log();
+		console.log(`  \x1B[1mTotal:\x1B[0m ${totalFiles} files, ${totalRows.toLocaleString()} rows, ${formatBytes(totalBytes)} live`);
+		if (totalRetiredFiles > 0) console.log(`  \x1B[90mRetired: ${totalRetiredFiles} files, ${formatBytes(totalRetiredBytes)} awaiting GC\x1B[0m`);
+		if (watermarks.length > 0) {
+			console.log();
+			console.log(`  \x1B[1mSync watermarks:\x1B[0m`);
+			for (const w of sortWatermarks(watermarks)) {
+				const scope = w.siteId ? `${w.table}@${w.siteId}` : w.table;
+				console.log(`  ${scope.padEnd(24)} \x1B[36m${w.oldestDateSynced}\x1B[0m → \x1B[36m${w.newestDateSynced}\x1B[0m  \x1B[90m(last ${formatAge(w.lastSyncAt)})\x1B[0m`);
+			}
+		}
+		console.log();
 	}
 });
-const sitemapsCommand = defineCommand({
+function sortWatermarks(ws) {
+	return [...ws].sort((a, b) => {
+		if (a.table !== b.table) return a.table.localeCompare(b.table);
+		return (a.siteId ?? "").localeCompare(b.siteId ?? "");
+	});
+}
+function sumRows(entries) {
+	return entries.reduce((acc, e) => acc + e.rowCount, 0);
+}
+function sumBytes(entries) {
+	return entries.reduce((acc, e) => acc + e.bytes, 0);
+}
+function formatBytes(n) {
+	if (n < 1024) return `${n} B`;
+	if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+	if (n < 1024 * 1024 * 1024) return `${(n / 1024 / 1024).toFixed(1)} MB`;
+	return `${(n / 1024 / 1024 / 1024).toFixed(2)} GB`;
+}
+const storeCommand = defineCommand({
 	meta: {
-		name: "sitemaps",
-		description: "Manage sitemaps"
+		name: "store",
+		description: "Manage the local DuckDB/Parquet store"
 	},
 	subCommands: {
-		list: listCommand,
-		get: getCommand,
-		submit: submitCommand,
-		delete: deleteCommand
+		stats: statsCommand,
+		compact: compactCommand,
+		gc: gcCommand,
+		export: exportCommand,
+		rollups: rollupsCommand
 	}
 });
-
-//#endregion
-//#region src/commands/sites.ts
-const sitesCommand = defineCommand({
+const DEFAULT_TABLES = [
+	"pages",
+	"keywords",
+	"countries",
+	"devices"
+];
+const DEFAULT_TYPES = ["web"];
+const ALL_SEARCH_TYPES = Object.values(SearchTypes);
+const DEFAULT_PENDING_DAYS = 3;
+const DEFAULT_CONCURRENCY = 8;
+const EMPTY_TYPE_PROBE_MIN_DAYS = 7;
+const EMPTY_TYPE_PROTECTED = ["web"];
+function createProgressTracker(total, quiet) {
+	if (quiet) return {
+		tick: () => {},
+		done: () => {}
+	};
+	let current = 0;
+	let lastLabel = "";
+	let timer = null;
+	const render = () => {
+		clearLine();
+		process.stdout.write(progressBar(current, total, lastLabel));
+	};
+	timer = setInterval(render, 100);
+	return {
+		tick: (label) => {
+			current++;
+			lastLabel = label;
+		},
+		done: () => {
+			if (timer) {
+				clearInterval(timer);
+				timer = null;
+			}
+			clearLine();
+		}
+	};
+}
+async function syncTable(store, siteUrl, table, searchType, dates, client, concurrency, force, progress) {
+	const dims = TABLE_DIMS[table];
+	const siteId = store.siteIdFor(siteUrl);
+	let totalRows = 0;
+	let skipped = 0;
+	let failed = 0;
+	const priorStates = await store.engine.getSyncStates({
+		userId: store.userId,
+		siteId,
+		table,
+		searchType
+	});
+	const stateByDate = new Map(priorStates.map((s) => [s.date, s]));
+	const label = searchType === "web" ? table : `${table}/${searchType}`;
+	await runWithConcurrency(dates, concurrency, async (date) => {
+		const prior = stateByDate.get(date);
+		if (!force && prior?.state === "done") {
+			skipped++;
+			progress.tick(`${label} ${date} (skip)`);
+			return;
+		}
+		const scope = {
+			userId: store.userId,
+			siteId,
+			table,
+			date,
+			searchType
+		};
+		await store.engine.setSyncState(scope, "inflight");
+		const result = await runOneDate(store, client, siteUrl, table, searchType, dims, date).catch((err) => ({
+			kind: "error",
+			error: err
+		}));
+		if (result.kind === "error") {
+			await store.engine.setSyncState(scope, "failed", { error: result.error.message });
+			failed++;
+			progress.tick(`${label} ${date} (fail)`);
+			return;
+		}
+		await store.engine.setSyncState(scope, "done");
+		totalRows += result.rows;
+		progress.tick(`${label} ${date}`);
+	});
+	return {
+		rows: totalRows,
+		skipped,
+		failed
+	};
+}
+async function runOneDate(store, client, siteUrl, table, searchType, dims, date) {
+	const rowLimit = 25e3;
+	const rows = [];
+	let startRow = 0;
+	while (true) {
+		const batch = (await client._rawQuery(siteUrl, {
+			startDate: date,
+			endDate: date,
+			dimensions: dims,
+			searchType,
+			rowLimit,
+			startRow
+		})).rows || [];
+		for (const apiRow of batch) {
+			const transformed = transformGscRow(table, {
+				keys: apiRow.keys ?? [],
+				clicks: apiRow.clicks ?? 0,
+				impressions: apiRow.impressions ?? 0,
+				ctr: apiRow.ctr ?? 0,
+				position: apiRow.position ?? 0
+			});
+			if (transformed) rows.push(transformed.row);
+		}
+		if (batch.length < rowLimit) break;
+		startRow += batch.length;
+	}
+	const writeCtx = {
+		userId: store.userId,
+		siteId: store.siteIdFor(siteUrl),
+		table,
+		date,
+		searchType
+	};
+	await store.engine.writeDay(writeCtx, rows);
+	return {
+		kind: "ok",
+		rows: rows.length
+	};
+}
+const syncCommand = defineCommand({
 	meta: {
-		name: "sites",
-		description: "List available GSC sites"
+		name: "sync",
+		description: "Sync GSC data to local Parquet store"
+	},
+	args: {
+		"site": {
+			type: "string",
+			alias: "s",
+			description: "Site URL"
+		},
+		"start": {
+			type: "string",
+			description: "Start date (YYYY-MM-DD) for historical sync"
+		},
+		"end": {
+			type: "string",
+			description: "End date (YYYY-MM-DD); defaults to 3 days ago"
+		},
+		"days": {
+			type: "string",
+			description: `Number of days back to sync (default: ${DEFAULT_PENDING_DAYS})`
+		},
+		"tables": {
+			type: "string",
+			alias: "t",
+			description: `Tables to sync (default: ${DEFAULT_TABLES.join(",")}); comma-separated`
+		},
+		"types": {
+			type: "string",
+			description: `GSC search types to sync (default: ${DEFAULT_TYPES.join(",")}); comma-separated. Allowed: ${ALL_SEARCH_TYPES.join(",")}.`
+		},
+		"force-types": {
+			type: "boolean",
+			default: false,
+			description: "Ignore stored empty-type markers and re-probe every requested type"
+		},
+		"no-rollups": {
+			type: "boolean",
+			default: false,
+			description: "Skip the post-sync rollup rebuild (daily/weekly totals, top-N tables)"
+		},
+		"full": {
+			type: "boolean",
+			description: "Sync the last 450 days (full GSC history)"
+		},
+		"quiet": {
+			type: "boolean",
+			alias: "q",
+			default: false,
+			description: "Suppress progress output"
+		},
+		"force": {
+			type: "boolean",
+			default: false,
+			description: "Re-sync dates already marked done (default: skip them for idempotent resume)"
+		},
+		"status": {
+			type: "boolean",
+			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",
+			description: `Concurrent in-flight day fetches per table (default: ${DEFAULT_CONCURRENCY})`
+		},
+		"serial-tables": {
+			type: "boolean",
+			default: false,
+			description: "Run tables sequentially (default: run all tables in parallel)"
+		}
 	},
-	args: { json: {
-		type: "boolean",
-		default: false,
-		description: "Output as JSON for scripting"
-	} },
 	async run({ args }) {
-		const sites = (await fetchSites(googleSearchConsole(await getAuth({ interactive: false }))).catch(gscErrorHandler)).filter((site) => site.siteUrl && site.permissionLevel !== "siteUnverifiedUser").map((site) => ({
-			url: site.siteUrl,
-			permission: site.permissionLevel || "unknown"
-		}));
-		if (args.json) {
-			console.log(JSON.stringify(sites, null, 2));
+		if (args.status) {
+			await printSyncStatus(await loadConfig(), args.site ? String(args.site) : void 0, Boolean(args.json));
 			return;
 		}
-		if (sites.length === 0) {
-			logger.warn("No verified sites found");
+		const ctx = await createCommandContext({
+			needsAuth: true,
+			needsStore: true
+		});
+		const client = ctx.client;
+		const siteUrl = await ctx.resolveSite(args.site ? String(args.site) : void 0);
+		const tables = args.tables ? String(args.tables).split(",").map((t) => t.trim()).filter(isKnownTable) : DEFAULT_TABLES;
+		const requestedTypes = args.types ? String(args.types).split(",").map((t) => t.trim()).filter(isKnownSearchType) : DEFAULT_TYPES;
+		if (requestedTypes.length === 0) {
+			logger.error(`No valid search types specified. Allowed: ${ALL_SEARCH_TYPES.join(",")}`);
+			process.exit(1);
+		}
+		const siteId = ctx.store.siteIdFor(siteUrl);
+		const emptyTypesStore = createEmptyTypesStore({ dataSource: ctx.store.dataSource });
+		const emptyTypesDoc = await emptyTypesStore.load({
+			userId: ctx.store.userId,
+			siteId
+		});
+		const forceTypes = Boolean(args["force-types"]);
+		const skippedTypes = [];
+		const types = [];
+		for (const t of requestedTypes) {
+			if (!forceTypes && emptyTypesDoc.emptyTypes.includes(t) && !EMPTY_TYPE_PROTECTED.includes(t)) {
+				skippedTypes.push(t);
+				continue;
+			}
+			types.push(t);
+		}
+		if (types.length === 0) {
+			logger.warn(`All requested types (${requestedTypes.join(", ")}) are marked empty for this site. Pass --force-types to re-probe.`);
 			return;
 		}
-		logger.success(`Found ${sites.length} sites:`);
-		console.log();
-		for (const site of sites) {
-			const perm = site.permission === "siteOwner" ? "\x1B[32m" : "\x1B[90m";
-			console.log(`  ${site.url} ${perm}(${site.permission})\x1B[0m`);
+		if (skippedTypes.length > 0 && !args.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);
+		else if (args.full) startDate = daysAgo(450);
+		else if (args.days) startDate = daysAgo(Number.parseInt(String(args.days), 10) + DEFAULT_PENDING_DAYS - 1);
+		else startDate = daysAgo(DEFAULT_PENDING_DAYS + DEFAULT_PENDING_DAYS - 1);
+		const dates = getDateRange(startDate, endDate);
+		if (dates.length === 0) {
+			logger.error(`No dates to sync (start=${startDate}, end=${endDate})`);
+			process.exit(1);
+		}
+		const store = ctx.store;
+		if (!args.quiet) {
+			logger.info(`Syncing ${siteUrl} (${tables.join(", ")}) [${types.join(", ")}] → ${store.dataDir}`);
+			logger.info(`Range: ${startDate} → ${endDate} (${dates.length} days)`);
+		}
+		const concurrency = args.concurrency ? Math.max(1, Number.parseInt(String(args.concurrency), 10) || DEFAULT_CONCURRENCY) : DEFAULT_CONCURRENCY;
+		const serialTables = Boolean(args["serial-tables"]);
+		const start = Date.now();
+		const totals = {};
+		const jobs = [];
+		for (const table of tables) for (const type of types) {
+			const label = type === "web" ? table : `${table}/${type}`;
+			jobs.push({
+				table,
+				type,
+				label
+			});
+		}
+		const progress = createProgressTracker(dates.length * jobs.length, Boolean(args.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)));
+			jobs.forEach((job, i) => {
+				totals[job.label] = results[i];
+			});
+		}
+		progress.done();
+		const seconds = ((Date.now() - start) / 1e3).toFixed(1);
+		if (!args.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(", ");
+				const tail = suffix ? ` (${suffix})` : "";
+				console.log(`  ${t}: ${n.rows.toLocaleString()} rows${tail}`);
+			}
+			console.log();
+		}
+		const anyFailed = Object.values(totals).some((t) => t.failed > 0);
+		const rowsByType = /* @__PURE__ */ new Map();
+		const failedByType = /* @__PURE__ */ new Map();
+		for (const job of jobs) {
+			const t = totals[job.label];
+			rowsByType.set(job.type, (rowsByType.get(job.type) ?? 0) + t.rows);
+			failedByType.set(job.type, (failedByType.get(job.type) ?? 0) + t.failed);
+		}
+		if (!forceTypes && dates.length >= EMPTY_TYPE_PROBE_MIN_DAYS) {
+			const toMark = [];
+			for (const type of types) {
+				if (EMPTY_TYPE_PROTECTED.includes(type)) continue;
+				if ((failedByType.get(type) ?? 0) > 0) continue;
+				if ((rowsByType.get(type) ?? 0) === 0) toMark.push(type);
+			}
+			if (toMark.length > 0) {
+				await emptyTypesStore.mark({
+					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 (forceTypes && emptyTypesDoc.emptyTypes.length > 0) {
+			const toClear = [];
+			for (const type of types) if (emptyTypesDoc.emptyTypes.includes(type) && (rowsByType.get(type) ?? 0) > 0) toClear.push(type);
+			if (toClear.length > 0) {
+				await emptyTypesStore.clear({
+					userId: store.userId,
+					siteId
+				}, toClear);
+				if (!args.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)…`);
+			const rollupStart = Date.now();
+			const results = await rebuildRollups({
+				engine: store.engine,
+				dataSource: store.dataSource,
+				ctx: {
+					userId: store.userId,
+					siteId
+				},
+				defs: DEFAULT_ROLLUPS
+			}).catch((err) => {
+				logger.warn(`Rollup rebuild failed: ${err.message}`);
+				return [];
+			});
+			if (!args.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`);
+			}
+		}
+		if (anyFailed) process.exit(1);
 	}
 });
-
-//#endregion
-//#region src/index.ts
+function isKnownTable(name) {
+	return allTables().includes(name);
+}
+function isKnownSearchType(name) {
+	return ALL_SEARCH_TYPES.includes(name);
+}
+async function printSyncStatus(config, siteFilter, asJson) {
+	const store = createLocalStore({ dataDir: resolveDataDir(config) });
+	const siteId = siteFilter ? store.siteIdFor(siteFilter) : void 0;
+	const watermarks = await store.engine.getWatermarks({
+		userId: store.userId,
+		siteId
+	});
+	const states = await store.engine.getSyncStates({
+		userId: store.userId,
+		siteId
+	});
+	const failed = states.filter((s) => s.state === "failed");
+	const inflight = states.filter((s) => s.state === "inflight");
+	if (asJson) {
+		console.log(JSON.stringify({
+			dataDir: store.dataDir,
+			siteFilter: siteFilter ?? null,
+			watermarks,
+			failed,
+			inflight
+		}, null, 2));
+		return;
+	}
+	console.log();
+	console.log(`  \x1B[1m${store.dataDir}\x1B[0m`);
+	if (siteFilter) console.log(`  \x1B[90mSite: ${siteFilter}\x1B[0m`);
+	console.log();
+	if (watermarks.length === 0) {
+		console.log(`  No sync watermarks. Run \`gscdump sync\` to ingest data.`);
+		console.log();
+		return;
+	}
+	console.log(`  \x1B[1mWatermarks:\x1B[0m`);
+	const sorted = [...watermarks].sort((a, b) => {
+		if (a.table !== b.table) return a.table.localeCompare(b.table);
+		return (a.siteId ?? "").localeCompare(b.siteId ?? "");
+	});
+	for (const w of sorted) {
+		const scope = w.siteId ? `${w.table}@${w.siteId}` : w.table;
+		console.log(`  ${scope.padEnd(28)} \x1B[36m${w.oldestDateSynced}\x1B[0m → \x1B[36m${w.newestDateSynced}\x1B[0m  \x1B[90m(last ${formatAge(w.lastSyncAt)})\x1B[0m`);
+	}
+	if (inflight.length > 0) {
+		console.log();
+		console.log(`  \x1B[33m${inflight.length} inflight:\x1B[0m`);
+		for (const s of inflight) console.log(`    ${s.table}${s.siteId ? `@${s.siteId}` : ""} ${s.date} (attempt ${s.attempts}, started ${formatAge(s.updatedAt)})`);
+	}
+	if (failed.length > 0) {
+		console.log();
+		console.log(`  \x1B[31m${failed.length} failed:\x1B[0m`);
+		for (const s of failed) console.log(`    ${s.table}${s.siteId ? `@${s.siteId}` : ""} ${s.date}: ${s.error ?? "unknown"}`);
+		console.log();
+		console.log(`  Re-run \`gscdump sync --force\` to retry failed dates.`);
+	}
+	console.log();
+}
 runMain(defineCommand({
 	meta: {
 		name: "gscdump",
@@ -1662,6 +2805,11 @@ runMain(defineCommand({
 		query: queryCommand,
 		sites: sitesCommand,
 		sitemaps: sitemapsCommand,
+		sync: syncCommand,
+		store: storeCommand,
+		inspect: inspectCommand,
+		entities: entitiesCommand,
+		analyze: analyzeCommand,
 		auth: authCommand,
 		config: configCommand,
 		mcp: mcpCommand
@@ -1670,6 +2818,4 @@ runMain(defineCommand({
 		if (!process.argv.includes("mcp")) showSplash();
 	}
 }));
-
-//#endregion
-export { getAuth as a, loadTokens as c, clearTokens as i, saveCloudTokens as l, authenticateCloud as n, getAuthCredentials as o, clearCloudTokens as r, loadCloudTokens as s, authenticate as t, saveTokens as u };
+export {};