npm - @gscdump/cli - Versions diffs - 0.4.0 → 0.6.2 - Mend

@gscdump/cli 0.4.0 → 0.6.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/index.mjs CHANGED Viewed

@@ -1,38 +1,102 @@
 #!/usr/bin/env node
-import process$1 from "node:process";
+import process from "node:process";
 import { defineCommand, runMain } from "citty";
-import { cancel, confirm, isCancel, multiselect, select, text } from "@clack/prompts";
-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 { OAuth2Client } from "google-auth-library";
-import { consola } from "consola";
-import { batchInspectUrls, batchRequestIndexing, deleteSitemap, fetchSitemap, fetchSitemaps, fetchSites, fetchSitesWithSitemaps, formatErrorForCli, getIndexingMetadata, googleSearchConsole, inspectUrl, requestIndexing, submitSitemap } from "gscdump";
 import os from "node:os";
-import { between, country, date, device, gsc, page, query, searchAppearance } from "gscdump/query";
+import { consola } from "consola";
+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 src/utils.ts
+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";
+	}
+};
+var LocalStoreEmptyError = class extends Error {
+	constructor(siteUrl) {
+		super(`no local data synced for ${siteUrl} (run \`gscdump sync\` first)`);
+		this.name = "LocalStoreEmptyError";
+	}
+};
+async function hasLocalData(store, siteUrl) {
+	return (await store.engine.listLive({
+		userId: store.userId,
+		siteId: store.siteIdFor(siteUrl)
+	})).length > 0;
+}
+async function runLocalAnalysis(store, siteUrl, params) {
+	return analyzeFromSource(createEngineQuerySource({
+		engine: store.engine,
+		ctx: {
+			userId: store.userId,
+			siteId: store.siteIdFor(siteUrl)
+		}
+	}), params, defaultAnalyzerRegistry).catch((e) => {
+		if (e instanceof AnalyzerCapabilityError) throw new LocalStoreUnsupportedError(params.type);
+		throw e;
+	});
+}
+async function runLiveAnalysis(client, siteUrl, params) {
+	return analyzeFromSource(createGscApiQuerySource({
+		client,
+		siteUrl
+	}), params, defaultAnalyzerRegistry).catch((e) => {
+		if (e instanceof AnalyzerCapabilityError) throw new LocalStoreUnsupportedError(params.type);
+		throw e;
+	});
+}
+let configDir = path.join(os.homedir(), ".config", "gscdump");
+function getConfigDir() {
+	return configDir;
+}
+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(() => ({}));
+}
+async function saveConfig(config) {
+	await fs.mkdir(configDir, {
+		recursive: true,
+		mode: 448
+	});
+	await fs.writeFile(path.join(configDir, "config.json"), JSON.stringify(config, null, 2), { mode: 384 });
+}
+function getConfigPath() {
+	return path.join(configDir, "config.json");
+}
 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$1.exit(1);
-}
-/**
-* Creates a .catch() handler for GSC API errors.
-* Use: somePromise.catch(gscErrorHandler)
-*/
-function gscErrorHandler(error) {
-	return handleGscError(error);
+	process.exit(1);
 }
 const gradientColors = [
 	(s) => `\x1B[38;2;52;211;153m${s}\x1B[0m`,
@@ -41,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("");
 }
@@ -52,14 +116,26 @@ 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$1.stdout.write("\r\x1B[K");
+	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) => {
@@ -101,104 +177,7 @@ function exportToCSV(output) {
 	])}`);
 	return sections.join("\n\n");
 }
-//#endregion
-//#region src/cloud.ts
-async function cloudFetch(url, options) {
-	const res = await fetch(url, options);
-	if (res.status === 401) {
-		logger.error("CLI session expired or revoked. Run gscdump init --force to re-authenticate.");
-		process$1.exit(1);
-	}
-	if (!res.ok) {
-		const body = await res.json().catch(() => ({ message: res.statusText }));
-		throw new Error(body.message || `HTTP ${res.status}: ${res.statusText}`);
-	}
-	return res.json();
-}
-function buildUrl(base, path$1, query$1) {
-	const url = new URL(path$1, base);
-	if (query$1) {
-		for (const [k, v] of Object.entries(query$1)) if (v !== void 0 && v !== "") url.searchParams.set(k, v);
-	}
-	return url.toString();
-}
-function createCloudClient(cloudUrl, sessionId) {
-	const headers = {
-		"x-cli-session": sessionId,
-		"content-type": "application/json"
-	};
-	return {
-		me: () => cloudFetch(buildUrl(cloudUrl, "/api/cli/me"), { headers }),
-		availableSites: () => cloudFetch(buildUrl(cloudUrl, "/api/cli/sites/available"), { headers }),
-		registerSite: (siteUrl) => cloudFetch(buildUrl(cloudUrl, "/api/sites/register"), {
-			method: "POST",
-			headers,
-			body: JSON.stringify({ siteUrl })
-		}),
-		syncStatus: (siteId) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}/sync-status`), { headers }),
-		data: (siteId, params) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}/data`, params), { headers }),
-		sitemaps: (siteId) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}/sitemaps`), { headers }),
-		analysis: (siteId, tool, params) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}/analysis/${tool}`, params), { headers }),
-		query: (siteId, params) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}/query`, params), { headers }),
-		indexing: (siteId, params) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}/indexing`, params), { headers }),
-		indexingDiagnostics: (siteId) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}/indexing/diagnostics`), { headers }),
-		indexingUrls: (siteId, params) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}/indexing/urls`, params), { headers }),
-		indexPercent: (siteId, params) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}/index-percent`, params), { headers }),
-		sitemapAction: (siteId, body) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}/sitemaps`), {
-			method: "POST",
-			headers,
-			body: JSON.stringify(body)
-		}),
-		triggerSync: (siteId) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}/sync`), {
-			method: "POST",
-			headers
-		}),
-		deleteSite: (siteId) => cloudFetch(buildUrl(cloudUrl, `/api/sites/${siteId}`), {
-			method: "DELETE",
-			headers
-		}),
-		bulkRegister: (siteUrls) => cloudFetch(buildUrl(cloudUrl, "/api/sites/bulk-register"), {
-			method: "POST",
-			headers,
-			body: JSON.stringify({ siteUrls })
-		}),
-		analysisPost: (siteId, body) => cloudFetch(buildUrl(cloudUrl, `/api/cli/sites/${siteId}/analysis`), {
-			method: "POST",
-			headers,
-			body: JSON.stringify(body)
-		}),
-		detail: (siteId, body) => cloudFetch(buildUrl(cloudUrl, `/api/cli/sites/${siteId}/detail`), {
-			method: "POST",
-			headers,
-			body: JSON.stringify(body)
-		})
-	};
-}
-//#endregion
-//#region src/config.ts
-let configDir = path.join(os.homedir(), ".config", "gscdump");
-function getConfigDir() {
-	return configDir;
-}
-const DEFAULT_CLOUD_URL = "https://cloud.gscdump.com";
-async function loadConfig() {
-	return fs.readFile(path.join(configDir, "config.json"), "utf-8").then((data) => JSON.parse(data)).catch(() => ({}));
-}
-async function saveConfig(config) {
-	await fs.mkdir(configDir, {
-		recursive: true,
-		mode: 448
-	});
-	await fs.writeFile(path.join(configDir, "config.json"), JSON.stringify(config, null, 2), { mode: 384 });
-}
-function getConfigPath() {
-	return path.join(configDir, "config.json");
-}
-//#endregion
-//#region src/auth.ts
+const REDIRECT_URI_RE = /redirect_uri=[^&]+/;
 function getTokensPath() {
 	return path.join(getConfigDir(), "tokens.json");
 }
@@ -217,8 +196,8 @@ async function clearTokens() {
 	logger.success("Logged out, tokens cleared");
 }
 async function getAuthCredentials(interactive) {
-	const envClientId = process$1.env.GOOGLE_CLIENT_ID;
-	const envClientSecret = process$1.env.GOOGLE_CLIENT_SECRET;
+	const envClientId = process.env.GOOGLE_CLIENT_ID;
+	const envClientSecret = process.env.GOOGLE_CLIENT_SECRET;
 	if (envClientId && envClientSecret) {
 		logger.success("Using OAuth2 credentials from environment");
 		return {
@@ -233,7 +212,7 @@ async function getAuthCredentials(interactive) {
 	};
 	if (!interactive) {
 		logger.error("GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET required for non-interactive mode");
-		process$1.exit(1);
+		process.exit(1);
 	}
 	console.log();
 	console.log("  \x1B[1mOAuth 2.0 Setup Required\x1B[0m");
@@ -250,12 +229,12 @@ async function getAuthCredentials(interactive) {
 		placeholder: "your-client-id.googleusercontent.com",
 		validate: (v) => v ? void 0 : "Required"
 	});
-	if (isCancel(clientIdResult)) process$1.exit(1);
+	if (isCancel(clientIdResult)) process.exit(1);
 	const clientSecretResult = await text({
 		message: "Enter your Google OAuth Client Secret:",
 		validate: (v) => v ? void 0 : "Required"
 	});
-	if (isCancel(clientSecretResult)) process$1.exit(1);
+	if (isCancel(clientSecretResult)) process.exit(1);
 	console.log();
 	logger.info("Tip: Set GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET env vars to skip prompts");
 	return {
@@ -297,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`);
@@ -316,8 +295,8 @@ async function getAuthCodeViaLoopback(authUrl) {
 }
 async function authenticate(credentials, interactive) {
 	const oauth2Client = new OAuth2Client(credentials.clientId, credentials.clientSecret, "http://127.0.0.1");
-	const envAccessToken = process$1.env.GOOGLE_ACCESS_TOKEN;
-	const envRefreshToken = process$1.env.GOOGLE_REFRESH_TOKEN;
+	const envAccessToken = process.env.GOOGLE_ACCESS_TOKEN;
+	const envRefreshToken = process.env.GOOGLE_REFRESH_TOKEN;
 	if (envAccessToken || envRefreshToken) {
 		oauth2Client.setCredentials({
 			access_token: envAccessToken,
@@ -347,7 +326,7 @@ async function authenticate(credentials, interactive) {
 	}
 	if (!interactive) {
 		logger.error("No saved tokens. Run interactively first to authenticate.");
-		process$1.exit(1);
+		process.exit(1);
 	}
 	const authUrl = oauth2Client.generateAuthUrl({
 		access_type: "offline",
@@ -362,207 +341,73 @@ 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 clearCloudTokens() {
-	await fs.rm(getCloudTokensPath()).catch(() => {});
-	logger.success("Logged out from cloud");
-}
-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$1.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$1.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,
-				sessionId: pollRes.sessionId,
-				user: pollRes.user
-			});
-			if (pollRes.user?.email) logger.success(`Authenticated as ${pollRes.user.email}`);
-			else 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");
-			process$1.exit(1);
-		}
-	}
-	logger.error("Authorization timed out");
-	process$1.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.");
-			process$1.exit(1);
-		}
-		logger.warn("GSCDump not configured");
-		logger.info("Run: gscdump init");
-		process$1.exit(1);
-	}
-	if (config.mode === "cloud") return authenticateCloud(config.cloudUrl || DEFAULT_CLOUD_URL, interactive);
+	const { interactive = true } = opts;
 	return authenticate(await getAuthCredentials(interactive), interactive);
 }
-async function getCloudClient() {
-	const config = await loadConfig();
-	if (config.mode !== "cloud") return null;
-	const tokens = await loadCloudTokens();
-	if (!tokens?.sessionId) return null;
-	return createCloudClient(config.cloudUrl || DEFAULT_CLOUD_URL, tokens.sessionId);
+function createLocalStore(opts) {
+	return createNodeHarness(opts);
 }
-//#endregion
-//#region src/commands/analysis.ts
-const ANALYSIS_TOOLS = [
-	"striking-distance",
-	"opportunity",
-	"movers",
-	"decay",
-	"zero-click",
-	"brand",
-	"cannibalization",
-	"clustering",
-	"concentration",
-	"seasonality"
-];
-async function resolveSiteId(cloud, siteUrl) {
+async function createCommandContext(opts = {}) {
+	const { needsAuth = false, needsStore = false, interactive = false } = opts;
 	const config = await loadConfig();
-	const target = siteUrl || config.defaultSite;
-	const me = await cloud.me().catch((e) => {
-		logger.error(`Failed to fetch profile: ${e.message}`);
-		process$1.exit(1);
-	});
-	if (me.sites.length === 0) {
-		logger.error("No registered sites. Run gscdump register first.");
-		process$1.exit(1);
-	}
-	const match = target ? me.sites.find((s) => s.siteUrl === target || s.siteUrl.includes(target)) : void 0;
-	if (match) return match.siteId;
-	if (me.sites.length === 1) return me.sites[0].siteId;
-	const selected = await select({
-		message: "Select a site",
-		options: me.sites.map((s) => ({
-			value: s.siteId,
-			label: s.siteUrl
-		}))
-	});
-	if (isCancel(selected)) {
-		cancel("Cancelled");
-		process$1.exit(0);
-	}
-	return selected;
-}
-function extractResults(data) {
-	if (Array.isArray(data.results)) return {
-		results: data.results,
-		total: data.meta?.total ?? data.results.length
-	};
-	if (Array.isArray(data.keywords)) return {
-		results: data.keywords,
-		total: data.totalCount ?? data.keywords.length
+	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);
+		})).filter((s) => s.siteUrl && s.permissionLevel !== "siteUnverifiedUser").map((s) => ({
+			siteUrl: s.siteUrl,
+			permissionLevel: s.permissionLevel || "unknown"
+		}));
 	};
-	if (Array.isArray(data.clusters)) {
-		const clusters = data.clusters;
-		return {
-			results: clusters,
-			total: data.meta?.totalClusters ?? clusters.length
-		};
-	}
-	if (Array.isArray(data.rising)) {
-		const rows = [...data.rising.map((r) => ({
-			...r,
-			direction: "rising"
-		})), ...(data.declining || []).map((r) => ({
-			...r,
-			direction: "declining"
-		}))];
-		return {
-			results: rows,
-			total: rows.length
-		};
-	}
-	if (Array.isArray(data.brand)) {
-		const rows = [...data.brand.map((r) => ({
-			...r,
-			segment: "brand"
-		})), ...(data.nonBrand || []).map((r) => ({
-			...r,
-			segment: "non-brand"
-		}))];
-		return {
-			results: rows,
-			total: rows.length
-		};
-	}
-	if (Array.isArray(data.monthlyBreakdown)) return {
-		results: data.monthlyBreakdown,
-		total: data.monthlyBreakdown.length
+	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);
+		}
+		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;
 	};
-	if (data.giniCoefficient !== void 0) {
-		const { meta: _m, ...rest } = data;
-		return {
-			results: [rest],
-			total: 1
-		};
-	}
 	return {
-		results: [],
-		total: 0
+		config,
+		auth,
+		client,
+		store,
+		loadSites,
+		resolveSite
 	};
 }
+const ANALYSIS_TOOLS = defaultAnalyzerRegistry.listAnalyzerIds();
 const TOOL_EXTRA_ARGS = {
-	"brand": { "brand-terms": {
+	brand: { "brand-terms": {
 		type: "string",
 		description: "Comma-separated brand terms (required)"
 	} },
-	"movers": {
+	movers: {
 		"prev-start": {
 			type: "string",
 			description: "Previous period start date (required)"
@@ -572,7 +417,7 @@ const TOOL_EXTRA_ARGS = {
 			description: "Previous period end date (required)"
 		}
 	},
-	"decay": {
+	decay: {
 		"prev-start": {
 			type: "string",
 			description: "Previous period start date (required)"
@@ -582,33 +427,49 @@ const TOOL_EXTRA_ARGS = {
 			description: "Previous period end date (required)"
 		}
 	},
-	"concentration": { dimension: {
+	concentration: { dimension: {
 		type: "string",
 		description: "Dimension: pages or keywords (default: pages)"
 	} },
-	"seasonality": { metric: {
+	seasonality: { metric: {
 		type: "string",
 		description: "Metric: clicks or impressions (default: clicks)"
 	} },
-	"clustering": { "cluster-by": {
+	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)"
+		}
+	}
 };
-function buildBody(tool, args) {
-	const body = {
+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"]) body.brandTerms = String(args["brand-terms"]).split(",").map((t) => t.trim()).filter(Boolean);
-	if (args["prev-start"]) body.prevStartDate = String(args["prev-start"]);
-	if (args["prev-end"]) body.prevEndDate = String(args["prev-end"]);
-	if (args.dimension) body.dimension = String(args.dimension);
-	if (args.metric) body.metric = String(args.metric);
-	if (args["cluster-by"]) body.clusterBy = String(args["cluster-by"]);
-	return body;
+	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] || {};
@@ -648,129 +509,232 @@ function makeToolCommand(tool) {
 				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 cloud = await getCloudClient();
-			if (!cloud) {
-				logger.error("Analysis requires cloud mode. Run gscdump init to set up cloud mode.");
-				process$1.exit(1);
-			}
-			const siteId = await resolveSiteId(cloud, args.site);
-			logger.info(`Running ${tool} analysis...`);
-			const body = buildBody(tool, args);
-			const data = await cloud.analysisPost(siteId, body).catch((e) => {
-				logger.error(`Analysis failed: ${e.message}`);
-				process$1.exit(1);
+			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 (format === "json") {
-				console.log(JSON.stringify(data, null, 2));
-				return;
-			}
-			const { results, total } = extractResults(data);
-			if (format === "csv" && results.length > 0) {
-				const cols$1 = Object.keys(results[0]);
-				console.log(toCSV(results, cols$1));
+			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;
 			}
-			if (results.length === 0) {
-				logger.warn("No results found");
+			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 cols = Object.keys(results[0]);
-			const widths = cols.map((c) => Math.max(c.length, ...results.map((r) => String(r[c] ?? "").length).slice(0, 20)));
-			console.log();
-			console.log(`  ${cols.map((c, i) => c.padEnd(widths[i])).join("  ")}`);
-			console.log(`  ${cols.map((_, i) => "─".repeat(widths[i])).join("  ")}`);
-			for (const row of results) console.log(`  ${cols.map((c, i) => {
-				const val = row[c];
-				return (typeof val === "number" ? Number.isInteger(val) ? String(val) : val.toFixed(2) : String(val ?? "")).padEnd(widths[i]);
-			}).join("  ")}`);
-			console.log();
-			logger.success(`${results.length} results`);
-			if (total > results.length) logger.info(`Total: ${total} (showing ${results.length})`);
+			renderResults(result.results, result.results.length, format);
 		}
 	});
 }
-const analysisCommand = defineCommand({
-	meta: {
-		name: "analysis",
-		description: "SEO analysis tools (cloud mode only)"
-	},
-	subCommands: Object.fromEntries(ANALYSIS_TOOLS.map((tool) => [tool, makeToolCommand(tool)]))
-});
-//#endregion
-//#region src/commands/auth.ts
-const statusCommand$2 = defineCommand({
-	meta: {
-		name: "status",
-		description: "Show current authentication status"
-	},
-	async run() {
-		const config = await loadConfig();
+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 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(`  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;
-		}
-		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");
-				return;
-			}
-			const hasSession = !!tokens.sessionId;
-			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();
-			if (tokens.user?.email) console.log(`  User:          \x1B[36m${tokens.user.email}\x1B[0m`);
-			if (tokens.user?.publicId) console.log(`  User ID:       \x1B[90m${tokens.user.publicId}\x1B[0m`);
-			console.log(`  Session:       ${hasSession ? "\x1B[32mactive\x1B[0m" : "\x1B[31mmissing\x1B[0m"}`);
-			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");
-				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})`);
-			}
-		}
+		console.log(`  trend: ${rowSeriesSparkline.spark}  (${rowSeriesSparkline.label})`);
 	}
-});
-const logoutCommand = defineCommand({
+	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: {
@@ -778,162 +742,134 @@ const authCommand = defineCommand({
 		description: "Manage authentication"
 	},
 	subCommands: {
-		status: statusCommand$2,
-		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"
-	},
-	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$1.exit(1);
-		}
-		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
-	}
-});
-//#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];
-	}
-}
-function getDimensionNames(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 resolveCloudSite$3(cloud, target) {
-	const me = await cloud.me().catch((e) => {
-		logger.error(`Failed to fetch sites: ${e.message}`);
-		process$1.exit(1);
-	});
-	if (me.sites.length === 0) {
-		logger.error("No registered sites. Run gscdump register first.");
-		process$1.exit(1);
-	}
-	let site = target ? me.sites.find((s) => s.siteUrl === target || s.siteUrl.includes(target)) : void 0;
-	if (!site) if (me.sites.length === 1) site = me.sites[0];
-	else {
-		const selected = await select({
-			message: "Select a site",
-			options: me.sites.map((s) => ({
-				value: s.siteId,
-				label: s.siteUrl
-			}))
-		});
-		if (isCancel(selected)) {
-			cancel("Cancelled");
-			process$1.exit(0);
-		}
-		site = me.sites.find((s) => s.siteId === selected);
-	}
-	return {
-		siteId: site.siteId,
-		siteUrl: site.siteUrl
-	};
-}
-const dumpCommand = defineCommand({
-	meta: {
-		name: "dump",
-		description: "Export search analytics data via GSC API"
+		name: "dump",
+		description: "Export live Parquet files from the local store to a directory"
 	},
 	args: {
 		site: {
@@ -941,325 +877,197 @@ const dumpCommand = defineCommand({
 			alias: "s",
 			description: "Site URL (e.g., sc-domain:example.com)"
 		},
-		output: {
+		out: {
 			type: "string",
 			alias: "o",
-			description: "Output file path (default: stdout)"
-		},
-		format: {
-			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)"
-		},
-		types: {
-			type: "string",
-			alias: "t",
-			description: "Data types: pages,keywords,countries,devices"
+			default: DEFAULT_OUT,
+			description: `Output directory (default: ${DEFAULT_OUT})`
 		},
-		limit: {
-			type: "string",
-			alias: "l",
-			default: "25000",
-			description: "Max rows per data type"
+		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"
-		},
-		interactive: {
-			type: "boolean",
-			alias: "i",
-			default: false,
-			description: "Interactive mode - prompts for options"
 		}
 	},
 	async run({ args }) {
-		const config = await loadConfig();
-		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$1.exit(0);
-			}
-			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$1.exit(0);
-			}
-			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"]
-			});
-			if (isCancel(selected)) {
-				cancel("Cancelled");
-				process$1.exit(0);
-			}
-			dataTypes = selected;
-		} else dataTypes = ["pages", "keywords"];
-		const rowLimit = Number.parseInt(String(args.limit), 10);
-		const format = String(args.format);
-		const cloud = await getCloudClient();
-		if (cloud) {
-			const { siteId, siteUrl: siteUrl$1 } = await resolveCloudSite$3(cloud, args.site || config.defaultSite);
-			const output$1 = {
-				siteUrl: siteUrl$1,
-				dateRange: {
-					start: startDate,
-					end: endDate
-				},
-				exportedAt: (/* @__PURE__ */ new Date()).toISOString()
-			};
-			const totalSteps$1 = dataTypes.length;
-			let currentStep$1 = 0;
-			for (const dataType of dataTypes) {
-				currentStep$1++;
-				if (!args.quiet) {
-					clearLine();
-					process$1.stdout.write(progressBar(currentStep$1, totalSteps$1, dataType));
-				}
-				const dimensions = getDimensionNames(dataType);
-				const result = await cloud.query(siteId, {
-					startDate,
-					endDate,
-					dimensions,
-					rowLimit: String(rowLimit)
-				}).catch((e) => {
-					logger.error(`Query failed: ${e.message}`);
-					process$1.exit(1);
-				});
-				output$1[dataType] = {
-					total: result.rows.length,
-					data: result.rows
-				};
-			}
-			if (!args.quiet) {
-				clearLine();
-				logger.success(`Exported ${dataTypes.join(", ")} for ${siteUrl$1}`);
-			}
-			const content$1 = format === "csv" ? exportToCSV(output$1) : JSON.stringify(output$1, null, 2);
-			if (args.output) {
-				await fs.writeFile(String(args.output), content$1);
-				if (!args.quiet) logger.info(`Written to ${args.output}`);
-			} else console.log(content$1);
-			return;
-		}
-		const client = googleSearchConsole(await getAuth({
-			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$1.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$1.exit(0);
-			}
-			siteUrl = selected;
-		}
-		const output = {
-			siteUrl,
-			dateRange: {
-				start: startDate,
-				end: endDate
-			},
-			exportedAt: (/* @__PURE__ */ new Date()).toISOString()
-		};
-		const totalSteps = dataTypes.length;
-		let currentStep = 0;
-		for (const dataType of dataTypes) {
-			currentStep++;
-			if (!args.quiet) {
-				clearLine();
-				process$1.stdout.write(progressBar(currentStep, totalSteps, dataType));
-			}
-			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);
+		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);
+		}
+		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/indexing.ts
-async function resolveCloudSite$2(cloud, target) {
-	const me = await cloud.me().catch((e) => {
-		logger.error(`Failed to fetch sites: ${e.message}`);
-		process$1.exit(1);
-	});
-	if (me.sites.length === 0) {
-		logger.error("No registered sites. Run gscdump register first.");
-		process$1.exit(1);
-	}
-	let site = target ? me.sites.find((s) => s.siteUrl === target || s.siteUrl.includes(target)) : void 0;
-	if (!site) if (me.sites.length === 1) site = me.sites[0];
-	else {
-		const selected = await select({
-			message: "Select a site",
-			options: me.sites.map((s) => ({
-				value: s.siteId,
-				label: s.siteUrl
-			}))
+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
 		});
-		if (isCancel(selected)) {
-			cancel("Cancelled");
-			process$1.exit(0);
-		}
-		site = me.sites.find((s) => s.siteId === selected);
 	}
-	return {
-		siteId: site.siteId,
-		siteUrl: site.siteUrl
-	};
 }
-const statusCommand$1 = 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: "status",
-		description: "Show indexing status overview (cloud mode)"
+		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",
-			description: "Site URL"
+			required: true,
+			description: "Site URL (e.g., sc-domain:example.com)"
 		},
-		days: {
+		file: {
 			type: "string",
-			alias: "d",
-			default: "28",
-			description: "Days of trend data (max 90)"
+			alias: "f",
+			description: "Path to a file with one URL per line. If omitted, reads from stdin."
 		},
-		json: {
+		limit: {
+			type: "string",
+			description: `Max URLs to inspect this run (default: ${INSPECTION_QPD_PER_PROPERTY}, the per-property GSC daily quota)`
+		},
+		concurrency: {
+			type: "string",
+			alias: "c",
+			default: "4",
+			description: "Concurrent in-flight inspect calls (default: 4)"
+		},
+		quiet: {
 			type: "boolean",
+			alias: "q",
 			default: false,
-			description: "Output as JSON"
+			description: "Suppress progress output"
 		}
 	},
 	async run({ args }) {
-		const cloud = await getCloudClient();
-		if (!cloud) {
-			logger.error("Indexing status requires cloud mode. Run gscdump init to set up.");
-			process$1.exit(1);
-		}
-		const config = await loadConfig();
-		const { siteId, siteUrl } = await resolveCloudSite$2(cloud, args.site || config.defaultSite);
-		const data = await cloud.indexing(siteId, { days: String(args.days) }).catch((e) => {
-			logger.error(`Failed to fetch indexing data: ${e.message}`);
-			process$1.exit(1);
+		const ctx = await createCommandContext({
+			needsAuth: true,
+			needsStore: true
 		});
-		if (args.json) {
-			console.log(JSON.stringify(data, null, 2));
+		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;
 		}
-		const s = data.summary;
-		console.log();
-		console.log(`  \x1B[1m${siteUrl}\x1B[0m — Indexing Status`);
-		console.log();
-		console.log(`  Total URLs:     \x1B[36m${s.totalUrls.toLocaleString()}\x1B[0m`);
-		console.log(`  Indexed:        \x1B[32m${s.indexed.toLocaleString()}\x1B[0m (${s.indexedPercent}%)`);
-		console.log(`  Not Indexed:    \x1B[31m${s.notIndexed.toLocaleString()}\x1B[0m`);
-		if (s.pending > 0) console.log(`  Pending:        \x1B[33m${s.pending.toLocaleString()}\x1B[0m`);
-		if (s.change7d !== null || s.change28d !== null) {
-			console.log();
-			if (s.change7d !== null) {
-				const color = s.change7d > 0 ? "\x1B[32m+" : s.change7d < 0 ? "\x1B[31m" : "\x1B[90m";
-				console.log(`  7d change:      ${color}${s.change7d}%\x1B[0m`);
-			}
-			if (s.change28d !== null) {
-				const color = s.change28d > 0 ? "\x1B[32m+" : s.change28d < 0 ? "\x1B[31m" : "\x1B[90m";
-				console.log(`  28d change:     ${color}${s.change28d}%\x1B[0m`);
+		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
+				});
 			}
-		}
-		if (data.trend.length > 1) {
-			console.log();
-			console.log("  \x1B[1mTrend (indexed %)\x1B[0m");
-			const recent = data.trend.slice(-14);
-			for (const t of recent) {
-				const bar = "█".repeat(Math.round(t.indexedPercent / 5));
-				console.log(`  ${t.date}  \x1B[36m${bar}\x1B[0m ${t.indexedPercent}%`);
+			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`);
 			}
 		}
-		console.log();
+		if (failed > 0) process.exit(1);
 	}
 });
-const diagnosticsCommand = defineCommand({
+const showSubCommand = defineCommand({
 	meta: {
-		name: "diagnostics",
-		description: "Show indexing issue diagnostics (cloud mode)"
+		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,
@@ -1267,175 +1075,122 @@ const diagnosticsCommand = defineCommand({
 		}
 	},
 	async run({ args }) {
-		const cloud = await getCloudClient();
-		if (!cloud) {
-			logger.error("Indexing diagnostics requires cloud mode. Run gscdump init to set up.");
-			process$1.exit(1);
+		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);
 		}
-		const config = await loadConfig();
-		const { siteId, siteUrl } = await resolveCloudSite$2(cloud, args.site || config.defaultSite);
-		const data = await cloud.indexingDiagnostics(siteId).catch((e) => {
-			logger.error(`Failed to fetch diagnostics: ${e.message}`);
-			process$1.exit(1);
-		});
 		if (args.json) {
-			console.log(JSON.stringify(data, null, 2));
+			console.log(JSON.stringify(record, null, 2));
 			return;
 		}
 		console.log();
-		console.log(`  \x1B[1m${siteUrl}\x1B[0m — Indexing Diagnostics`);
-		console.log();
-		console.log(`  Total: \x1B[36m${data.summary.totalUrls.toLocaleString()}\x1B[0m URLs, \x1B[32m${data.summary.indexed.toLocaleString()}\x1B[0m indexed (${data.summary.indexedPercent}%)`);
-		console.log();
-		if (data.issues.length === 0) {
-			logger.success("No indexing issues found!");
-			return;
-		}
-		console.log("  \x1B[1mIssues\x1B[0m");
-		for (const issue of data.issues) {
-			const color = issue.severity === "error" ? "\x1B[31m" : issue.severity === "warning" ? "\x1B[33m" : "\x1B[90m";
-			console.log(`  ${color}${issue.severity.toUpperCase().padEnd(7)}\x1B[0m ${issue.label} — \x1B[36m${issue.count.toLocaleString()}\x1B[0m URLs`);
-		}
+		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 urlsCommand = defineCommand({
+const sitemapsSnapshotSubCommand = defineCommand({
 	meta: {
-		name: "urls",
-		description: "List URLs with indexing status (cloud mode)"
+		name: "snapshot",
+		description: "Fetch current sitemap state from GSC and persist to the local entity store"
 	},
 	args: {
 		site: {
 			type: "string",
 			alias: "s",
-			description: "Site URL"
-		},
-		status: {
-			type: "string",
-			description: "Filter: indexed, not_indexed, pending"
-		},
-		issue: {
-			type: "string",
-			description: "Filter by issue type"
-		},
-		search: {
-			type: "string",
-			description: "Search URLs"
-		},
-		limit: {
-			type: "string",
-			alias: "l",
-			default: "50",
-			description: "Max results"
+			required: true,
+			description: "Site URL (e.g., sc-domain:example.com)"
 		},
-		offset: {
-			type: "string",
-			default: "0",
-			description: "Offset for pagination"
+		quiet: {
+			type: "boolean",
+			alias: "q",
+			default: false,
+			description: "Suppress progress output"
 		},
 		json: {
 			type: "boolean",
 			default: false,
-			description: "Output as JSON"
+			description: "Emit the snapshot JSON to stdout"
 		}
 	},
 	async run({ args }) {
-		const cloud = await getCloudClient();
-		if (!cloud) {
-			logger.error("Indexing URLs requires cloud mode. Run gscdump init to set up.");
-			process$1.exit(1);
-		}
-		const config = await loadConfig();
-		const { siteId, siteUrl } = await resolveCloudSite$2(cloud, args.site || config.defaultSite);
-		const params = {
-			limit: String(args.limit),
-			offset: String(args.offset)
-		};
-		if (args.status) params.status = String(args.status);
-		if (args.issue) params.issue = String(args.issue);
-		if (args.search) params.search = String(args.search);
-		const data = await cloud.indexingUrls(siteId, params).catch((e) => {
-			logger.error(`Failed to fetch URLs: ${e.message}`);
-			process$1.exit(1);
+		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(data, null, 2));
+			console.log(JSON.stringify({
+				site: siteUrl,
+				capturedAt,
+				records
+			}, null, 2));
 			return;
 		}
-		console.log();
-		console.log(`  \x1B[1m${siteUrl}\x1B[0m — ${data.pagination.total.toLocaleString()} URLs (showing ${data.urls.length})`);
-		console.log();
-		for (const url of data.urls) {
-			const verdictColor = url.verdict === "PASS" ? "\x1B[32m" : url.verdict ? "\x1B[31m" : "\x1B[33m";
-			const verdictLabel = url.verdict === "PASS" ? "INDEXED" : url.verdict ? "NOT INDEXED" : "PENDING";
-			console.log(`  ${verdictColor}${verdictLabel.padEnd(12)}\x1B[0m ${url.url}`);
-			if (url.coverageState && url.coverageState !== "Submitted and indexed") console.log(`               \x1B[90m${url.coverageState}\x1B[0m`);
+		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}`);
+			}
 		}
-		if (data.pagination.hasMore) console.log(`\n  \x1B[90m... ${data.pagination.total - data.pagination.offset - data.urls.length} more (use --offset ${data.pagination.offset + data.urls.length})\x1B[0m`);
-		console.log();
 	}
 });
-const inspectCommand = defineCommand({
+const sitemapsShowSubCommand = defineCommand({
 	meta: {
-		name: "inspect",
-		description: "Inspect a specific URL's indexing status (local mode)"
+		name: "show",
+		description: "Print the latest captured sitemap state for a feedpath"
 	},
 	args: {
 		site: {
 			type: "string",
 			alias: "s",
 			required: true,
-			description: "Site URL (e.g., sc-domain:example.com)"
+			description: "Site URL"
 		},
-		url: {
+		path: {
 			type: "positional",
 			required: true,
-			description: "URL to inspect"
-		},
-		json: {
-			type: "boolean",
-			default: false,
-			description: "Output as JSON"
-		}
-	},
-	async run({ args }) {
-		const result = await inspectUrl(googleSearchConsole(await getAuth({ interactive: false })), args.site, args.url).catch((e) => {
-			logger.error(`Inspection failed: ${e.message}`);
-			process$1.exit(1);
-		});
-		if (args.json) {
-			console.log(JSON.stringify(result, null, 2));
-			return;
-		}
-		const indexStatus = result.inspectionResult?.indexStatusResult;
-		console.log();
-		console.log(`  \x1B[1mURL:\x1B[0m ${args.url}`);
-		console.log();
-		if (indexStatus) {
-			const verdict = indexStatus.verdict;
-			const verdictColor = verdict === "PASS" ? "\x1B[32m" : "\x1B[31m";
-			console.log(`  Verdict:        ${verdictColor}${verdict}\x1B[0m`);
-			if (indexStatus.coverageState) console.log(`  Coverage:       ${indexStatus.coverageState}`);
-			if (indexStatus.robotsTxtState) console.log(`  Robots.txt:     ${indexStatus.robotsTxtState}`);
-			if (indexStatus.indexingState) console.log(`  Indexing:       ${indexStatus.indexingState}`);
-			if (indexStatus.lastCrawlTime) console.log(`  Last Crawl:     ${indexStatus.lastCrawlTime}`);
-			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}`);
-		} else console.log(JSON.stringify(result, null, 2));
-		console.log();
-	}
-});
-const indexPercentCommand = defineCommand({
-	meta: {
-		name: "index-percent",
-		description: "Show index percent, invisible URLs, and orphan pages (cloud mode)"
-	},
-	args: {
-		site: {
-			type: "string",
-			alias: "s",
-			description: "Site URL"
+			description: "Sitemap path (feedpath)"
 		},
 		json: {
 			type: "boolean",
@@ -1444,81 +1199,172 @@ const indexPercentCommand = defineCommand({
 		}
 	},
 	async run({ args }) {
-		const cloud = await getCloudClient();
-		if (!cloud) {
-			logger.error("Index percent requires cloud mode. Run gscdump init to set up.");
-			process$1.exit(1);
+		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);
 		}
-		const config = await loadConfig();
-		const { siteId, siteUrl } = await resolveCloudSite$2(cloud, args.site || config.defaultSite);
-		const data = await cloud.indexPercent(siteId).catch((e) => {
-			logger.error(`Failed to fetch index percent: ${e.message}`);
-			process$1.exit(1);
-		});
 		if (args.json) {
-			console.log(JSON.stringify(data, null, 2));
+			console.log(JSON.stringify(record, null, 2));
 			return;
 		}
-		const s = data.summary;
-		console.log();
-		console.log(`  \x1B[1m${siteUrl}\x1B[0m — Index Percent`);
 		console.log();
-		console.log(`  Index Percent:     \x1B[36m${s.currentPercent}%\x1B[0m`);
-		console.log(`  Sitemap URLs:      ${s.totalSitemapUrls.toLocaleString()}`);
-		console.log(`  Visible in Search: \x1B[32m${s.visibleUrls.toLocaleString()}\x1B[0m`);
-		if (s.change7d !== null) {
-			const color = s.change7d > 0 ? "\x1B[32m+" : s.change7d < 0 ? "\x1B[31m" : "\x1B[90m";
-			console.log(`  7d change:         ${color}${s.change7d.toFixed(1)}%\x1B[0m`);
-		}
-		if (s.change28d !== null) {
-			const color = s.change28d > 0 ? "\x1B[32m+" : s.change28d < 0 ? "\x1B[31m" : "\x1B[90m";
-			console.log(`  28d change:        ${color}${s.change28d.toFixed(1)}%\x1B[0m`);
-		}
-		if (data.invisibleCount > 0) {
-			console.log();
-			console.log(`  \x1B[1mInvisible URLs\x1B[0m (\x1B[33m${data.invisibleCount}\x1B[0m — in sitemap but no search traffic)`);
-			for (const u of data.invisibleUrls.slice(0, 10)) console.log(`    ${u.url}`);
-			if (data.invisibleCount > 10) console.log(`    \x1B[90m... and ${data.invisibleCount - 10} more\x1B[0m`);
-		}
-		if (data.orphanCount > 0) {
-			console.log();
-			console.log(`  \x1B[1mOrphan Pages\x1B[0m (\x1B[33m${data.orphanCount}\x1B[0m — has traffic but not in sitemap)`);
-			for (const u of data.orphanPages.slice(0, 10)) console.log(`    ${u.url} \x1B[90m(${u.clicks} clicks)\x1B[0m`);
-			if (data.orphanCount > 10) console.log(`    \x1B[90m... and ${data.orphanCount - 10} more\x1B[0m`);
-		}
-		if (data.sitemaps.length > 0) {
-			console.log();
-			console.log("  \x1B[1mSitemaps\x1B[0m");
-			for (const sm of data.sitemaps) console.log(`    ${sm.path} \x1B[90m(${sm.urlCount.toLocaleString()} URLs)\x1B[0m`);
+		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 indexingCommand = defineCommand({
+const indexingSubCommand = defineCommand({
 	meta: {
 		name: "indexing",
-		description: "Indexing status, diagnostics, and URL inspection"
+		description: "Snapshot Indexing API metadata per URL"
 	},
-	subCommands: {
-		"status": statusCommand$1,
-		"diagnostics": diagnosticsCommand,
-		"urls": urlsCommand,
-		"inspect": inspectCommand,
-		"index-percent": indexPercentCommand
-	}
-});
-//#endregion
-//#region src/commands/init.ts
-async function loadEnvFile() {
-	const envPath = path.join(process$1.cwd(), ".env");
-	const content = await fs.readFile(envPath, "utf-8").catch(() => null);
+	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"
+			}
+		},
+		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 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;
+			}
+			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 (!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`);
+				}
+			}
+			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"
+			},
+			subCommands: {
+				snapshot: sitemapsSnapshotSubCommand,
+				show: sitemapsShowSubCommand
+			}
+		}),
+		indexing: indexingSubCommand
+	}
+});
+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);
 	if (!content) return null;
 	const env = {};
 	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();
@@ -1531,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",
@@ -1540,23 +1386,23 @@ 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;
 		}
 		const envFile = await loadEnvFile();
 		if (envFile?.GOOGLE_CLIENT_ID && envFile?.GOOGLE_CLIENT_SECRET && envFile?.GOOGLE_REFRESH_TOKEN) {
 			logger.info("Found .env file with Google credentials");
-			process$1.env.GOOGLE_CLIENT_ID = envFile.GOOGLE_CLIENT_ID;
-			process$1.env.GOOGLE_CLIENT_SECRET = envFile.GOOGLE_CLIENT_SECRET;
-			process$1.env.GOOGLE_REFRESH_TOKEN = envFile.GOOGLE_REFRESH_TOKEN;
-			if (envFile.GOOGLE_ACCESS_TOKEN) process$1.env.GOOGLE_ACCESS_TOKEN = envFile.GOOGLE_ACCESS_TOKEN;
+			process.env.GOOGLE_CLIENT_ID = envFile.GOOGLE_CLIENT_ID;
+			process.env.GOOGLE_CLIENT_SECRET = envFile.GOOGLE_CLIENT_SECRET;
+			process.env.GOOGLE_REFRESH_TOKEN = envFile.GOOGLE_REFRESH_TOKEN;
+			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,
@@ -1575,621 +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$1.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)")
-});
-//#endregion
-//#region src/mcp/server/index.ts
-function createGscMcpServer(options) {
-	const { name = "gscdump", version = "1.0.0", getAuth: getAuth$1, cloudClient } = 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)
-		}] };
-	});
-	if (cloudClient) {
-		const siteIdSchema = z.object({ siteId: z.string().describe("Site ID from gscdump platform (use cloud-list-sites to find)") });
-		const analysisSchema = z.object({
-			siteId: z.string().describe("Site ID from gscdump platform"),
-			tool: z.enum([
-				"striking-distance",
-				"opportunity",
-				"movers",
-				"decay",
-				"zero-click",
-				"brand",
-				"cannibalization",
-				"clustering",
-				"concentration",
-				"seasonality"
-			]).describe("Analysis tool to run"),
-			startDate: z.string().optional().describe("Start date (YYYY-MM-DD)"),
-			endDate: z.string().optional().describe("End date (YYYY-MM-DD)"),
-			limit: z.number().optional().describe("Max results")
-		});
-		server.registerTool("cloud-list-sites", {
-			description: "List registered sites on gscdump.com with sync status and progress",
-			inputSchema: z.object({}).shape
-		}, async () => {
-			const result = await cloudClient.me();
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(result, null, 2)
-			}] };
-		});
-		server.registerTool("cloud-sync-status", {
-			description: "Get detailed sync status for a site on gscdump.com",
-			inputSchema: siteIdSchema.shape
-		}, async ({ siteId }) => {
-			const result = await cloudClient.syncStatus(siteId);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(result, null, 2)
-			}] };
-		});
-		server.registerTool("cloud-sitemaps", {
-			description: "Get sitemap health data for a site from gscdump.com (includes URL counts, error tracking, history)",
-			inputSchema: siteIdSchema.shape
-		}, async ({ siteId }) => {
-			const result = await cloudClient.sitemaps(siteId);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(result, null, 2)
-			}] };
-		});
-		server.registerTool("cloud-analysis", {
-			description: "Run SEO analysis on synced data (striking-distance, opportunity, movers, decay, zero-click, brand, cannibalization, clustering, concentration, seasonality)",
-			inputSchema: analysisSchema.shape
-		}, async ({ siteId, tool, startDate, endDate, limit }) => {
-			const params = {};
-			if (startDate) params.startDate = startDate;
-			if (endDate) params.endDate = endDate;
-			if (limit) params.limit = String(limit);
-			const result = await cloudClient.analysis(siteId, tool, params);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(result, null, 2)
-			}] };
-		});
-		server.registerTool("cloud-register-site", {
-			description: "Register a site for syncing on gscdump.com",
-			inputSchema: z.object({ siteUrl: z.string().describe("Site URL to register (e.g., example.com)") }).shape
-		}, async ({ siteUrl }) => {
-			const result = await cloudClient.registerSite(siteUrl);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(result, null, 2)
-			}] };
-		});
-		server.registerTool("cloud-query", {
-			description: "Live GSC query via gscdump.com platform (bypasses synced data, queries Google directly)",
-			inputSchema: z.object({
-				siteId: z.string().describe("Site ID from gscdump platform"),
-				startDate: z.string().describe("Start date (YYYY-MM-DD)"),
-				endDate: z.string().describe("End date (YYYY-MM-DD)"),
-				dimensions: z.string().optional().describe("Comma-separated: page,query,country,device,date,searchAppearance"),
-				rowLimit: z.number().optional().describe("Max rows (default 1000, max 25000)")
-			}).shape
-		}, async ({ siteId, startDate, endDate, dimensions, rowLimit }) => {
-			const params = {
-				startDate,
-				endDate
-			};
-			if (dimensions) params.dimensions = dimensions;
-			if (rowLimit) params.rowLimit = String(rowLimit);
-			const result = await cloudClient.query(siteId, params);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(result, null, 2)
-			}] };
-		});
-		server.registerTool("cloud-indexing", {
-			description: "Get indexing status trend and summary for a site on gscdump.com",
-			inputSchema: z.object({
-				siteId: z.string().describe("Site ID from gscdump platform"),
-				days: z.number().optional().describe("Days of trend data (default 28, max 90)")
-			}).shape
-		}, async ({ siteId, days }) => {
-			const params = {};
-			if (days) params.days = String(days);
-			const result = await cloudClient.indexing(siteId, params);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(result, null, 2)
-			}] };
-		});
-		server.registerTool("cloud-indexing-diagnostics", {
-			description: "Get indexing issue diagnostics with counts and severity for a site",
-			inputSchema: siteIdSchema.shape
-		}, async ({ siteId }) => {
-			const result = await cloudClient.indexingDiagnostics(siteId);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(result, null, 2)
-			}] };
-		});
-		server.registerTool("cloud-indexing-urls", {
-			description: "Get paginated URL list with indexing status, verdict, and coverage details",
-			inputSchema: z.object({
-				siteId: z.string().describe("Site ID from gscdump platform"),
-				status: z.enum([
-					"indexed",
-					"not_indexed",
-					"pending"
-				]).optional().describe("Filter by status"),
-				issue: z.string().optional().describe("Filter by issue type"),
-				search: z.string().optional().describe("Search URLs"),
-				limit: z.number().optional().describe("Max results (default 100, max 500)"),
-				offset: z.number().optional().describe("Pagination offset")
-			}).shape
-		}, async ({ siteId, status, issue, search, limit, offset }) => {
-			const params = {};
-			if (status) params.status = status;
-			if (issue) params.issue = issue;
-			if (search) params.search = search;
-			if (limit) params.limit = String(limit);
-			if (offset) params.offset = String(offset);
-			const result = await cloudClient.indexingUrls(siteId, params);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(result, null, 2)
-			}] };
-		});
-		server.registerTool("cloud-index-percent", {
-			description: "Get index percent trend, invisible URLs (in sitemap but no traffic), and orphan pages (traffic but not in sitemap)",
-			inputSchema: siteIdSchema.shape
-		}, async ({ siteId }) => {
-			const result = await cloudClient.indexPercent(siteId);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(result, null, 2)
-			}] };
-		});
-		server.registerTool("cloud-trigger-sync", {
-			description: "Trigger a fresh data sync for a site on gscdump.com",
-			inputSchema: siteIdSchema.shape
-		}, async ({ siteId }) => {
-			const result = await cloudClient.triggerSync(siteId);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(result, null, 2)
-			}] };
-		});
-		server.registerTool("cloud-delete-site", {
-			description: "Unregister a site from gscdump.com (stops syncing, removes pending jobs)",
-			inputSchema: siteIdSchema.shape
-		}, async ({ siteId }) => {
-			const result = await cloudClient.deleteSite(siteId);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(result, null, 2)
-			}] };
-		});
-		server.registerTool("cloud-sitemap-action", {
-			description: "Submit, delete, or refresh sitemaps via gscdump.com",
-			inputSchema: z.object({
-				siteId: z.string().describe("Site ID from gscdump platform"),
-				action: z.enum([
-					"submit",
-					"delete",
-					"refresh"
-				]).describe("Action to perform"),
-				sitemapUrl: z.string().optional().describe("Sitemap URL (required for submit/delete)")
-			}).shape
-		}, async ({ siteId, action, sitemapUrl }) => {
-			const body = { action };
-			if (sitemapUrl) body.sitemapUrl = sitemapUrl;
-			const result = await cloudClient.sitemapAction(siteId, body);
-			return { content: [{
-				type: "text",
-				text: JSON.stringify(result, null, 2)
-			}] };
+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();
 	}
-	return server;
-}
-//#endregion
-//#region src/commands/mcp.ts
+});
 async function checkAuth() {
-	if ((process$1.env.GOOGLE_ACCESS_TOKEN || process$1.env.GOOGLE_REFRESH_TOKEN) && process$1.env.GOOGLE_CLIENT_ID && process$1.env.GOOGLE_CLIENT_SECRET) return { ok: true };
+	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.
@@ -2201,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 {
+	if (!await loadTokens()) return {
 		ok: false,
-		error: `Local authentication missing.
+		error: `Authentication missing.
 Run this command to authenticate:
@@ -2232,23 +1525,27 @@ const mcpCommand = defineCommand({
 	async run() {
 		const authCheck = await checkAuth();
 		if (!authCheck.ok) {
-			process$1.stderr.write(`\n${authCheck.error}\n\n`);
-			process$1.exit(1);
+			process.stderr.write(`\n${authCheck.error}\n\n`);
+			process.exit(1);
 		}
 		const server = createGscMcpServer({
 			name: "gscdump",
 			version: VERSION,
-			getAuth: () => getAuth({ interactive: false }),
-			cloudClient: await getCloudClient()
+			getAuth: () => getAuth({ interactive: false })
 		});
 		const transport = new StdioServerTransport();
 		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,
@@ -2256,40 +1553,38 @@ const DIMENSION_MAP = {
 	device,
 	searchAppearance
 };
-async function resolveCloudSite$1(cloud, target) {
-	const me = await cloud.me().catch((e) => {
-		logger.error(`Failed to fetch sites: ${e.message}`);
-		process$1.exit(1);
-	});
-	if (me.sites.length === 0) {
-		logger.error("No registered sites. Run gscdump register first.");
-		process$1.exit(1);
-	}
-	let site = target ? me.sites.find((s) => s.siteUrl === target || s.siteUrl.includes(target)) : void 0;
-	if (!site) if (me.sites.length === 1) site = me.sites[0];
-	else {
-		const selected = await select({
-			message: "Select a site",
-			options: me.sites.map((s) => ({
-				value: s.siteId,
-				label: s.siteUrl
-			}))
+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;
 		});
-		if (isCancel(selected)) {
-			cancel("Cancelled");
-			process$1.exit(0);
-		}
-		site = me.sites.find((s) => s.siteId === selected);
+		allRows.push(...rows);
+		if (rows.length < opts.rowLimit) break;
+		startRow += rows.length;
 	}
-	return {
-		siteId: site.siteId,
-		siteUrl: site.siteUrl
-	};
+	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: {
@@ -2300,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",
@@ -2327,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",
@@ -2341,70 +1649,70 @@ const queryCommand = defineCommand({
 		}
 	},
 	async run({ args }) {
-		const config = await loadConfig();
-		let dimNames;
-		if (args.dimensions) dimNames = String(args.dimensions).split(",").filter((d) => d in DIMENSION_MAP);
-		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"]
-			});
-			if (isCancel(selected)) {
-				cancel("Cancelled");
-				process$1.exit(0);
-			}
-			dimNames = selected;
-		} else dimNames = ["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 (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)
 			});
-			if (isCancel(startInput)) {
-				cancel("Cancelled");
-				process$1.exit(0);
-			}
-			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$1.exit(0);
-			}
-			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];
+			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 cloud = await getCloudClient();
-		if (cloud) {
-			const { siteId, siteUrl: siteUrl$1 } = await resolveCloudSite$1(cloud, args.site || config.defaultSite);
-			if (!args.quiet) logger.info(`Querying ${siteUrl$1}...`);
-			const result = await cloud.query(siteId, {
+		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.join(","),
-				rowLimit: String(rowLimit)
+				dimensions: dimNames,
+				rowLimit
 			}).catch((e) => {
 				logger.error(`Query failed: ${e.message}`);
-				process$1.exit(1);
+				process.exit(1);
 			});
-			if (!args.quiet) logger.success(`Fetched ${result.rows.length} rows`);
-			const output$1 = {
-				siteUrl: siteUrl$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)
+			});
+			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,
@@ -2412,700 +1720,1079 @@ const queryCommand = defineCommand({
 				},
 				total: result.rows.length,
 				data: result.rows
-			};
-			const content$1 = format === "csv" ? exportToCSV(output$1) : JSON.stringify(output$1, null, 2);
-			if (args.output) {
-				await fs.writeFile(String(args.output), content$1);
-				if (!args.quiet) logger.info(`Written to ${args.output}`);
-			} else console.log(content$1);
-			return;
-		}
-		const client = googleSearchConsole(await getAuth({
-			interactive: false,
-			config
-		}));
-		const dimensions = dimNames.map((d) => DIMENSION_MAP[d]);
-		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$1.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$1.exit(0);
-			}
-			siteUrl = selected;
-		}
-		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$1.stdout.write(progressBar(rows.length, rowLimit, `${rows.length} rows`));
-			}
-		}
-		if (!args.quiet) {
-			clearLine();
-			logger.success(`Fetched ${rows.length} rows`);
-		}
-		const output = {
-			siteUrl,
-			dimensions: dimNames,
-			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);
+			format,
+			path: args.output ? String(args.output) : void 0,
+			quiet: Boolean(args.quiet)
+		});
 	}
 });
-//#endregion
-//#region src/commands/register.ts
-const registerCommand = defineCommand({
-	meta: {
-		name: "register",
-		description: "Register site(s) for syncing (cloud mode only)"
-	},
-	args: { site: {
-		type: "positional",
-		description: "Site URL(s) to register (space-separated for bulk)",
-		required: false
-	} },
-	async run({ args }) {
-		const cloud = await getCloudClient();
-		if (!cloud) {
-			logger.error("Register requires cloud mode. Run gscdump init to set up cloud mode.");
-			process$1.exit(1);
-		}
-		const rawArgs = process$1.argv.slice(3).filter((a) => !a.startsWith("-"));
-		const siteUrls = rawArgs.length > 0 ? rawArgs : args.site ? [args.site] : [];
-		if (siteUrls.length > 1) {
-			logger.info(`Registering ${siteUrls.length} sites...`);
-			const result$1 = await cloud.bulkRegister(siteUrls).catch((e) => {
-				logger.error(`Bulk registration failed: ${e.message}`);
-				process$1.exit(1);
-			});
-			console.log();
-			for (const r of result$1.results) {
-				const icon = r.status === "registered" ? "\x1B[32m✓\x1B[0m" : r.status === "already_exists" ? "\x1B[33m~\x1B[0m" : "\x1B[31m✗\x1B[0m";
-				const detail = r.status === "registered" ? `ID: ${r.siteId}` : r.status === "already_exists" ? "already registered" : r.error || r.status;
-				console.log(`  ${icon} ${r.siteUrl} — ${detail}`);
-			}
-			console.log();
-			const s = result$1.summary;
-			logger.success(`${s.registered} registered, ${s.alreadyExists} existing, ${s.notFound} not found, ${s.errors} errors`);
-			return;
-		}
-		let siteUrl = siteUrls[0];
-		if (!siteUrl) {
-			const available = await cloud.availableSites().catch((e) => {
-				logger.error(`Failed to fetch available sites: ${e.message}`);
-				process$1.exit(1);
-			});
-			const unregistered = available.filter((s) => !s.registered);
-			if (unregistered.length === 0) {
-				if (available.length > 0) logger.info("All available sites are already registered");
-				else logger.warn("No GSC sites found for this account");
-				return;
-			}
-			const selected = await select({
-				message: "Select a site to register for syncing",
-				options: unregistered.map((s) => ({
-					value: s.siteUrl,
-					label: s.siteUrl,
-					hint: s.permissionLevel
-				}))
-			});
-			if (isCancel(selected)) {
-				cancel("Cancelled");
-				process$1.exit(0);
-			}
-			siteUrl = selected;
+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);
 		}
-		logger.info(`Registering ${siteUrl}...`);
-		const result = await cloud.registerSite(siteUrl).catch((e) => {
-			logger.error(`Registration failed: ${e.message}`);
-			process$1.exit(1);
+		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 (result.existing) logger.info(`Site already registered (${result.status})`);
-		else logger.success(`Site registered! Sync queued.`);
-		console.log();
-		console.log(`  Site ID: \x1B[36m${result.siteId}\x1B[0m`);
-		console.log(`  Status:  ${result.status}`);
-		console.log();
-		logger.info("Run gscdump sync status to check sync progress");
+		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)
+		};
 	}
-});
-//#endregion
-//#region src/commands/sitemaps.ts
-const listCommand = defineCommand({
+	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: "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"
-		}
+		name: "sitemaps",
+		description: "Manage sitemaps"
 	},
-	async run({ args }) {
-		const cloud = await getCloudClient();
-		if (cloud) {
-			const config = await loadConfig();
-			const target = args.site || config.defaultSite;
-			const me = await cloud.me().catch((e) => {
-				logger.error(`Failed to fetch sites: ${e.message}`);
-				process$1.exit(1);
-			});
-			if (me.sites.length === 0) {
-				logger.warn("No registered sites. Run gscdump register first.");
-				return;
-			}
-			let site = target ? me.sites.find((s) => s.siteUrl === target || s.siteUrl.includes(target)) : void 0;
-			if (!site) if (me.sites.length === 1) site = me.sites[0];
-			else {
-				const selected = await select({
-					message: "Select a site",
-					options: me.sites.map((s) => ({
-						value: s.siteId,
-						label: s.siteUrl
-					}))
-				});
-				if (isCancel(selected)) {
-					cancel("Cancelled");
-					process$1.exit(0);
+	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}`);
 				}
-				site = me.sites.find((s) => s.siteId === selected);
-			}
-			const data = await cloud.sitemaps(site.siteId).catch((e) => {
-				logger.error(`Failed to fetch sitemaps: ${e.message}`);
-				process$1.exit(1);
-			});
-			if (args.json) {
-				console.log(JSON.stringify(data, null, 2));
-				return;
 			}
-			if (data.sitemaps.length === 0) {
-				logger.warn("No sitemaps found");
-				return;
+		}),
+		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`);
+				}
 			}
-			logger.success(`${data.sitemaps.length} sitemaps:`);
-			console.log();
-			for (const sm of data.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` : "";
-				const urls = sm.urlCount ? ` \x1B[36m${sm.urlCount.toLocaleString()} URLs\x1B[0m` : "";
-				console.log(`  ${sm.path}${urls}${pending}${errors}${warnings}`);
+		}),
+		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}`);
 			}
-			if (data.history.length > 0) {
-				console.log();
-				console.log("  \x1B[1mRecent History\x1B[0m");
-				for (const h of data.history.slice(0, 7)) {
-					const errStr = h.errors > 0 ? ` \x1B[31m${h.errors} err\x1B[0m` : "";
-					console.log(`  ${h.date}: ${h.urlCount.toLocaleString()} URLs${errStr}`);
+		}),
+		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}`);
 			}
-			return;
-		}
-		if (!args.site) {
-			logger.error("Site URL required (-s)");
-			process$1.exit(1);
-		}
-		const sitemaps = await fetchSitemaps(googleSearchConsole(await getAuth({ interactive: false })), args.site).catch(gscErrorHandler);
+		})
+	}
+});
+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(sitemaps, null, 2));
+			console.log(JSON.stringify(sites, null, 2));
 			return;
 		}
-		if (sitemaps.length === 0) {
-			logger.warn("No sitemaps found");
+		if (sites.length === 0) {
+			logger.warn("No verified sites found");
 			return;
 		}
-		logger.success(`Found ${sitemaps.length} sitemaps:`);
+		logger.success(`Found ${sites.length} sites:`);
 		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}`);
+		for (const site of sites) {
+			const perm = site.permissionLevel === "siteOwner" ? "\x1B[32m" : "\x1B[90m";
+			console.log(`  ${site.siteUrl} ${perm}(${site.permissionLevel})\x1B[0m`);
 		}
 	}
 });
-const getCommand = defineCommand({
+const compactCommand = defineCommand({
 	meta: {
-		name: "get",
-		description: "Get details for a specific sitemap"
+		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"
+			description: "Restrict to a single site (default: all sites with local data)"
 		},
-		url: {
-			type: "positional",
-			required: true,
-			description: "Sitemap URL"
+		"raw-days": {
+			type: "string",
+			description: "Override raw→d7 age threshold in days (default: 7)"
 		},
-		json: {
+		"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 sitemap = await fetchSitemap(googleSearchConsole(await getAuth({ interactive: false })), 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 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 submitCommand = 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: "submit",
-		description: "Submit a sitemap to GSC"
+		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 to submit"
+		site: {
+			type: "string",
+			description: "Limit export to a single site URL (omit to include all)"
+		},
+		force: {
+			type: "boolean",
+			default: false,
+			description: "Overwrite the output file if it already exists"
 		}
 	},
 	async run({ args }) {
-		const cloud = await getCloudClient();
-		if (cloud) {
-			const config = await loadConfig();
-			const me = await cloud.me().catch((e) => {
-				logger.error(`Failed to fetch sites: ${e.message}`);
-				process$1.exit(1);
-			});
-			const target = args.site || config.defaultSite;
-			const site = me.sites.find((s) => s.siteUrl === target || s.siteUrl.includes(target));
-			if (!site) {
-				logger.error(`Site not found: ${target}`);
-				process$1.exit(1);
-			}
-			await cloud.sitemapAction(site.siteId, {
-				action: "submit",
-				sitemapUrl: args.url
-			}).catch((e) => {
-				logger.error(`Submit failed: ${e.message}`);
-				process$1.exit(1);
-			});
-			logger.success(`Submitted sitemap: ${args.url}`);
+		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;
 		}
-		await submitSitemap(googleSearchConsole(await getAuth({ interactive: false })), args.site, args.url).catch(gscErrorHandler);
-		logger.success(`Submitted sitemap: ${args.url}`);
+		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 deleteCommand = defineCommand({
+const DEFAULT_GRACE_HOURS = 24;
+const gcCommand = defineCommand({
 	meta: {
-		name: "delete",
-		description: "Delete a sitemap from 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 delete"
+		"quiet": {
+			type: "boolean",
+			alias: "q",
+			default: false,
+			description: "Suppress progress output"
 		}
 	},
 	async run({ args }) {
-		const cloud = await getCloudClient();
-		if (cloud) {
-			const config = await loadConfig();
-			const me = await cloud.me().catch((e) => {
-				logger.error(`Failed to fetch sites: ${e.message}`);
-				process$1.exit(1);
-			});
-			const target = args.site || config.defaultSite;
-			const site = me.sites.find((s) => s.siteUrl === target || s.siteUrl.includes(target));
-			if (!site) {
-				logger.error(`Site not found: ${target}`);
-				process$1.exit(1);
-			}
-			await cloud.sitemapAction(site.siteId, {
-				action: "delete",
-				sitemapUrl: args.url
-			}).catch((e) => {
-				logger.error(`Delete failed: ${e.message}`);
-				process$1.exit(1);
-			});
-			logger.success(`Deleted sitemap: ${args.url}`);
-			return;
-		}
-		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(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 refreshCommand = defineCommand({
+const rollupsCommand = defineCommand({
 	meta: {
-		name: "refresh",
-		description: "Refresh sitemap data from GSC (cloud mode)"
+		name: "rollups",
+		description: "Manage post-sync rollups"
 	},
-	args: { site: {
-		type: "string",
-		alias: "s",
-		description: "Site URL"
-	} },
-	async run({ args }) {
-		const cloud = await getCloudClient();
-		if (!cloud) {
-			logger.error("Sitemap refresh requires cloud mode. Run gscdump init to set up.");
-			process$1.exit(1);
-		}
-		const config = await loadConfig();
-		const me = await cloud.me().catch((e) => {
-			logger.error(`Failed to fetch sites: ${e.message}`);
-			process$1.exit(1);
-		});
-		const target = args.site || config.defaultSite;
-		let site = target ? me.sites.find((s) => s.siteUrl === target || s.siteUrl.includes(target)) : me.sites.length === 1 ? me.sites[0] : void 0;
-		if (!site) {
-			const selected = await select({
-				message: "Select a site",
-				options: me.sites.map((s) => ({
-					value: s.siteId,
-					label: s.siteUrl
-				}))
-			});
-			if (isCancel(selected)) {
-				cancel("Cancelled");
-				process$1.exit(0);
+	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"
 			}
-			site = me.sites.find((s) => s.siteId === selected);
-		}
-		const result = await cloud.sitemapAction(site.siteId, { action: "refresh" }).catch((e) => {
-			logger.error(`Refresh failed: ${e.message}`);
-			process$1.exit(1);
-		});
-		logger.success(`Refreshed sitemaps (${result.sitemapCount} found)`);
-	}
-});
-const sitemapsCommand = defineCommand({
-	meta: {
-		name: "sitemaps",
-		description: "Manage sitemaps"
-	},
-	subCommands: {
-		list: listCommand,
-		get: getCommand,
-		submit: submitCommand,
-		delete: deleteCommand,
-		refresh: refreshCommand
-	}
-});
-//#endregion
-//#region src/commands/sites.ts
-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 cloud = await getCloudClient();
-		if (cloud) {
-			const me = await cloud.me().catch((e) => {
-				logger.error(`Failed to fetch sites: ${e.message}`);
-				process.exit(1);
-			});
-			if (args.json) {
-				console.log(JSON.stringify(me.sites, null, 2));
-				return;
+		},
+		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 (me.sites.length === 0) {
-				logger.warn("No registered sites. Run gscdump register to add a site.");
+			if (allSiteIds.size === 0) {
+				logger.warn("No sites with local data. Run `gscdump sync` first.");
 				return;
 			}
-			logger.success(`${me.sites.length} registered sites:`);
-			console.log();
-			for (const site of me.sites) {
-				const statusColor = site.syncStatus === "synced" ? "\x1B[32m" : site.syncStatus === "syncing" ? "\x1B[33m" : site.syncStatus === "error" ? "\x1B[31m" : "\x1B[90m";
-				console.log(`  ${site.siteUrl} ${statusColor}(${site.syncStatus || "pending"})\x1B[0m`);
-				if (site.syncProgress.percent > 0 && site.syncProgress.percent < 100) console.log(`    ${progressBar(site.syncProgress.percent, 100, `${site.syncProgress.percent}%`, 20)}`);
-				if (site.oldestDateSynced && site.newestDateSynced) console.log(`    \x1B[90m${site.oldestDateSynced} → ${site.newestDateSynced}\x1B[0m`);
+			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}`);
+				}
 			}
-			return;
-		}
-		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));
-			return;
+			if (!quiet) logger.success(`Rebuilt rollups across ${allSiteIds.size} site(s) — total ${(totalBytes / 1024).toFixed(1)} KB`);
 		}
-		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.permission === "siteOwner" ? "\x1B[32m" : "\x1B[90m";
-			console.log(`  ${site.url} ${perm}(${site.permission})\x1B[0m`);
-		}
-	}
+	}) }
 });
-//#endregion
-//#region src/commands/sync.ts
-async function resolveCloudSite(cloud, target) {
-	const me = await cloud.me().catch((e) => {
-		logger.error(`Failed to fetch sites: ${e.message}`);
-		process$1.exit(1);
-	});
-	if (me.sites.length === 0) {
-		logger.error("No registered sites. Run gscdump register first.");
-		process$1.exit(1);
-	}
-	let site = target ? me.sites.find((s) => s.siteUrl === target || s.siteUrl.includes(target)) : void 0;
-	if (!site) if (me.sites.length === 1) site = me.sites[0];
-	else {
-		const selected = await select({
-			message: "Select a site",
-			options: me.sites.map((s) => ({
-				value: s.siteId,
-				label: s.siteUrl,
-				hint: s.syncStatus || "unknown"
-			}))
-		});
-		if (isCancel(selected)) {
-			cancel("Cancelled");
-			process$1.exit(0);
-		}
-		site = me.sites.find((s) => s.siteId === selected);
-	}
-	return {
-		siteId: site.siteId,
-		siteUrl: site.siteUrl
-	};
-}
-function requireCloud(cloud) {
-	if (!cloud) {
-		logger.error("Sync requires cloud mode. Run gscdump init to set up cloud mode.");
-		process$1.exit(1);
-	}
-}
-const statusCommand = defineCommand({
+const statsCommand = defineCommand({
 	meta: {
-		name: "status",
-		description: "Check sync status for a site"
+		name: "stats",
+		description: "Show row/byte counts per table and on-disk footprint"
 	},
 	args: {
-		site: {
-			type: "string",
-			alias: "s",
-			description: "Site URL"
-		},
 		json: {
 			type: "boolean",
 			default: false,
 			description: "Output as JSON"
+		},
+		site: {
+			type: "string",
+			description: "Limit to one site URL (sc-domain:example.com, https://example.com/, ...)"
 		}
 	},
 	async run({ args }) {
-		const cloud = await getCloudClient();
-		requireCloud(cloud);
-		const config = await loadConfig();
-		const { siteId } = await resolveCloudSite(cloud, args.site || config.defaultSite);
-		const status = await cloud.syncStatus(siteId).catch((e) => {
-			logger.error(`Failed to fetch sync status: ${e.message}`);
-			process$1.exit(1);
+		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) {
-			console.log(JSON.stringify(status, null, 2));
+			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${status.siteUrl}\x1B[0m`);
+		console.log(`  \x1B[1m${store.dataDir}\x1B[0m`);
+		console.log(`  \x1B[90mDisk: ${disk.files} file(s), ${formatBytes(disk.bytes)}\x1B[0m`);
 		console.log();
-		const statusColor = status.syncStatus === "synced" ? "\x1B[32m" : status.isSyncing ? "\x1B[33m" : status.syncStatus === "error" ? "\x1B[31m" : "\x1B[90m";
-		console.log(`  Status:   ${statusColor}${status.syncStatus}\x1B[0m`);
-		console.log(`  Progress: ${progressBar(status.progress, 100, `${status.progress}%`)}`);
-		console.log(`  Days:     \x1B[36m${status.daysSynced}\x1B[0m / ${status.daysAvailable} synced`);
-		if (status.oldestDateSynced) console.log(`  Range:    ${status.oldestDateSynced} \x1B[90m→\x1B[0m ${status.newestDateSynced}`);
+		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[1mJobs\x1B[0m");
-		console.log(`  Queued:     ${status.jobs.queued}`);
-		console.log(`  Processing: ${status.jobs.processing}`);
-		console.log(`  Completed:  \x1B[32m${status.jobs.completed}\x1B[0m`);
-		if (status.jobs.failed > 0) console.log(`  Failed:     \x1B[31m${status.jobs.failed}\x1B[0m`);
-		const tableNames = Object.keys(status.tables);
-		if (tableNames.length > 0) {
+		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[1mTables\x1B[0m");
-			for (const name of tableNames) {
-				const t = status.tables[name];
-				const rows = t.totalRows > 0 ? ` (${t.totalRows.toLocaleString()} rows)` : "";
-				console.log(`  ${name}: \x1B[32m${t.completed}\x1B[0m done, ${t.queued} queued${t.failed > 0 ? `, \x1B[31m${t.failed} failed\x1B[0m` : ""}${rows}`);
+			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`);
 			}
 		}
-		if (status.failedJobs.length > 0) {
-			console.log();
-			console.log("  \x1B[31mFailed Jobs\x1B[0m");
-			for (const j of status.failedJobs.slice(0, 5)) console.log(`  ${j.date} ${j.tableName}: ${j.error}`);
-			if (status.failedJobs.length > 5) console.log(`  \x1B[90m... and ${status.failedJobs.length - 5} more\x1B[0m`);
-		}
 		console.log();
 	}
 });
-const triggerCommand = 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: "trigger",
-		description: "Trigger a fresh sync for a site"
+		name: "store",
+		description: "Manage the local DuckDB/Parquet store"
 	},
-	args: { site: {
-		type: "string",
-		alias: "s",
-		description: "Site URL"
-	} },
-	async run({ args }) {
-		const cloud = await getCloudClient();
-		requireCloud(cloud);
-		const config = await loadConfig();
-		const { siteId, siteUrl } = await resolveCloudSite(cloud, args.site || config.defaultSite);
-		const result = await cloud.triggerSync(siteId).catch((e) => {
-			logger.error(`Failed to trigger sync: ${e.message}`);
-			process$1.exit(1);
-		});
-		logger.success(`Sync triggered for ${siteUrl}`);
-		console.log(`  ${result.message}`);
-		console.log();
+	subCommands: {
+		stats: statsCommand,
+		compact: compactCommand,
+		gc: gcCommand,
+		export: exportCommand,
+		rollups: rollupsCommand
 	}
 });
+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: "sync",
-		description: "Sync status and management (cloud mode only)"
+		description: "Sync GSC data to local Parquet store"
 	},
-	subCommands: {
-		status: statusCommand,
-		trigger: triggerCommand
-	}
-});
-//#endregion
-//#region src/commands/unregister.ts
-const unregisterCommand = defineCommand({
-	meta: {
-		name: "unregister",
-		description: "Unregister a site from syncing (cloud mode only)"
+	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: { site: {
-		type: "positional",
-		description: "Site URL to unregister",
-		required: false
-	} },
 	async run({ args }) {
-		const cloud = await getCloudClient();
-		if (!cloud) {
-			logger.error("Unregister requires cloud mode. Run gscdump init to set up.");
-			process$1.exit(1);
+		if (args.status) {
+			await printSyncStatus(await loadConfig(), args.site ? String(args.site) : void 0, Boolean(args.json));
+			return;
 		}
-		const config = await loadConfig();
-		const target = args.site || config.defaultSite;
-		const me = await cloud.me().catch((e) => {
-			logger.error(`Failed to fetch sites: ${e.message}`);
-			process$1.exit(1);
+		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
 		});
-		if (me.sites.length === 0) {
-			logger.warn("No registered sites.");
+		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;
 		}
-		let site = target ? me.sites.find((s) => s.siteUrl === target || s.siteUrl.includes(target)) : void 0;
-		if (!site) {
-			const selected = await select({
-				message: "Select a site to unregister",
-				options: me.sites.map((s) => ({
-					value: s.siteId,
-					label: s.siteUrl,
-					hint: s.syncStatus || "unknown"
-				}))
+		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
 			});
-			if (isCancel(selected)) {
-				cancel("Cancelled");
-				process$1.exit(0);
+		}
+		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}`);
 			}
-			site = me.sites.find((s) => s.siteId === selected);
+			console.log();
 		}
-		const confirmed = await confirm({ message: `Unregister ${site.siteUrl}? This will stop syncing and delete pending jobs.` });
-		if (isCancel(confirmed) || !confirmed) {
-			cancel("Cancelled");
-			process$1.exit(0);
+		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).`);
+			}
 		}
-		const result = await cloud.deleteSite(site.siteId).catch((e) => {
-			logger.error(`Failed to unregister: ${e.message}`);
-			process$1.exit(1);
-		});
-		logger.success(`Unregistered ${result.siteUrl}`);
+		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",
@@ -3118,19 +2805,17 @@ runMain(defineCommand({
 		query: queryCommand,
 		sites: sitesCommand,
 		sitemaps: sitemapsCommand,
-		register: registerCommand,
-		unregister: unregisterCommand,
 		sync: syncCommand,
-		indexing: indexingCommand,
-		analysis: analysisCommand,
+		store: storeCommand,
+		inspect: inspectCommand,
+		entities: entitiesCommand,
+		analyze: analyzeCommand,
 		auth: authCommand,
 		config: configCommand,
 		mcp: mcpCommand
 	},
 	setup() {
-		if (!process$1.argv.includes("mcp")) showSplash();
+		if (!process.argv.includes("mcp")) showSplash();
 	}
 }));
-//#endregion
-export {  };
+export {};