inboxctl 0.1.0

package/dist/cli.js

@@ -0,0 +1,4668 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_GOOGLE_REDIRECT_URI,
+  GMAIL_SCOPES,
+  addExecutionItems,
+  archiveEmails,
+  clearGmailTransportOverride,
+  closeDb,
+  createExecutionRun,
+  createFilter,
+  createLabel,
+  createOAuthClient,
+  deleteFilter,
+  deployAllRules,
+  deployLoadedRule,
+  detectDrift,
+  disableRule,
+  enableRule,
+  ensureDir,
+  forwardEmail,
+  fullSync,
+  getAllRulesStatus,
+  getConfigFilePath,
+  getDefaultDataDir,
+  getExecutionHistory,
+  getFilter,
+  getGmailReadiness,
+  getGmailTransport,
+  getGoogleCredentialStatus,
+  getInboxOverview,
+  getLabelDistribution,
+  getMessage,
+  getNewsletters,
+  getOAuthReadiness,
+  getRecentEmails,
+  getRecentRuns,
+  getRuleStatus,
+  getRunsByEmail,
+  getSenderStats,
+  getSqlite,
+  getSyncStatus,
+  getTopSenders,
+  getVolumeByPeriod,
+  incrementalSync,
+  initializeDb,
+  isTokenExpired,
+  labelEmails,
+  listFilters,
+  listLabels,
+  listMessages,
+  loadConfig,
+  loadRuleFile,
+  loadTokens,
+  markRead,
+  markUnread,
+  reconcileCacheForAuthenticatedAccount,
+  runAllRules,
+  runRule,
+  saveTokens,
+  setGmailTransportOverride,
+  startMcpServer,
+  startOAuthFlow,
+  syncLabels,
+  undoRun
+} from "./chunk-EY6VV43S.js";
+
+// src/cli.ts
+import { Command } from "commander";
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+
+// src/core/demo/index.ts
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+// src/tui/app.tsx
+import { convert } from "html-to-text";
+import {
+  Box,
+  Newline,
+  Spacer,
+  Text,
+  render,
+  useApp,
+  useInput,
+  useStdout
+} from "ink";
+import Spinner from "ink-spinner";
+import TextInput from "ink-text-input";
+import { useEffect, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var PAGE_SIZE = 20;
+var SEARCH_LIMIT = 50;
+var MIN_CONTENT_HEIGHT = 10;
+function stripAnsi(value) {
+  return value.replace(/\u001B\[[0-9;]*m/g, "");
+}
+function pad(value, width) {
+  const visible = stripAnsi(value);
+  if (visible.length >= width) {
+    return value;
+  }
+  return `${value}${" ".repeat(width - visible.length)}`;
+}
+function truncate(value, width) {
+  if (width <= 0) {
+    return "";
+  }
+  if (value.length <= width) {
+    return value;
+  }
+  if (width === 1) {
+    return value.slice(0, 1);
+  }
+  return `${value.slice(0, width - 1)}\u2026`;
+}
+function flattenWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function sanitizeInlineText(value, width) {
+  let next = value.replace(/[\r\n\t]+/g, " ");
+  if (/<[a-z][\s\S]*>/i.test(next)) {
+    next = convert(next, {
+      wordwrap: false,
+      selectors: [{ selector: "a", options: { ignoreHref: true } }]
+    });
+  }
+  next = flattenWhitespace(next);
+  return width ? truncate(next, width) : next;
+}
+function formatFlashText(value) {
+  return sanitizeInlineText(value, 240);
+}
+function formatRelativeTime(value) {
+  if (!value) {
+    return "-";
+  }
+  const timestamp = value instanceof Date ? value.getTime() : value;
+  const diff = Date.now() - timestamp;
+  if (diff < 6e4) {
+    return `${Math.max(1, Math.floor(diff / 1e3))}s ago`;
+  }
+  if (diff < 36e5) {
+    return `${Math.floor(diff / 6e4)}m ago`;
+  }
+  if (diff < 864e5) {
+    return `${Math.floor(diff / 36e5)}h ago`;
+  }
+  if (diff < 6048e5) {
+    return `${Math.floor(diff / 864e5)}d ago`;
+  }
+  return new Date(timestamp).toISOString().slice(0, 10);
+}
+function formatPercent(value) {
+  return `${Number.isInteger(value) ? value : Number(value.toFixed(1))}%`;
+}
+function formatCount(value) {
+  if (value == null) {
+    return "-";
+  }
+  return new Intl.NumberFormat("en-US").format(value);
+}
+function formatDurationEstimate(seconds) {
+  if (seconds < 60) {
+    return `${Math.max(1, Math.round(seconds))}s`;
+  }
+  if (seconds < 3600) {
+    const minutes2 = Math.floor(seconds / 60);
+    const remainingSeconds = Math.round(seconds % 60);
+    return remainingSeconds === 0 ? `${minutes2}m` : `${minutes2}m ${remainingSeconds}s`;
+  }
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.round(seconds % 3600 / 60);
+  return minutes === 0 ? `${hours}h` : `${hours}h ${minutes}m`;
+}
+function getMinimumItemsForEta(total) {
+  if (!total || total <= 0) {
+    return 500;
+  }
+  return Math.min(2e3, Math.max(500, Math.floor(total * 0.01)));
+}
+function clampIndex(index, length) {
+  if (length <= 0) {
+    return 0;
+  }
+  return Math.max(0, Math.min(index, length - 1));
+}
+function terminalWidth() {
+  return process.stdout.columns || 100;
+}
+function terminalHeight() {
+  return process.stdout.rows || 30;
+}
+function toneColor(tone) {
+  switch (tone) {
+    case "success":
+      return "green";
+    case "error":
+      return "red";
+    case "info":
+      return "blue";
+  }
+}
+function getBodyText(detail) {
+  if (detail.textPlain?.trim()) {
+    return detail.textPlain.trim();
+  }
+  if (detail.bodyHtml?.trim()) {
+    return convert(detail.bodyHtml, {
+      wordwrap: Math.max(terminalWidth() - 10, 40)
+    }).trim();
+  }
+  return detail.body?.trim() || detail.snippet || "";
+}
+function useTerminalSize() {
+  const { stdout } = useStdout();
+  const [size, setSize] = useState({
+    columns: stdout.columns || terminalWidth(),
+    rows: stdout.rows || terminalHeight()
+  });
+  useEffect(() => {
+    function handleResize() {
+      setSize({
+        columns: stdout.columns || terminalWidth(),
+        rows: stdout.rows || terminalHeight()
+      });
+    }
+    handleResize();
+    stdout.on("resize", handleResize);
+    return () => {
+      stdout.off("resize", handleResize);
+    };
+  }, [stdout]);
+  return size;
+}
+function getViewportRange(length, selectedIndex, visibleCount) {
+  if (length <= visibleCount) {
+    return { start: 0, end: length };
+  }
+  const half = Math.floor(visibleCount / 2);
+  const start = Math.max(0, Math.min(selectedIndex - half, length - visibleCount));
+  return {
+    start,
+    end: Math.min(length, start + visibleCount)
+  };
+}
+function getScreenGuide(screen, focus) {
+  const global = "q quit  \u2022  s sync  \u2022  / search  \u2022  d stats  \u2022  R rules";
+  switch (screen) {
+    case "inbox":
+      return `${global}  \u2022  j/k move  \u2022  Enter open  \u2022  a archive  \u2022  l label  \u2022  r read`;
+    case "email":
+      return "Esc back  \u2022  j/k scroll  \u2022  a archive  \u2022  l label  \u2022  r toggle read";
+    case "stats":
+      return "Esc back  \u2022  s senders  \u2022  l labels  \u2022  n newsletters";
+    case "rules":
+      return `Esc back  \u2022  Tab switch ${focus === "history" ? "history" : "rules"} focus  \u2022  d deploy  \u2022  e toggle  \u2022  r dry-run  \u2022  R apply  \u2022  u undo`;
+    case "search":
+      return `Esc back  \u2022  Enter search  \u2022  i focus input  \u2022  ${focus === "input" ? "type Gmail query" : "j/k move  \u2022  Enter open  \u2022  a archive  \u2022  l label  \u2022  r read"}`;
+  }
+}
+function renderProgressBar(current, total, width) {
+  if (total <= 0 || width <= 0) {
+    return "";
+  }
+  const ratio = Math.max(0, Math.min(1, current / total));
+  const filled = Math.round(ratio * width);
+  return `${"\u2588".repeat(filled)}${"\u2591".repeat(Math.max(0, width - filled))}`;
+}
+function Panel(props) {
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: props.accent || "cyan",
+      paddingX: 1,
+      paddingY: 0,
+      width: "100%",
+      children: [
+        /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsx(Text, { bold: true, color: props.accent || "cyan", children: props.title }),
+          /* @__PURE__ */ jsx(Spacer, {}),
+          props.subtitle ? /* @__PURE__ */ jsx(Text, { color: "gray", children: props.subtitle }) : null
+        ] }),
+        props.children
+      ]
+    }
+  );
+}
+function Header(props) {
+  const items = [
+    { key: "inbox", label: "Inbox" },
+    { key: "email", label: "Email" },
+    { key: "stats", label: "Stats" },
+    { key: "rules", label: "Rules" },
+    { key: "search", label: "Search" }
+  ];
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      width: props.columns,
+      borderStyle: "round",
+      borderColor: "blue",
+      paddingX: 1,
+      paddingY: 0,
+      flexDirection: "column",
+      children: [
+        /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "inboxctl" }),
+          /* @__PURE__ */ jsx(Text, { color: "gray", children: "  local-first Gmail cockpit" }),
+          /* @__PURE__ */ jsx(Spacer, {}),
+          /* @__PURE__ */ jsx(Text, { color: props.sync.syncing ? "yellow" : "gray", children: props.sync.syncing ? props.sync.message : "ready" })
+        ] }),
+        /* @__PURE__ */ jsx(Box, { marginTop: 1, children: items.map((item, index) => /* @__PURE__ */ jsx(Box, { marginRight: index === items.length - 1 ? 0 : 2, children: /* @__PURE__ */ jsx(Text, { color: props.screen === item.key ? "black" : "gray", backgroundColor: props.screen === item.key ? "cyan" : void 0, children: ` ${item.label} ` }) }, item.key)) }),
+        /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: truncate(props.guide, Math.max(20, props.columns - 4)) }) })
+      ]
+    }
+  );
+}
+function EmailList(props) {
+  const senderWidth = 28;
+  const dateWidth = 10;
+  const subjectWidth = Math.max(terminalWidth() - senderWidth - dateWidth - 20, 20);
+  const { start, end } = getViewportRange(props.emails.length, props.selectedIndex, props.visibleRows);
+  const visibleEmails = props.emails.slice(start, end);
+  return /* @__PURE__ */ jsxs(
+    Panel,
+    {
+      title: props.title,
+      subtitle: props.subtitle || `${props.emails.length} loaded`,
+      accent: "cyan",
+      children: [
+        /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+          pad("STATE", 6),
+          " ",
+          pad("FROM", senderWidth),
+          " ",
+          pad("DATE", dateWidth),
+          " SUBJECT"
+        ] }),
+        props.loading ? /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+          /* @__PURE__ */ jsx(Spinner, { type: "dots" }),
+          " Loading inbox\u2026"
+        ] }) }) : props.emails.length === 0 ? /* @__PURE__ */ jsx(Text, { color: "gray", children: props.emptyMessage }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+          visibleEmails.map((email, index) => {
+            const absoluteIndex = start + index;
+            const selected = absoluteIndex === props.selectedIndex;
+            const sender = sanitizeInlineText(email.fromName || email.fromAddress || "(unknown)", senderWidth);
+            const subject = sanitizeInlineText(email.subject || "(no subject)", subjectWidth);
+            const state = email.isRead ? " " : "\u25CF";
+            return /* @__PURE__ */ jsxs(
+              Text,
+              {
+                backgroundColor: selected ? "white" : void 0,
+                color: selected ? "black" : !email.isRead ? "white" : "gray",
+                bold: !email.isRead,
+                children: [
+                  pad(state, 6),
+                  " ",
+                  pad(sender, senderWidth),
+                  " ",
+                  pad(formatRelativeTime(email.date), dateWidth),
+                  " ",
+                  subject
+                ]
+              },
+              email.id
+            );
+          }),
+          /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+            "showing ",
+            start + 1,
+            "-",
+            end,
+            " of ",
+            props.emails.length
+          ] }) })
+        ] })
+      ]
+    }
+  );
+}
+function Table(props) {
+  const widths = props.headers.map(
+    (header, index) => Math.max(
+      header.length,
+      ...props.rows.map((row) => stripAnsi(row[index] || "").length)
+    )
+  );
+  return /* @__PURE__ */ jsx(Panel, { title: props.title, accent: "magenta", children: props.rows.length === 0 ? /* @__PURE__ */ jsx(Text, { color: "gray", children: props.emptyMessage }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Text, { color: "gray", children: props.headers.map((header, index) => pad(header, widths[index] || header.length)).join("  ") }),
+    props.rows.map((row, index) => /* @__PURE__ */ jsx(Text, { children: row.map((cell, cellIndex) => pad(cell, widths[cellIndex] || cell.length)).join("  ") }, `${props.title}-${index}`))
+  ] }) });
+}
+function Modal(props) {
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      borderStyle: "round",
+      borderColor: "cyan",
+      paddingX: 1,
+      paddingY: 0,
+      marginTop: 1,
+      flexDirection: "column",
+      children: [
+        /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: props.title }),
+        props.children
+      ]
+    }
+  );
+}
+function StatusBar(props) {
+  const lastSync = props.sync.lastSync ? formatRelativeTime(props.sync.lastSync) : "never";
+  const progressWidth = Math.max(12, Math.min(36, Math.floor((props.columns - 48) / 2)));
+  const hasProgressBar = props.sync.syncing && props.sync.progressTotal !== null && props.sync.progressTotal > 0;
+  const progressBar = hasProgressBar ? renderProgressBar(
+    props.sync.progressCurrent,
+    props.sync.progressTotal || 0,
+    progressWidth
+  ) : "";
+  const progressSummary = hasProgressBar ? `${formatCount(props.sync.progressCurrent)} / ${formatCount(props.sync.progressTotal)}` : props.sync.syncing ? props.sync.progressMode === "incremental" ? "checking for changes" : "preparing sync" : `Last sync ${lastSync}`;
+  const elapsedSeconds = props.sync.startedAt ? Math.max(1, (Date.now() - props.sync.startedAt) / 1e3) : 0;
+  const remainingItems = props.sync.progressTotal !== null ? Math.max(0, props.sync.progressTotal - props.sync.progressCurrent) : 0;
+  const minimumItemsForEta = getMinimumItemsForEta(props.sync.progressTotal);
+  const canShowEta = hasProgressBar && props.sync.progressMode === "full" && props.sync.progressPhase === "fetching_messages" && props.sync.ratePerSecond !== null && props.sync.ratePerSecond > 0 && elapsedSeconds >= 15 && props.sync.progressCurrent >= minimumItemsForEta && remainingItems > 0;
+  const etaSummary = canShowEta ? `ETA ~${formatDurationEstimate(remainingItems / (props.sync.ratePerSecond || 1))}` : hasProgressBar && props.sync.progressMode === "full" && props.sync.progressPhase === "fetching_messages" && props.sync.progressCurrent > 0 && remainingItems > 0 ? "ETA calculating\u2026" : null;
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      borderStyle: "round",
+      borderColor: props.flash ? toneColor(props.flash.tone) : "gray",
+      paddingX: 1,
+      paddingY: 0,
+      flexDirection: "column",
+      width: "100%",
+      children: [
+        /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsx(Text, { color: "cyan", children: "inboxctl" }),
+          /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+            "  ",
+            props.email || "not authenticated"
+          ] }),
+          /* @__PURE__ */ jsx(Spacer, {}),
+          /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
+            props.unreadCount,
+            " unread"
+          ] }),
+          /* @__PURE__ */ jsx(Text, { color: "gray", children: "  |  " }),
+          /* @__PURE__ */ jsx(Text, { color: "gray", children: truncate(progressSummary, Math.max(18, props.columns - 56)) }),
+          /* @__PURE__ */ jsx(Text, { color: "gray", children: "  |  " }),
+          /* @__PURE__ */ jsx(Text, { color: "magenta", children: props.screen })
+        ] }),
+        props.sync.syncing ? /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(Newline, {}),
+          /* @__PURE__ */ jsxs(Box, { children: [
+            /* @__PURE__ */ jsx(Text, { color: props.sync.progressMode === "full" ? "yellow" : "cyan", children: props.sync.progressMode === "full" ? "full" : "incr" }),
+            /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+              "  ",
+              truncate(props.sync.message, Math.max(24, props.columns - 34))
+            ] }),
+            hasProgressBar ? /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsx(Spacer, {}),
+              etaSummary ? /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+                etaSummary,
+                "  "
+              ] }) : null,
+              /* @__PURE__ */ jsx(Text, { color: "green", children: progressBar }),
+              /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+                "  ",
+                formatPercent(props.sync.progressCurrent / (props.sync.progressTotal || 1) * 100)
+              ] })
+            ] }) : null
+          ] })
+        ] }) : null,
+        props.flash ? /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(Newline, {}),
+          /* @__PURE__ */ jsx(Text, { color: toneColor(props.flash.tone), children: props.flash.text })
+        ] }) : null
+      ]
+    }
+  );
+}
+function App({ initialSync = true }) {
+  const { exit } = useApp();
+  const { columns, rows } = useTerminalSize();
+  const config = loadConfig();
+  const [screen, setScreen] = useState("inbox");
+  const [emailOrigin, setEmailOrigin] = useState("inbox");
+  const [flash, setFlash] = useState(null);
+  const [confirmState, setConfirmState] = useState(null);
+  const [authEmail, setAuthEmail] = useState(null);
+  const [syncState, setSyncState] = useState({
+    syncing: false,
+    message: "Syncing\u2026",
+    lastSync: null,
+    totalMessages: 0,
+    resumableProgressCurrent: 0,
+    resumableProgressTotal: null,
+    progressCurrent: 0,
+    progressTotal: null,
+    progressMode: null,
+    progressPhase: null,
+    startedAt: null,
+    progressStartedAt: null,
+    lastProgressAt: null,
+    lastProgressCurrent: 0,
+    ratePerSecond: null
+  });
+  const [unreadCount, setUnreadCount] = useState(0);
+  const [inboxEmails, setInboxEmails] = useState([]);
+  const [inboxSelectedIndex, setInboxSelectedIndex] = useState(0);
+  const [inboxLoading, setInboxLoading] = useState(true);
+  const [inboxHasMore, setInboxHasMore] = useState(true);
+  const [selectedEmailId, setSelectedEmailId] = useState(null);
+  const [emailDetail, setEmailDetail] = useState(null);
+  const [emailBody, setEmailBody] = useState("");
+  const [emailLoading, setEmailLoading] = useState(false);
+  const [emailScroll, setEmailScroll] = useState(0);
+  const [statsLoading, setStatsLoading] = useState(false);
+  const [statsTab, setStatsTab] = useState("senders");
+  const [statsOverview, setStatsOverview] = useState(null);
+  const [statsSenders, setStatsSenders] = useState([]);
+  const [statsLabels, setStatsLabels] = useState([]);
+  const [statsNewsletters, setStatsNewsletters] = useState([]);
+  const [statsVolume, setStatsVolume] = useState([]);
+  const [rulesLoading, setRulesLoading] = useState(false);
+  const [rulesFocus, setRulesFocus] = useState("rules");
+  const [rules2, setRules] = useState([]);
+  const [rulesSelectedIndex, setRulesSelectedIndex] = useState(0);
+  const [ruleHistory, setRuleHistory] = useState([]);
+  const [historySelectedIndex, setHistorySelectedIndex] = useState(0);
+  const [searchQuery, setSearchQuery] = useState("");
+  const [searchFocus, setSearchFocus] = useState("input");
+  const [searchLoading, setSearchLoading] = useState(false);
+  const [searchResults, setSearchResults] = useState([]);
+  const [searchSelectedIndex, setSearchSelectedIndex] = useState(0);
+  const [labelPicker, setLabelPicker] = useState({
+    open: false,
+    loading: false,
+    labels: [],
+    selectedIndex: 0,
+    targetEmailId: null,
+    createMode: false,
+    newLabelName: ""
+  });
+  function pushFlash(tone, text2) {
+    setFlash({ tone, text: formatFlashText(text2) });
+  }
+  async function refreshStatus() {
+    const [syncStatus, overview, tokens] = await Promise.all([
+      getSyncStatus(),
+      getInboxOverview(),
+      loadTokens(config.tokensPath)
+    ]);
+    setSyncState((current) => ({
+      ...current,
+      lastSync: syncStatus.lastIncrementalSync ?? syncStatus.lastFullSync,
+      totalMessages: syncStatus.totalMessages,
+      resumableProgressCurrent: syncStatus.fullSyncProcessed,
+      resumableProgressTotal: syncStatus.fullSyncTotal
+    }));
+    setUnreadCount(overview.unread);
+    setAuthEmail(tokens?.email && tokens.email !== "unknown" ? tokens.email : null);
+  }
+  async function loadInbox(reset) {
+    setInboxLoading(true);
+    try {
+      const offset = reset ? 0 : inboxEmails.length;
+      const rows2 = await getRecentEmails(PAGE_SIZE, offset);
+      setInboxEmails((current) => reset ? rows2 : [...current, ...rows2]);
+      setInboxHasMore(rows2.length === PAGE_SIZE);
+      setInboxSelectedIndex((current) => clampIndex(reset ? 0 : current, reset ? rows2.length : offset + rows2.length));
+    } catch (error) {
+      pushFlash("error", error instanceof Error ? error.message : String(error));
+    } finally {
+      setInboxLoading(false);
+    }
+  }
+  async function loadStats() {
+    setStatsLoading(true);
+    try {
+      const [overview, senders, labels2, newsletters, volume] = await Promise.all([
+        getInboxOverview(),
+        getTopSenders({ limit: 10 }),
+        getLabelDistribution(),
+        getNewsletters({ minMessages: 1 }),
+        getVolumeByPeriod("day", { start: Date.now() - 30 * 24 * 60 * 60 * 1e3, end: Date.now() })
+      ]);
+      setStatsOverview(overview);
+      setStatsSenders(senders);
+      setStatsLabels(labels2.slice(0, 10));
+      setStatsNewsletters(newsletters.slice(0, 10));
+      setStatsVolume(volume.slice(-7));
+    } catch (error) {
+      pushFlash("error", error instanceof Error ? error.message : String(error));
+    } finally {
+      setStatsLoading(false);
+    }
+  }
+  async function loadRules() {
+    setRulesLoading(true);
+    try {
+      const [nextRules, nextHistory] = await Promise.all([
+        getAllRulesStatus(),
+        getExecutionHistory(void 0, 10)
+      ]);
+      setRules(nextRules);
+      setRuleHistory(nextHistory);
+      setRulesSelectedIndex((current) => clampIndex(current, nextRules.length));
+      setHistorySelectedIndex((current) => clampIndex(current, nextHistory.length));
+    } catch (error) {
+      pushFlash("error", error instanceof Error ? error.message : String(error));
+    } finally {
+      setRulesLoading(false);
+    }
+  }
+  async function loadEmailDetail(emailId) {
+    setEmailLoading(true);
+    setEmailScroll(0);
+    try {
+      const detail = await getMessage(emailId);
+      setEmailDetail(detail);
+      setEmailBody(getBodyText(detail));
+    } catch (error) {
+      setEmailDetail(null);
+      setEmailBody("");
+      pushFlash("error", error instanceof Error ? error.message : String(error));
+    } finally {
+      setEmailLoading(false);
+    }
+  }
+  async function runSync(message) {
+    const startedAt = Date.now();
+    setSyncState((current) => ({
+      ...current,
+      syncing: true,
+      message,
+      progressCurrent: current.resumableProgressCurrent,
+      progressTotal: current.resumableProgressTotal,
+      progressMode: current.resumableProgressCurrent > 0 ? "full" : null,
+      progressPhase: current.resumableProgressCurrent > 0 ? "starting" : "starting",
+      startedAt,
+      progressStartedAt: null,
+      lastProgressAt: startedAt,
+      lastProgressCurrent: current.resumableProgressCurrent,
+      ratePerSecond: null
+    }));
+    try {
+      await incrementalSync(
+        (synced, total) => {
+          setSyncState((current) => {
+            const now = Date.now();
+            const progressStartedAt = current.progressStartedAt ?? (synced > 0 ? now : null);
+            const elapsedSinceProgressStart = progressStartedAt ? (now - progressStartedAt) / 1e3 : 0;
+            const nextRate = synced > 0 && elapsedSinceProgressStart > 0 ? synced / elapsedSinceProgressStart : current.ratePerSecond;
+            return {
+              ...current,
+              progressCurrent: synced,
+              progressTotal: total,
+              progressStartedAt,
+              lastProgressAt: now,
+              lastProgressCurrent: Math.max(current.lastProgressCurrent, synced),
+              ratePerSecond: nextRate
+            };
+          });
+        },
+        (event) => {
+          setSyncState((current) => ({
+            ...current,
+            message: event.detail,
+            progressCurrent: event.synced,
+            progressTotal: event.total,
+            progressMode: event.mode,
+            progressPhase: event.phase
+          }));
+        }
+      );
+      await Promise.all([
+        refreshStatus(),
+        loadInbox(true),
+        screen === "stats" ? loadStats() : Promise.resolve(),
+        screen === "rules" ? loadRules() : Promise.resolve()
+      ]);
+      pushFlash("success", "Inbox sync complete.");
+    } catch (error) {
+      pushFlash("error", error instanceof Error ? error.message : String(error));
+    } finally {
+      setSyncState((current) => ({
+        ...current,
+        syncing: false,
+        progressCurrent: 0,
+        progressTotal: null,
+        progressMode: null,
+        progressPhase: null,
+        startedAt: null,
+        progressStartedAt: null,
+        lastProgressAt: null,
+        lastProgressCurrent: 0,
+        ratePerSecond: null
+      }));
+    }
+  }
+  async function refreshAfterMutation() {
+    await Promise.all([
+      refreshStatus(),
+      loadInbox(true),
+      screen === "stats" ? loadStats() : Promise.resolve(),
+      screen === "rules" ? loadRules() : Promise.resolve(),
+      selectedEmailId && screen === "email" ? loadEmailDetail(selectedEmailId) : Promise.resolve()
+    ]);
+  }
+  function currentListSelection() {
+    if (screen === "search") {
+      return searchResults[searchSelectedIndex] || null;
+    }
+    return inboxEmails[inboxSelectedIndex] || null;
+  }
+  async function archiveCurrentEmail() {
+    const email = screen === "email" ? emailDetail : currentListSelection();
+    if (!email) {
+      return;
+    }
+    try {
+      await archiveEmails([email.id]);
+      pushFlash("success", `Archived ${email.subject || email.id}.`);
+      await refreshAfterMutation();
+    } catch (error) {
+      pushFlash("error", error instanceof Error ? error.message : String(error));
+    }
+  }
+  async function toggleReadCurrentEmail() {
+    const email = screen === "email" ? emailDetail : currentListSelection();
+    if (!email) {
+      return;
+    }
+    try {
+      if (email.isRead) {
+        await markUnread([email.id]);
+        pushFlash("success", `Marked ${email.subject || email.id} as unread.`);
+      } else {
+        await markRead([email.id]);
+        pushFlash("success", `Marked ${email.subject || email.id} as read.`);
+      }
+      await refreshAfterMutation();
+    } catch (error) {
+      pushFlash("error", error instanceof Error ? error.message : String(error));
+    }
+  }
+  async function openLabelPicker(targetEmailId) {
+    if (!targetEmailId) {
+      return;
+    }
+    setLabelPicker({
+      open: true,
+      loading: true,
+      labels: [],
+      selectedIndex: 0,
+      targetEmailId,
+      createMode: false,
+      newLabelName: ""
+    });
+    try {
+      const labels2 = await listLabels();
+      setLabelPicker((current) => ({
+        ...current,
+        loading: false,
+        labels: labels2
+      }));
+    } catch (error) {
+      setLabelPicker((current) => ({
+        ...current,
+        loading: false
+      }));
+      pushFlash("error", error instanceof Error ? error.message : String(error));
+    }
+  }
+  async function applySelectedLabel(labelName) {
+    if (!labelPicker.targetEmailId) {
+      return;
+    }
+    try {
+      await labelEmails([labelPicker.targetEmailId], labelName);
+      setLabelPicker((current) => ({
+        ...current,
+        open: false
+      }));
+      pushFlash("success", `Applied label ${labelName}.`);
+      await refreshAfterMutation();
+    } catch (error) {
+      pushFlash("error", error instanceof Error ? error.message : String(error));
+    }
+  }
+  async function createAndApplyLabel(name) {
+    const trimmed = name.trim();
+    if (!trimmed) {
+      pushFlash("error", "Label name cannot be empty.");
+      return;
+    }
+    try {
+      await createLabel(trimmed);
+      await applySelectedLabel(trimmed);
+    } catch (error) {
+      pushFlash("error", error instanceof Error ? error.message : String(error));
+    }
+  }
+  async function executeSearch(query) {
+    const trimmed = query.trim();
+    if (!trimmed) {
+      pushFlash("error", "Enter a Gmail query first.");
+      return;
+    }
+    setSearchLoading(true);
+    try {
+      const results = await listMessages(trimmed, SEARCH_LIMIT);
+      setSearchResults(results);
+      setSearchSelectedIndex(0);
+      setSearchFocus("results");
+      pushFlash("info", `${results.length} search results loaded.`);
+    } catch (error) {
+      pushFlash("error", error instanceof Error ? error.message : String(error));
+    } finally {
+      setSearchLoading(false);
+    }
+  }
+  function openSelectedEmail(email, origin) {
+    setEmailOrigin(origin);
+    setSelectedEmailId(email.id);
+    setScreen("email");
+  }
+  useEffect(() => {
+    void (async () => {
+      await Promise.all([
+        refreshStatus(),
+        loadInbox(true)
+      ]);
+      if (initialSync) {
+        await runSync("Syncing inbox\u2026");
+      }
+    })();
+  }, []);
+  useEffect(() => {
+    if (screen === "stats") {
+      void loadStats();
+    }
+    if (screen === "rules") {
+      void loadRules();
+    }
+  }, [screen]);
+  useEffect(() => {
+    if (screen === "email" && selectedEmailId) {
+      void loadEmailDetail(selectedEmailId);
+    }
+  }, [screen, selectedEmailId]);
+  useEffect(() => {
+    if (!flash) {
+      return;
+    }
+    const timeout = setTimeout(() => {
+      setFlash(null);
+    }, 3500);
+    return () => clearTimeout(timeout);
+  }, [flash]);
+  useInput((input2, key) => {
+    if (confirmState) {
+      if (input2 === "y" || input2 === "Y") {
+        const action = confirmState.onConfirm;
+        setConfirmState(null);
+        void action();
+      } else if (input2 === "n" || input2 === "N" || key.escape) {
+        setConfirmState(null);
+      }
+      return;
+    }
+    if (labelPicker.open) {
+      if (labelPicker.createMode) {
+        if (key.escape) {
+          setLabelPicker((current) => ({
+            ...current,
+            createMode: false,
+            newLabelName: ""
+          }));
+        }
+        return;
+      }
+      if (key.escape) {
+        setLabelPicker((current) => ({
+          ...current,
+          open: false
+        }));
+        return;
+      }
+      if (input2 === "j" || key.downArrow) {
+        setLabelPicker((current) => ({
+          ...current,
+          selectedIndex: clampIndex(current.selectedIndex + 1, current.labels.length)
+        }));
+        return;
+      }
+      if (input2 === "k" || key.upArrow) {
+        setLabelPicker((current) => ({
+          ...current,
+          selectedIndex: clampIndex(current.selectedIndex - 1, current.labels.length)
+        }));
+        return;
+      }
+      if (input2 === "c") {
+        setLabelPicker((current) => ({
+          ...current,
+          createMode: true,
+          newLabelName: ""
+        }));
+        return;
+      }
+      if (key.return) {
+        const label = labelPicker.labels[labelPicker.selectedIndex];
+        if (label) {
+          void applySelectedLabel(label.name);
+        }
+        return;
+      }
+      return;
+    }
+    if (screen === "search" && searchFocus === "input") {
+      if (key.escape) {
+        setScreen("inbox");
+      }
+      return;
+    }
+    if (input2 === "q") {
+      exit();
+      return;
+    }
+    if (screen === "inbox") {
+      if (input2 === "j" || key.downArrow) {
+        if (inboxSelectedIndex === inboxEmails.length - 1 && inboxHasMore && !inboxLoading) {
+          void loadInbox(false);
+        }
+        setInboxSelectedIndex((current) => clampIndex(current + 1, inboxEmails.length));
+        return;
+      }
+      if (input2 === "k" || key.upArrow) {
+        setInboxSelectedIndex((current) => clampIndex(current - 1, inboxEmails.length));
+        return;
+      }
+      if (key.return) {
+        const email = inboxEmails[inboxSelectedIndex];
+        if (email) {
+          openSelectedEmail(email, "inbox");
+        }
+        return;
+      }
+      if (input2 === "a") {
+        void archiveCurrentEmail();
+        return;
+      }
+      if (input2 === "l") {
+        void openLabelPicker(inboxEmails[inboxSelectedIndex]?.id || null);
+        return;
+      }
+      if (input2 === "r") {
+        void toggleReadCurrentEmail();
+        return;
+      }
+      if (input2 === "/") {
+        setScreen("search");
+        setSearchFocus("input");
+        return;
+      }
+      if (input2 === "s") {
+        void runSync("Syncing inbox\u2026");
+        return;
+      }
+      if (input2 === "d") {
+        setScreen("stats");
+        return;
+      }
+      if (input2 === "R") {
+        setScreen("rules");
+      }
+      return;
+    }
+    if (screen === "email") {
+      if (key.escape || key.backspace) {
+        setScreen(emailOrigin);
+        return;
+      }
+      if (input2 === "j" || key.downArrow) {
+        setEmailScroll((current) => current + 1);
+        return;
+      }
+      if (input2 === "k" || key.upArrow) {
+        setEmailScroll((current) => Math.max(0, current - 1));
+        return;
+      }
+      if (input2 === "a") {
+        void archiveCurrentEmail();
+        return;
+      }
+      if (input2 === "l") {
+        void openLabelPicker(selectedEmailId);
+        return;
+      }
+      if (input2 === "r") {
+        void toggleReadCurrentEmail();
+      }
+      return;
+    }
+    if (screen === "stats") {
+      if (key.escape || key.backspace) {
+        setScreen("inbox");
+        return;
+      }
+      if (input2 === "s") {
+        setStatsTab("senders");
+        return;
+      }
+      if (input2 === "l") {
+        setStatsTab("labels");
+        return;
+      }
+      if (input2 === "n") {
+        setStatsTab("newsletters");
+      }
+      return;
+    }
+    if (screen === "rules") {
+      if (key.escape || key.backspace) {
+        setScreen("inbox");
+        return;
+      }
+      if (key.tab) {
+        setRulesFocus((current) => current === "rules" ? "history" : "rules");
+        return;
+      }
+      if (input2 === "j" || key.downArrow) {
+        if (rulesFocus === "rules") {
+          setRulesSelectedIndex((current) => clampIndex(current + 1, rules2.length));
+        } else {
+          setHistorySelectedIndex((current) => clampIndex(current + 1, ruleHistory.length));
+        }
+        return;
+      }
+      if (input2 === "k" || key.upArrow) {
+        if (rulesFocus === "rules") {
+          setRulesSelectedIndex((current) => clampIndex(current - 1, rules2.length));
+        } else {
+          setHistorySelectedIndex((current) => clampIndex(current - 1, ruleHistory.length));
+        }
+        return;
+      }
+      if (input2 === "d") {
+        void (async () => {
+          try {
+            await deployAllRules(config.rulesDir);
+            pushFlash("success", "Rules deployed from YAML.");
+            await loadRules();
+          } catch (error) {
+            pushFlash("error", error instanceof Error ? error.message : String(error));
+          }
+        })();
+        return;
+      }
+      if (input2 === "e" && rulesFocus === "rules") {
+        const rule = rules2[rulesSelectedIndex];
+        if (!rule) {
+          return;
+        }
+        void (async () => {
+          try {
+            if (rule.enabled) {
+              await disableRule(rule.name);
+              pushFlash("success", `Disabled rule ${rule.name}.`);
+            } else {
+              await enableRule(rule.name);
+              pushFlash("success", `Enabled rule ${rule.name}.`);
+            }
+            await loadRules();
+          } catch (error) {
+            pushFlash("error", error instanceof Error ? error.message : String(error));
+          }
+        })();
+        return;
+      }
+      if (input2 === "r" && rulesFocus === "rules") {
+        const rule = rules2[rulesSelectedIndex];
+        if (!rule) {
+          return;
+        }
+        void (async () => {
+          try {
+            await runRule(rule.name, { dryRun: true, maxEmails: 100 });
+            pushFlash("success", `Dry-ran rule ${rule.name}.`);
+            await loadRules();
+          } catch (error) {
+            pushFlash("error", error instanceof Error ? error.message : String(error));
+          }
+        })();
+        return;
+      }
+      if (input2 === "R" && rulesFocus === "rules") {
+        const rule = rules2[rulesSelectedIndex];
+        if (!rule) {
+          return;
+        }
+        setConfirmState({
+          title: "Run Rule",
+          message: `Apply rule ${rule.name} against cached matches?`,
+          onConfirm: async () => {
+            try {
+              await runRule(rule.name, { dryRun: false, maxEmails: 100 });
+              pushFlash("success", `Applied rule ${rule.name}.`);
+              await refreshAfterMutation();
+              await loadRules();
+            } catch (error) {
+              pushFlash("error", error instanceof Error ? error.message : String(error));
+            }
+          }
+        });
+        return;
+      }
+      if (input2 === "u" && rulesFocus === "history") {
+        const run = ruleHistory[historySelectedIndex];
+        if (!run) {
+          return;
+        }
+        void (async () => {
+          try {
+            await undoRun(run.id);
+            pushFlash("success", `Undid run ${run.id}.`);
+            await refreshAfterMutation();
+            await loadRules();
+          } catch (error) {
+            pushFlash("error", error instanceof Error ? error.message : String(error));
+          }
+        })();
+      }
+      return;
+    }
+    if (screen === "search") {
+      if (key.escape || key.backspace) {
+        setScreen("inbox");
+        return;
+      }
+      if (input2 === "i") {
+        setSearchFocus("input");
+        return;
+      }
+      if (input2 === "j" || key.downArrow) {
+        setSearchSelectedIndex((current) => clampIndex(current + 1, searchResults.length));
+        return;
+      }
+      if (input2 === "k" || key.upArrow) {
+        setSearchSelectedIndex((current) => clampIndex(current - 1, searchResults.length));
+        return;
+      }
+      if (key.return) {
+        const email = searchResults[searchSelectedIndex];
+        if (email) {
+          openSelectedEmail(email, "search");
+        }
+        return;
+      }
+      if (input2 === "a") {
+        void archiveCurrentEmail();
+        return;
+      }
+      if (input2 === "l") {
+        void openLabelPicker(searchResults[searchSelectedIndex]?.id || null);
+        return;
+      }
+      if (input2 === "r") {
+        void toggleReadCurrentEmail();
+      }
+    }
+  });
+  const chromeHeight = 9;
+  const contentHeight = Math.max(MIN_CONTENT_HEIGHT, rows - chromeHeight);
+  const emailBodyHeight = Math.max(8, contentHeight - 8);
+  const listVisibleRows = Math.max(8, contentHeight - 6);
+  const emailBodyLines = emailBody.split("\n");
+  const visibleBodyLines = emailBodyLines.slice(emailScroll, emailScroll + emailBodyHeight);
+  const rulesVisibleCount = Math.max(5, Math.floor(contentHeight / 3));
+  const historyVisibleCount = Math.max(4, Math.floor(contentHeight / 4));
+  const rulesRange = getViewportRange(rules2.length, rulesSelectedIndex, rulesVisibleCount);
+  const historyRange = getViewportRange(
+    ruleHistory.length,
+    historySelectedIndex,
+    historyVisibleCount
+  );
+  const visibleRules = rules2.slice(rulesRange.start, rulesRange.end);
+  const visibleHistory = ruleHistory.slice(historyRange.start, historyRange.end);
+  const selectedRule = rules2[rulesSelectedIndex];
+  const selectedRun = ruleHistory[historySelectedIndex];
+  const screenGuide = getScreenGuide(
+    screen,
+    screen === "rules" ? rulesFocus : screen === "search" ? searchFocus : void 0
+  );
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: columns, height: rows, paddingX: 1, paddingY: 0, children: [
+    /* @__PURE__ */ jsx(
+      Header,
+      {
+        screen,
+        sync: syncState,
+        columns: Math.max(40, columns - 2),
+        guide: screenGuide
+      }
+    ),
+    /* @__PURE__ */ jsxs(Box, { height: contentHeight, flexDirection: "column", marginTop: 1, children: [
+      screen === "inbox" ? /* @__PURE__ */ jsx(
+        EmailList,
+        {
+          emails: inboxEmails,
+          selectedIndex: inboxSelectedIndex,
+          title: "Inbox",
+          loading: inboxLoading,
+          emptyMessage: "No cached emails yet. Sync to populate the local inbox.",
+          visibleRows: listVisibleRows,
+          subtitle: "Local cache first, background sync second"
+        }
+      ) : null,
+      screen === "email" ? /* @__PURE__ */ jsx(
+        Panel,
+        {
+          title: sanitizeInlineText(emailDetail?.subject || "Email Detail", Math.max(20, columns - 12)),
+          subtitle: "Esc back  \u2022  j/k scroll  \u2022  a archive  \u2022  l label  \u2022  r toggle read",
+          accent: "green",
+          children: emailLoading ? /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+            /* @__PURE__ */ jsx(Spinner, { type: "dots" }),
+            " Loading full email body\u2026"
+          ] }) : emailDetail ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsxs(Text, { children: [
+              "From: ",
+              sanitizeInlineText(emailDetail.fromName ? `${emailDetail.fromName} <${emailDetail.fromAddress}>` : emailDetail.fromAddress)
+            ] }),
+            /* @__PURE__ */ jsxs(Text, { children: [
+              "To: ",
+              sanitizeInlineText(emailDetail.toAddresses.join(", ") || "-")
+            ] }),
+            /* @__PURE__ */ jsxs(Text, { children: [
+              "Date: ",
+              new Date(emailDetail.date).toISOString()
+            ] }),
+            /* @__PURE__ */ jsxs(Text, { children: [
+              "Labels: ",
+              sanitizeInlineText(emailDetail.labelIds.join(", ") || "-")
+            ] }),
+            /* @__PURE__ */ jsx(Box, { marginTop: 1, flexDirection: "column", children: visibleBodyLines.length === 0 ? /* @__PURE__ */ jsx(Text, { color: "gray", children: "(no body content)" }) : visibleBodyLines.map((line, index) => /* @__PURE__ */ jsx(Text, { children: sanitizeInlineText(line || " ", Math.max(20, columns - 8)) }, `body-${index}`)) }),
+            /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+              "line ",
+              Math.min(emailBodyLines.length, emailScroll + 1),
+              " of ",
+              emailBodyLines.length || 1
+            ] }) })
+          ] }) : /* @__PURE__ */ jsx(Text, { color: "gray", children: "Unable to load email detail." })
+        }
+      ) : null,
+      screen === "stats" ? /* @__PURE__ */ jsx(
+        Panel,
+        {
+          title: "Stats Dashboard",
+          subtitle: "s senders  \u2022  l labels  \u2022  n newsletters  \u2022  Esc back",
+          accent: "yellow",
+          children: statsLoading ? /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+            /* @__PURE__ */ jsx(Spinner, { type: "dots" }),
+            " Loading stats\u2026"
+          ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+              /* @__PURE__ */ jsxs(Text, { children: [
+                "Total: ",
+                statsOverview?.total ?? 0
+              ] }),
+              /* @__PURE__ */ jsxs(Text, { children: [
+                "Unread: ",
+                statsOverview?.unread ?? 0
+              ] }),
+              /* @__PURE__ */ jsxs(Text, { children: [
+                "Starred: ",
+                statsOverview?.starred ?? 0
+              ] }),
+              /* @__PURE__ */ jsxs(Text, { children: [
+                "Today: ",
+                statsOverview?.today.received ?? 0,
+                " received / ",
+                statsOverview?.today.unread ?? 0,
+                " unread"
+              ] }),
+              /* @__PURE__ */ jsxs(Text, { children: [
+                "Week: ",
+                statsOverview?.thisWeek.received ?? 0,
+                " received / ",
+                statsOverview?.thisWeek.unread ?? 0,
+                " unread"
+              ] }),
+              /* @__PURE__ */ jsxs(Text, { children: [
+                "Month: ",
+                statsOverview?.thisMonth.received ?? 0,
+                " received / ",
+                statsOverview?.thisMonth.unread ?? 0,
+                " unread"
+              ] })
+            ] }),
+            /* @__PURE__ */ jsxs(Box, { marginTop: 1, children: [
+              /* @__PURE__ */ jsx(Text, { color: statsTab === "senders" ? "cyan" : "gray", children: "[Senders]" }),
+              /* @__PURE__ */ jsx(Text, { children: " " }),
+              /* @__PURE__ */ jsx(Text, { color: statsTab === "labels" ? "cyan" : "gray", children: "[Labels]" }),
+              /* @__PURE__ */ jsx(Text, { children: " " }),
+              /* @__PURE__ */ jsx(Text, { color: statsTab === "newsletters" ? "cyan" : "gray", children: "[Newsletters]" })
+            ] }),
+            statsTab === "senders" ? /* @__PURE__ */ jsx(
+              Table,
+              {
+                title: "Top Senders",
+                headers: ["SENDER", "TOTAL", "UNREAD%"],
+                rows: statsSenders.map((sender) => [
+                  truncate(sender.name || sender.email, 28),
+                  String(sender.totalMessages),
+                  formatPercent(sender.unreadRate)
+                ]),
+                emptyMessage: "No sender stats available."
+              }
+            ) : null,
+            statsTab === "labels" ? /* @__PURE__ */ jsx(
+              Table,
+              {
+                title: "Top Labels",
+                headers: ["LABEL", "TOTAL", "UNREAD"],
+                rows: statsLabels.map((label) => [
+                  truncate(label.labelName, 24),
+                  String(label.totalMessages),
+                  String(label.unreadMessages)
+                ]),
+                emptyMessage: "No label stats available."
+              }
+            ) : null,
+            statsTab === "newsletters" ? /* @__PURE__ */ jsx(
+              Table,
+              {
+                title: "Newsletters",
+                headers: ["SENDER", "TOTAL", "UNREAD%", "STATUS"],
+                rows: statsNewsletters.map((newsletter) => [
+                  truncate(newsletter.name || newsletter.email, 24),
+                  String(newsletter.messageCount),
+                  formatPercent(newsletter.unreadRate),
+                  newsletter.status
+                ]),
+                emptyMessage: "No newsletters detected."
+              }
+            ) : null,
+            /* @__PURE__ */ jsx(
+              Table,
+              {
+                title: "Recent Volume",
+                headers: ["DAY", "RECEIVED", "UNREAD"],
+                rows: statsVolume.map((point) => [
+                  point.period,
+                  String(point.received),
+                  String(point.unread)
+                ]),
+                emptyMessage: "No cached volume data."
+              }
+            )
+          ] })
+        }
+      ) : null,
+      screen === "rules" ? /* @__PURE__ */ jsx(
+        Panel,
+        {
+          title: "Rules Control",
+          subtitle: "Tab switches focus  \u2022  d deploy  \u2022  e toggle  \u2022  r dry-run  \u2022  R apply  \u2022  u undo",
+          accent: "magenta",
+          children: rulesLoading ? /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+            /* @__PURE__ */ jsx(Spinner, { type: "dots" }),
+            " Loading rules\u2026"
+          ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(Text, { color: rulesFocus === "rules" ? "cyan" : "gray", children: "Rules" }),
+            rules2.length === 0 ? /* @__PURE__ */ jsx(Text, { color: "gray", children: "No deployed rules." }) : visibleRules.map((rule, index) => {
+              const absoluteIndex = rulesRange.start + index;
+              return /* @__PURE__ */ jsxs(
+                Text,
+                {
+                  backgroundColor: rulesFocus === "rules" && absoluteIndex === rulesSelectedIndex ? "magenta" : void 0,
+                  color: rulesFocus === "rules" && absoluteIndex === rulesSelectedIndex ? "black" : void 0,
+                  children: [
+                    rule.enabled ? "\u2713" : "\xB7",
+                    " ",
+                    rule.name,
+                    " (",
+                    rule.totalRuns,
+                    " runs, last ",
+                    formatRelativeTime(rule.lastExecutionAt),
+                    ")"
+                  ]
+                },
+                rule.id
+              );
+            }),
+            /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+              /* @__PURE__ */ jsx(Text, { color: rulesFocus === "history" ? "cyan" : "gray", children: "Recent History" }),
+              ruleHistory.length === 0 ? /* @__PURE__ */ jsx(Text, { color: "gray", children: "No execution history yet." }) : visibleHistory.map((run, index) => {
+                const absoluteIndex = historyRange.start + index;
+                return /* @__PURE__ */ jsxs(
+                  Text,
+                  {
+                    backgroundColor: rulesFocus === "history" && absoluteIndex === historySelectedIndex ? "white" : void 0,
+                    color: rulesFocus === "history" && absoluteIndex === historySelectedIndex ? "black" : void 0,
+                    children: [
+                      run.status,
+                      " ",
+                      run.id,
+                      " (",
+                      run.itemCount,
+                      " items, ",
+                      formatRelativeTime(run.createdAt),
+                      ")"
+                    ]
+                  },
+                  run.id
+                );
+              })
+            ] }),
+            selectedRule && rulesFocus === "rules" ? /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+              /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+                "Selected rule: ",
+                selectedRule.name
+              ] }),
+              /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+                "Actions: ",
+                selectedRule.actions.map((action) => action.type).join(", ") || "-"
+              ] })
+            ] }) : null,
+            selectedRun && rulesFocus === "history" ? /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+              "Selected run: ",
+              selectedRun.id
+            ] }) : null
+          ] })
+        }
+      ) : null,
+      screen === "search" ? /* @__PURE__ */ jsxs(
+        Panel,
+        {
+          title: "Search",
+          subtitle: "Enter Gmail query syntax  \u2022  Enter search  \u2022  i focus input  \u2022  Esc back",
+          accent: "cyan",
+          children: [
+            /* @__PURE__ */ jsxs(Box, { children: [
+              /* @__PURE__ */ jsx(Text, { color: "cyan", children: "query: " }),
+              /* @__PURE__ */ jsx(
+                TextInput,
+                {
+                  value: searchQuery,
+                  onChange: setSearchQuery,
+                  onSubmit: (value) => {
+                    void executeSearch(value);
+                  },
+                  focus: searchFocus === "input"
+                }
+              )
+            ] }),
+            searchLoading ? /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+              /* @__PURE__ */ jsx(Spinner, { type: "dots" }),
+              " Searching Gmail\u2026"
+            ] }) : /* @__PURE__ */ jsx(
+              EmailList,
+              {
+                emails: searchResults,
+                selectedIndex: searchSelectedIndex,
+                title: "Results",
+                emptyMessage: "No results yet.",
+                visibleRows: Math.max(6, listVisibleRows - 4)
+              }
+            )
+          ]
+        }
+      ) : null
+    ] }),
+    labelPicker.open ? /* @__PURE__ */ jsx(Modal, { title: "Label Picker", children: labelPicker.loading ? /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+      /* @__PURE__ */ jsx(Spinner, { type: "dots" }),
+      " Loading labels\u2026"
+    ] }) : labelPicker.createMode ? /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "Enter new label name, then press Enter. Esc cancels." }),
+      /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          value: labelPicker.newLabelName,
+          onChange: (value) => {
+            setLabelPicker((current) => ({
+              ...current,
+              newLabelName: value
+            }));
+          },
+          onSubmit: (value) => {
+            void createAndApplyLabel(value);
+          },
+          focus: true
+        }
+      )
+    ] }) : labelPicker.labels.length === 0 ? /* @__PURE__ */ jsx(Text, { color: "gray", children: "No labels available. Press c to create one." }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "j/k navigate, Enter apply, c create label, Esc cancel" }),
+      labelPicker.labels.map((label, index) => /* @__PURE__ */ jsx(Text, { inverse: index === labelPicker.selectedIndex, children: label.name }, label.id))
+    ] }) }) : null,
+    confirmState ? /* @__PURE__ */ jsxs(Modal, { title: confirmState.title, children: [
+      /* @__PURE__ */ jsx(Text, { children: confirmState.message }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "Press y to continue or n to cancel." })
+    ] }) : null,
+    /* @__PURE__ */ jsx(
+      StatusBar,
+      {
+        screen,
+        email: authEmail,
+        unreadCount,
+        sync: syncState,
+        flash,
+        columns
+      }
+    )
+  ] });
+}
+async function startTuiApp(options) {
+  if (process.stdout.isTTY) {
+    process.stdout.write("\x1B[?1049h\x1B[2J\x1B[H");
+  }
+  try {
+    const instance = render(/* @__PURE__ */ jsx(App, { initialSync: !options?.noSync }));
+    await instance.waitUntilExit();
+  } finally {
+    if (process.stdout.isTTY) {
+      process.stdout.write("\x1B[?1049l");
+    }
+  }
+}
+
+// src/core/demo/demo-transport.ts
+function copyMessage(message) {
+  return JSON.parse(JSON.stringify(message));
+}
+function copyLabel(label) {
+  return { ...label };
+}
+function copyFilter(filter) {
+  return JSON.parse(JSON.stringify(filter));
+}
+function getSearchTokens(query) {
+  return query.match(/"[^"]+"|\S+/g) || [];
+}
+function normalize(value) {
+  return (value || "").trim().toLowerCase();
+}
+function includesLabel(labelIds, rawLabels, expected) {
+  return labelIds.some((labelId) => {
+    const label = rawLabels.get(labelId);
+    return normalize(labelId) === expected || normalize(label?.name) === expected || normalize(label?.name).replace(/\s+/g, "-") === expected;
+  });
+}
+function matchesQuery(entry, query, rawLabels) {
+  const trimmed = query.trim();
+  if (!trimmed) {
+    return true;
+  }
+  const searchableText = normalize(
+    [
+      entry.message.fromAddress,
+      entry.message.fromName,
+      entry.message.subject,
+      entry.message.snippet,
+      ...entry.message.toAddresses
+    ].join(" ")
+  );
+  return getSearchTokens(trimmed).every((token) => {
+    const cleaned = token.replace(/^"|"$/g, "");
+    const separator = cleaned.indexOf(":");
+    if (separator === -1) {
+      return searchableText.includes(normalize(cleaned));
+    }
+    const key = normalize(cleaned.slice(0, separator));
+    const value = normalize(cleaned.slice(separator + 1));
+    switch (key) {
+      case "from":
+        return normalize(entry.message.fromAddress).includes(value) || normalize(entry.message.fromName).includes(value);
+      case "to":
+        return entry.message.toAddresses.some((address) => normalize(address).includes(value));
+      case "subject":
+        return normalize(entry.message.subject).includes(value);
+      case "label":
+        return includesLabel(entry.message.labelIds, rawLabels, value);
+      case "is":
+        if (value === "unread") return !entry.message.isRead;
+        if (value === "read") return entry.message.isRead;
+        if (value === "starred") return entry.message.isStarred;
+        return true;
+      case "has":
+        if (value === "attachment") return entry.message.hasAttachments;
+        return true;
+      default:
+        return searchableText.includes(normalize(cleaned));
+    }
+  });
+}
+function applyLabelMutation(labelIds, addLabelIds = [], removeLabelIds = []) {
+  const next = labelIds.filter((labelId) => !removeLabelIds.includes(labelId));
+  for (const labelId of addLabelIds) {
+    if (!next.includes(labelId)) {
+      next.push(labelId);
+    }
+  }
+  return next;
+}
+var DemoTransport = class {
+  constructor(dataset) {
+    this.dataset = dataset;
+    this.historyCounter = Number.parseInt(dataset.historyId, 10) || 12345678;
+    for (const label of dataset.labels) {
+      if (label.id) {
+        this.labels.set(label.id, copyLabel(label));
+      }
+    }
+    for (const message of dataset.messages) {
+      this.messages.set(message.message.id, {
+        ...message,
+        message: {
+          ...message.message,
+          labelIds: [...message.message.labelIds]
+        },
+        rawMessage: copyMessage(message.rawMessage)
+      });
+    }
+    for (const filter of dataset.filters) {
+      if (filter.id) {
+        this.filters.set(filter.id, copyFilter(filter));
+      }
+    }
+  }
+  dataset;
+  kind = "rest";
+  labels = /* @__PURE__ */ new Map();
+  messages = /* @__PURE__ */ new Map();
+  filters = /* @__PURE__ */ new Map();
+  historyCounter;
+  async getProfile() {
+    return {
+      emailAddress: this.dataset.accountEmail,
+      historyId: String(this.historyCounter),
+      messagesTotal: this.messages.size,
+      threadsTotal: new Set(
+        [...this.messages.values()].map((entry) => entry.message.threadId)
+      ).size
+    };
+  }
+  buildLabelDetails(label) {
+    const id = label.id || label.name || "";
+    const matching = [...this.messages.values()].filter(
+      (entry) => entry.message.labelIds.includes(id)
+    );
+    return {
+      ...copyLabel(label),
+      messagesTotal: matching.length,
+      messagesUnread: matching.filter((entry) => !entry.message.isRead).length,
+      threadsTotal: new Set(matching.map((entry) => entry.message.threadId)).size,
+      threadsUnread: new Set(
+        matching.filter((entry) => !entry.message.isRead).map((entry) => entry.message.threadId)
+      ).size
+    };
+  }
+  async listLabels() {
+    return {
+      labels: [...this.labels.values()].map((label) => this.buildLabelDetails(label))
+    };
+  }
+  async getLabel(id) {
+    const label = this.labels.get(id);
+    if (!label) {
+      throw new Error(`Demo label not found: ${id}`);
+    }
+    return this.buildLabelDetails(label);
+  }
+  async createLabel(input2) {
+    const existing = [...this.labels.values()].find(
+      (label) => normalize(label.name) === normalize(input2.name)
+    );
+    if (existing) {
+      return this.buildLabelDetails(existing);
+    }
+    const nextUserLabelCount = [...this.labels.values()].filter((label) => label.type === "user").length + 1;
+    const created = {
+      id: `Label_${nextUserLabelCount}`,
+      name: input2.name.trim(),
+      type: "user",
+      color: input2.color || null
+    };
+    this.labels.set(created.id, created);
+    return this.buildLabelDetails(created);
+  }
+  async batchModifyMessages(input2) {
+    for (const id of input2.ids) {
+      const entry = this.messages.get(id);
+      if (!entry) {
+        continue;
+      }
+      const nextLabelIds = applyLabelMutation(
+        entry.message.labelIds,
+        input2.addLabelIds,
+        input2.removeLabelIds
+      );
+      entry.message.labelIds = nextLabelIds;
+      entry.message.isRead = !nextLabelIds.includes("UNREAD");
+      entry.message.isStarred = nextLabelIds.includes("STARRED");
+      entry.rawMessage.labelIds = [...nextLabelIds];
+    }
+    this.historyCounter += 1;
+  }
+  async sendMessage() {
+    this.historyCounter += 1;
+    return {
+      id: `sent-demo-${this.historyCounter}`,
+      threadId: `sent-thread-${this.historyCounter}`,
+      labelIds: ["SENT"]
+    };
+  }
+  async listMessages(options) {
+    const matching = [...this.messages.values()].filter((entry) => matchesQuery(entry, options.query || "", this.labels)).sort((left, right) => right.message.date - left.message.date);
+    const offset = options.pageToken ? Number.parseInt(options.pageToken, 10) : 0;
+    const limit = options.maxResults || 20;
+    const slice = matching.slice(offset, offset + limit);
+    const nextOffset = offset + slice.length;
+    return {
+      messages: slice.map((entry) => ({
+        id: entry.message.id,
+        threadId: entry.message.threadId
+      })),
+      nextPageToken: nextOffset < matching.length ? String(nextOffset) : void 0,
+      resultSizeEstimate: matching.length
+    };
+  }
+  async getMessage(options) {
+    const entry = this.messages.get(options.id);
+    if (!entry) {
+      throw new Error(`Demo message not found: ${options.id}`);
+    }
+    return copyMessage(entry.rawMessage);
+  }
+  async getThread(id) {
+    const messages = [...this.messages.values()].filter((entry) => entry.message.threadId === id).sort((left, right) => left.message.date - right.message.date).map((entry) => copyMessage(entry.rawMessage));
+    return {
+      id,
+      messages
+    };
+  }
+  async listHistory() {
+    return {
+      history: [],
+      historyId: String(this.historyCounter)
+    };
+  }
+  async listFilters() {
+    return {
+      filter: [...this.filters.values()].map((filter) => copyFilter(filter))
+    };
+  }
+  async getFilter(id) {
+    const filter = this.filters.get(id);
+    if (!filter) {
+      throw new Error(`Demo filter not found: ${id}`);
+    }
+    return copyFilter(filter);
+  }
+  async createFilter(filter) {
+    const created = {
+      id: `filter-demo-${this.filters.size + 1}`,
+      criteria: filter.criteria,
+      action: filter.action
+    };
+    this.filters.set(created.id, created);
+    return copyFilter(created);
+  }
+  async deleteFilter(id) {
+    if (!this.filters.delete(id)) {
+      throw new Error(`Demo filter not found: ${id}`);
+    }
+  }
+};
+function createDemoTransport(dataset) {
+  return new DemoTransport(dataset);
+}
+
+// src/core/demo/seed.ts
+var DEMO_ACCOUNT_EMAIL = "demo@example.com";
+var USER_LABELS = {
+  receipts: "Label_1",
+  awsAlerts: "Label_2",
+  important: "Label_3"
+};
+var SYSTEM_LABELS = [
+  { id: "INBOX", name: "Inbox", type: "system" },
+  { id: "UNREAD", name: "Unread", type: "system" },
+  { id: "STARRED", name: "Starred", type: "system" },
+  { id: "SENT", name: "Sent", type: "system" },
+  { id: "DRAFT", name: "Drafts", type: "system" },
+  { id: "SPAM", name: "Spam", type: "system" },
+  { id: "TRASH", name: "Trash", type: "system" },
+  { id: "CATEGORY_UPDATES", name: "Updates", type: "system" },
+  { id: "CATEGORY_PROMOTIONS", name: "Promotions", type: "system" }
+];
+var DEMO_LABELS = [
+  ...SYSTEM_LABELS,
+  { id: USER_LABELS.receipts, name: "Receipts", type: "user" },
+  { id: USER_LABELS.awsAlerts, name: "AWS-Alerts", type: "user" },
+  { id: USER_LABELS.important, name: "Important", type: "user" }
+];
+var SENDERS = [
+  { key: "github", name: "GitHub", email: "notifications@github.com", count: 25, unread: 8 },
+  { key: "stripe", name: "Stripe", email: "receipts@stripe.com", count: 12, unread: 0 },
+  { key: "aws", name: "AWS Notifications", email: "no-reply@amazonaws.com", count: 18, unread: 14 },
+  { key: "vercel", name: "Vercel", email: "notifications@vercel.com", count: 10, unread: 7 },
+  { key: "linear", name: "Linear", email: "notifications@linear.app", count: 15, unread: 3 },
+  { key: "alice", name: "Alice Chen", email: "alice.chen@example.com", count: 8, unread: 2 },
+  { key: "bob", name: "Bob Martinez", email: "bob.martinez@example.com", count: 6, unread: 1 },
+  { key: "newsletter", name: "Newsletter Weekly", email: "digest@newsletterweekly.com", count: 14, unread: 12, hasListUnsubscribe: true },
+  { key: "hn", name: "Hacker News Digest", email: "hn@newsletters.hackernews.com", count: 12, unread: 10, hasListUnsubscribe: true },
+  { key: "paypal", name: "PayPal", email: "service@paypal.com", count: 8, unread: 0 },
+  { key: "shopify", name: "Shopify", email: "no-reply@shopify.com", count: 6, unread: 0 },
+  { key: "docker", name: "Docker Hub", email: "noreply@docker.com", count: 5, unread: 4 },
+  { key: "sarah", name: "Sarah Kim", email: "sarah.kim@example.com", count: 4, unread: 1 },
+  { key: "npm", name: "npm", email: "support@npmjs.com", count: 4, unread: 3 },
+  { key: "slack", name: "Slack", email: "notification@slack.com", count: 3, unread: 2 }
+];
+var PRIORITY_SEQUENCE = [
+  "github",
+  "aws",
+  "stripe",
+  "alice",
+  "linear",
+  "github",
+  "newsletter",
+  "stripe",
+  "vercel",
+  "hn",
+  "bob",
+  "github"
+];
+function createRng(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state * 1664525 + 1013904223 >>> 0;
+    return state / 4294967296;
+  };
+}
+function encodeBase64Url(value) {
+  return Buffer.from(value, "utf8").toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function buildTimestamps(now, total) {
+  const timestamps = [];
+  const blocks = [
+    { count: 10, startHours: 0.5, endHours: 23 },
+    { count: 15, startHours: 26, endHours: 72 },
+    { count: 30, startHours: 74, endHours: 168 },
+    { count: total - 55, startHours: 170, endHours: 720 }
+  ];
+  for (const block of blocks) {
+    for (let index = 0; index < block.count; index += 1) {
+      const ratio = block.count === 1 ? 0 : index / (block.count - 1);
+      const offsetHours = block.startHours + ratio * (block.endHours - block.startHours);
+      timestamps.push(now - Math.round(offsetHours * 60 * 60 * 1e3));
+    }
+  }
+  return timestamps.sort((a, b) => b - a);
+}
+function chooseSender(slotIndex, remaining, rng) {
+  const preferred = PRIORITY_SEQUENCE[slotIndex];
+  if (preferred && (remaining.get(preferred) || 0) > 0) {
+    remaining.set(preferred, (remaining.get(preferred) || 0) - 1);
+    return preferred;
+  }
+  const weighted = [...remaining.entries()].filter(([, count]) => count > 0);
+  const totalWeight = weighted.reduce((sum, [, count]) => sum + count, 0);
+  let cursor = rng() * totalWeight;
+  for (const [key, count] of weighted) {
+    cursor -= count;
+    if (cursor <= 0) {
+      remaining.set(key, count - 1);
+      return key;
+    }
+  }
+  const fallback = weighted[weighted.length - 1]?.[0];
+  if (!fallback) {
+    throw new Error("Demo sender pool exhausted unexpectedly.");
+  }
+  remaining.set(fallback, (remaining.get(fallback) || 1) - 1);
+  return fallback;
+}
+function getSubject(senderKey, sequence) {
+  switch (senderKey) {
+    case "github":
+      return [
+        `Re: [acme/inboxctl] Fix race condition in worker pool (#12${sequence + 1})`,
+        `[acme/inboxctl] New issue: Memory leak in cache layer (#23${sequence + 1})`,
+        `[acme/platform] Review requested on PR #45${sequence + 1}`,
+        `Re: [acme/inboxctl] TUI search pagination follow-up (#34${sequence + 1})`
+      ][sequence % 4];
+    case "stripe":
+      return [
+        "Your receipt from Acme Corp - $49.00",
+        "Payment to DigitalOcean - $12.00",
+        "Your receipt from Render, Inc. - $29.00",
+        "Invoice paid: GitHub Team - $9.00"
+      ][sequence % 4];
+    case "aws":
+      return [
+        "AWS Billing Alert: Your estimated charges exceed $50",
+        "Amazon EC2 Maintenance Notification",
+        "AWS Trusted Advisor weekly summary",
+        "Amazon RDS performance insights available"
+      ][sequence % 4];
+    case "vercel":
+      return [
+        "Deployment completed for inboxctl-web",
+        "Build failed for docs-preview",
+        "Preview ready for PR #184",
+        "Your project has a new domain alias"
+      ][sequence % 4];
+    case "linear":
+      return [
+        "Issue assigned: PROJ-142 Implement retry logic",
+        "Comment on PROJ-138",
+        "Cycle planning notes are ready",
+        "Issue updated: PROJ-155 Improve inbox search"
+      ][sequence % 4];
+    case "alice":
+      return [
+        "Re: Architecture review notes",
+        "Quick question about the deploy pipeline",
+        "Lunch tomorrow?",
+        "Follow-up on MCP prompt defaults"
+      ][sequence % 4];
+    case "bob":
+      return [
+        "Re: Sprint planning agenda",
+        "Can you sanity-check the release notes?",
+        "Quick update on the billing incident"
+      ][sequence % 3];
+    case "newsletter":
+      return [
+        "Weekly systems brief: incidents, launches, and lessons learned",
+        "This week in developer tools",
+        "Five workflows worth stealing this week"
+      ][sequence % 3];
+    case "hn":
+      return [
+        "Hacker News Digest: Top stories this week",
+        "HN Digest: AI tooling, terminals, and SQLite",
+        "Your weekly Hacker News roundup"
+      ][sequence % 3];
+    case "paypal":
+      return [
+        "Receipt for your payment to Figma",
+        "You sent a payment to Notion Labs",
+        "Transaction receipt from OpenAI"
+      ][sequence % 3];
+    case "shopify":
+      return [
+        "Order confirmation from Acme Supply",
+        "Receipt from Shopify Billing",
+        "Your Shopify payment receipt"
+      ][sequence % 3];
+    case "docker":
+      return [
+        "Docker Hub autobuild completed",
+        "New image vulnerability summary",
+        "Usage summary for your Docker plan"
+      ][sequence % 3];
+    case "sarah":
+      return [
+        "Re: Copy review for the setup guide",
+        "Notes from today's product sync",
+        "Small wording suggestion for the README"
+      ][sequence % 3];
+    case "npm":
+      return [
+        "Security notice for one of your dependencies",
+        "Your npm access token was used",
+        "Package advisory summary"
+      ][sequence % 3];
+    case "slack":
+      return [
+        "You have unread mentions in #engineering",
+        "Slack summary for yesterday",
+        "Reminder: action requested in #launches"
+      ][sequence % 3];
+  }
+}
+function buildBody(sender, subject, sequence) {
+  switch (sender.key) {
+    case "github":
+      return [
+        subject,
+        "",
+        "A reviewer left feedback on your pull request.",
+        "",
+        "File: src/core/rules/executor.ts",
+        "",
+        "```ts",
+        'if (result.status === "warning") {',
+        "  retryQueue.push(item);",
+        "}",
+        "```",
+        "",
+        "Comment:",
+        "The warning path looks good, but we may still emit duplicate audit items",
+        "when the retry branch is hit after a partial apply. Can we move the",
+        "audit append behind the final status resolution?",
+        "",
+        "Suggested follow-up:",
+        "- add a regression test around repeated partial retries",
+        "- confirm undo still sees a single logical execution item",
+        "",
+        "View pull request",
+        "Reply to comment"
+      ].join("\n");
+    case "stripe":
+      return [
+        subject,
+        "",
+        "Receipt summary",
+        "----------------------------------------",
+        `Receipt number: rcpt_demo_${sequence + 1}`,
+        "Paid with: Visa ending in 4242",
+        "Billing contact: demo@example.com",
+        "",
+        "Line items",
+        "- Team plan........................ $29.00",
+        "- Usage overage................... $20.00",
+        "",
+        "Subtotal.......................... $49.00",
+        "Tax............................... $0.00",
+        "Total............................. $49.00",
+        "",
+        "If you have questions about this charge, reply to this email and include",
+        "the receipt number above."
+      ].join("\n");
+    case "aws":
+      return [
+        subject,
+        "",
+        "Account: demo-platform",
+        "Region highlights:",
+        "- us-east-1 EC2 running hours increased by 14%",
+        "- ap-southeast-2 RDS backup storage exceeded forecast",
+        "- CloudWatch logs ingestion steady week over week",
+        "",
+        "Estimated charges",
+        "- EC2.............................. $28.40",
+        "- RDS.............................. $13.10",
+        "- CloudWatch....................... $7.92",
+        "- Data transfer.................... $3.61",
+        "",
+        "Recommended actions",
+        "- review orphaned volumes",
+        "- confirm dev database retention",
+        "- validate expected scale-up window"
+      ].join("\n");
+    case "newsletter":
+    case "hn":
+      return [
+        subject,
+        "",
+        "Good morning.",
+        "",
+        "Here is your roundup of the links and ideas people kept passing around",
+        "this week, from terminal UX to pricing models to practical SQLite tips.",
+        "",
+        "Featured reads",
+        "- A better way to review notification-heavy inboxes",
+        "- Why local-first tools feel faster and safer",
+        "- The hidden costs of brittle automation",
+        "",
+        "Worth a skim if you missed them",
+        "- Building humane CLIs",
+        "- Debugging MCP integrations in practice",
+        "- Shipping small tools without creating trust debt",
+        "",
+        "Read online",
+        "Manage subscription"
+      ].join("\n");
+    case "alice":
+    case "bob":
+    case "sarah":
+      return [
+        subject,
+        "",
+        `Hey team,`,
+        "",
+        "A couple of quick notes from my side:",
+        "- the current flow feels solid once the first sync is done",
+        "- the setup copy could be a little shorter",
+        "- I like that the TUI keeps the audit story visible",
+        "",
+        "Can you take a look when you get a chance?",
+        "",
+        "Thanks,",
+        sender.name
+      ].join("\n");
+    default:
+      return [
+        subject,
+        "",
+        `${sender.name} generated this notification for the demo mailbox.`,
+        "",
+        "This message exists so the TUI detail view, sender stats, and search",
+        "screens all have realistic data to work with."
+      ].join("\n");
+  }
+}
+function getBaseLabelIds(senderKey, unread, sequence) {
+  const labels2 = ["INBOX"];
+  if (unread) {
+    labels2.push("UNREAD");
+  }
+  switch (senderKey) {
+    case "github":
+    case "linear":
+      labels2.push("CATEGORY_UPDATES");
+      break;
+    case "stripe":
+    case "paypal":
+    case "shopify":
+      labels2.push(USER_LABELS.receipts);
+      break;
+    case "alice":
+    case "bob":
+    case "sarah":
+      if (sequence === 0) {
+        labels2.push(USER_LABELS.important);
+      }
+      break;
+    case "aws":
+      if (sequence < 2) {
+        labels2.push(USER_LABELS.awsAlerts);
+      }
+      break;
+    case "npm":
+      labels2.push(USER_LABELS.important);
+      break;
+  }
+  return Array.from(new Set(labels2));
+}
+function buildRawMessage(record, bodyText) {
+  return {
+    id: record.id,
+    threadId: record.threadId,
+    snippet: record.snippet,
+    internalDate: String(record.date),
+    labelIds: record.labelIds,
+    sizeEstimate: record.sizeEstimate,
+    payload: {
+      mimeType: "multipart/alternative",
+      headers: [
+        { name: "From", value: `${record.fromName} <${record.fromAddress}>` },
+        { name: "To", value: record.toAddresses.join(", ") },
+        { name: "Subject", value: record.subject },
+        { name: "Date", value: new Date(record.date).toUTCString() },
+        ...record.listUnsubscribe ? [{ name: "List-Unsubscribe", value: record.listUnsubscribe }] : []
+      ],
+      parts: [
+        {
+          mimeType: "text/plain",
+          filename: "",
+          body: {
+            data: encodeBase64Url(bodyText)
+          }
+        }
+      ]
+    }
+  };
+}
+function buildMessage(sender, sequence, date) {
+  const subject = getSubject(sender.key, sequence);
+  const bodyText = buildBody(sender, subject, sequence);
+  const unread = sequence < sender.unread;
+  const labelIds = getBaseLabelIds(sender.key, unread, sequence);
+  const message = {
+    id: `demo-${sender.key}-${String(sequence + 1).padStart(2, "0")}`,
+    threadId: `thread-${sender.key}-${Math.floor(sequence / 2) + 1}`,
+    fromAddress: sender.email,
+    fromName: sender.name,
+    toAddresses: [DEMO_ACCOUNT_EMAIL],
+    subject,
+    snippet: bodyText.split("\n").slice(0, 3).join(" ").slice(0, 160),
+    date,
+    isRead: !unread,
+    isStarred: sender.key === "alice" && sequence === 0 || sender.key === "stripe" && sequence === 0 || sender.key === "github" && sequence === 0,
+    labelIds,
+    sizeEstimate: 1024 + sequence * 17,
+    hasAttachments: sender.key === "stripe" || sender.key === "aws",
+    listUnsubscribe: sender.hasListUnsubscribe ? `<mailto:unsubscribe@${sender.email.split("@")[1]}>` : null
+  };
+  return {
+    senderKey: sender.key,
+    message,
+    rawMessage: buildRawMessage(message, bodyText),
+    bodyText
+  };
+}
+function makeRuleRecords(now) {
+  return [
+    {
+      id: "rule-label-receipts",
+      name: "label-receipts",
+      description: "Label emails that look like receipts",
+      enabled: true,
+      yamlHash: "demo-hash-label-receipts",
+      conditions: {
+        operator: "OR",
+        matchers: [
+          {
+            field: "from",
+            values: ["receipts@stripe.com", "service@paypal.com", "no-reply@shopify.com"]
+          },
+          {
+            field: "subject",
+            contains: ["receipt", "invoice", "order confirmation"]
+          }
+        ]
+      },
+      actions: [{ type: "label", label: "Receipts" }],
+      priority: 30,
+      deployedAt: now - 6 * 24 * 60 * 60 * 1e3,
+      createdAt: now - 6 * 24 * 60 * 60 * 1e3
+    },
+    {
+      id: "rule-archive-newsletters",
+      name: "archive-newsletters",
+      description: "Archive low-engagement newsletters",
+      enabled: true,
+      yamlHash: "demo-hash-archive-newsletters",
+      conditions: {
+        operator: "AND",
+        matchers: [
+          {
+            field: "from",
+            values: ["digest@newsletterweekly.com", "hn@newsletters.hackernews.com"]
+          }
+        ]
+      },
+      actions: [{ type: "archive" }, { type: "mark_read" }],
+      priority: 50,
+      deployedAt: now - 5 * 24 * 60 * 60 * 1e3,
+      createdAt: now - 5 * 24 * 60 * 60 * 1e3
+    },
+    {
+      id: "rule-flag-aws-alerts",
+      name: "flag-aws-alerts",
+      description: "Label AWS billing and maintenance alerts",
+      enabled: false,
+      yamlHash: "demo-hash-flag-aws-alerts",
+      conditions: {
+        operator: "OR",
+        matchers: [
+          {
+            field: "from",
+            values: ["no-reply@amazonaws.com"]
+          },
+          {
+            field: "subject",
+            contains: ["billing", "maintenance"]
+          }
+        ]
+      },
+      actions: [{ type: "label", label: "AWS-Alerts" }],
+      priority: 40,
+      deployedAt: now - 4 * 24 * 60 * 60 * 1e3,
+      createdAt: now - 4 * 24 * 60 * 60 * 1e3
+    }
+  ];
+}
+function pickIds(messages, senderKey, count) {
+  return messages.filter((entry) => entry.senderKey === senderKey).slice(0, count).map((entry) => entry.message.id);
+}
+function makeExecutionRecords(now, messages) {
+  const receiptIds = [
+    ...pickIds(messages, "stripe", 2),
+    ...pickIds(messages, "paypal", 1),
+    ...pickIds(messages, "shopify", 1)
+  ];
+  const newsletterIds = [
+    ...pickIds(messages, "newsletter", 2),
+    ...pickIds(messages, "hn", 2)
+  ];
+  const manualIds = [
+    ...pickIds(messages, "alice", 1),
+    ...pickIds(messages, "bob", 1),
+    ...pickIds(messages, "github", 1)
+  ];
+  const executionRuns = [
+    {
+      id: "run-receipts-apply",
+      sourceType: "rule",
+      ruleId: "rule-label-receipts",
+      dryRun: false,
+      requestedActions: [{ type: "label", label: "Receipts" }],
+      query: null,
+      status: "applied",
+      createdAt: now - 3 * 24 * 60 * 60 * 1e3,
+      undoneAt: null
+    },
+    {
+      id: "run-receipts-plan",
+      sourceType: "rule",
+      ruleId: "rule-label-receipts",
+      dryRun: true,
+      requestedActions: [{ type: "label", label: "Receipts" }],
+      query: null,
+      status: "planned",
+      createdAt: now - 3 * 24 * 60 * 60 * 1e3 + 20 * 60 * 1e3,
+      undoneAt: null
+    },
+    {
+      id: "run-newsletters-apply",
+      sourceType: "rule",
+      ruleId: "rule-archive-newsletters",
+      dryRun: false,
+      requestedActions: [{ type: "archive" }, { type: "mark_read" }],
+      query: null,
+      status: "applied",
+      createdAt: now - 24 * 60 * 60 * 1e3,
+      undoneAt: null
+    },
+    {
+      id: "run-manual-read",
+      sourceType: "manual",
+      ruleId: null,
+      dryRun: false,
+      requestedActions: [{ type: "mark_read" }],
+      query: "label:UNREAD older_than:2d",
+      status: "applied",
+      createdAt: now - 6 * 60 * 60 * 1e3,
+      undoneAt: null
+    },
+    {
+      id: "run-newsletters-plan",
+      sourceType: "rule",
+      ruleId: "rule-archive-newsletters",
+      dryRun: true,
+      requestedActions: [{ type: "archive" }, { type: "mark_read" }],
+      query: null,
+      status: "planned",
+      createdAt: now - 2 * 60 * 60 * 1e3,
+      undoneAt: null
+    }
+  ];
+  const executionItems = [
+    ...receiptIds.map((emailId, index) => ({
+      id: `item-receipts-apply-${index + 1}`,
+      runId: "run-receipts-apply",
+      emailId,
+      status: "applied",
+      appliedActions: [{ type: "label", label: "Receipts" }],
+      beforeLabelIds: ["INBOX"],
+      afterLabelIds: ["INBOX", USER_LABELS.receipts],
+      errorMessage: null,
+      executedAt: now - 3 * 24 * 60 * 60 * 1e3 + index * 60 * 1e3,
+      undoneAt: null
+    })),
+    ...receiptIds.map((emailId, index) => ({
+      id: `item-receipts-plan-${index + 1}`,
+      runId: "run-receipts-plan",
+      emailId,
+      status: "planned",
+      appliedActions: [{ type: "label", label: "Receipts" }],
+      beforeLabelIds: ["INBOX"],
+      afterLabelIds: ["INBOX", USER_LABELS.receipts],
+      errorMessage: null,
+      executedAt: now - 3 * 24 * 60 * 60 * 1e3 + 20 * 60 * 1e3 + index * 60 * 1e3,
+      undoneAt: null
+    })),
+    ...newsletterIds.map((emailId, index) => ({
+      id: `item-newsletters-apply-${index + 1}`,
+      runId: "run-newsletters-apply",
+      emailId,
+      status: "applied",
+      appliedActions: [{ type: "archive" }, { type: "mark_read" }],
+      beforeLabelIds: ["INBOX", "UNREAD"],
+      afterLabelIds: [],
+      errorMessage: null,
+      executedAt: now - 24 * 60 * 60 * 1e3 + index * 60 * 1e3,
+      undoneAt: null
+    })),
+    ...manualIds.map((emailId, index) => ({
+      id: `item-manual-read-${index + 1}`,
+      runId: "run-manual-read",
+      emailId,
+      status: "applied",
+      appliedActions: [{ type: "mark_read" }],
+      beforeLabelIds: ["INBOX", "UNREAD"],
+      afterLabelIds: ["INBOX"],
+      errorMessage: null,
+      executedAt: now - 6 * 60 * 60 * 1e3 + index * 60 * 1e3,
+      undoneAt: null
+    })),
+    ...newsletterIds.map((emailId, index) => ({
+      id: `item-newsletters-plan-${index + 1}`,
+      runId: "run-newsletters-plan",
+      emailId,
+      status: "planned",
+      appliedActions: [{ type: "archive" }, { type: "mark_read" }],
+      beforeLabelIds: ["INBOX", "UNREAD"],
+      afterLabelIds: [],
+      errorMessage: null,
+      executedAt: now - 2 * 60 * 60 * 1e3 + index * 60 * 1e3,
+      undoneAt: null
+    }))
+  ];
+  return { executionRuns, executionItems };
+}
+function makeNewsletterRecords(messages) {
+  const senders = [
+    {
+      email: "digest@newsletterweekly.com",
+      name: "Newsletter Weekly",
+      reason: "list-unsubscribe,high-unread"
+    },
+    {
+      email: "hn@newsletters.hackernews.com",
+      name: "Hacker News Digest",
+      reason: "list-unsubscribe,high-unread"
+    },
+    {
+      email: "no-reply@amazonaws.com",
+      name: "AWS Notifications",
+      reason: "noreply-pattern,high-unread"
+    },
+    {
+      email: "noreply@docker.com",
+      name: "Docker Hub",
+      reason: "noreply-pattern"
+    },
+    {
+      email: "notifications@github.com",
+      name: "GitHub",
+      reason: "high-volume"
+    },
+    {
+      email: "notification@slack.com",
+      name: "Slack",
+      reason: "noreply-pattern"
+    }
+  ];
+  return senders.map((sender, index) => {
+    const matching = messages.filter((entry) => entry.message.fromAddress === sender.email);
+    return {
+      id: `newsletter-${index + 1}`,
+      email: sender.email,
+      name: sender.name,
+      messageCount: matching.length,
+      unreadCount: matching.filter((entry) => !entry.message.isRead).length,
+      status: "active",
+      unsubscribeLink: matching[0]?.message.listUnsubscribe || null,
+      detectionReason: sender.reason,
+      firstSeen: matching[matching.length - 1]?.message.date || Date.now(),
+      lastSeen: matching[0]?.message.date || Date.now()
+    };
+  });
+}
+function buildDemoDataset(referenceNow = Date.now()) {
+  const timestamps = buildTimestamps(referenceNow, 150);
+  const remaining = new Map(
+    SENDERS.map((sender) => [sender.key, sender.count])
+  );
+  const sequenceBySender = /* @__PURE__ */ new Map();
+  const senderByKey = new Map(SENDERS.map((sender) => [sender.key, sender]));
+  const rng = createRng(42);
+  const messages = [];
+  for (let index = 0; index < timestamps.length; index += 1) {
+    const senderKey = chooseSender(index, remaining, rng);
+    const sender = senderByKey.get(senderKey);
+    if (!sender) {
+      throw new Error(`Missing demo sender spec for ${senderKey}`);
+    }
+    const sequence = sequenceBySender.get(senderKey) || 0;
+    messages.push(buildMessage(sender, sequence, timestamps[index] || referenceNow));
+    sequenceBySender.set(senderKey, sequence + 1);
+  }
+  messages.sort((left, right) => right.message.date - left.message.date);
+  const rules2 = makeRuleRecords(referenceNow);
+  const { executionRuns, executionItems } = makeExecutionRecords(referenceNow, messages);
+  return {
+    accountEmail: DEMO_ACCOUNT_EMAIL,
+    historyId: "12345678",
+    labels: DEMO_LABELS.map((label) => ({ ...label })),
+    messages,
+    rules: rules2,
+    executionRuns,
+    executionItems,
+    newsletters: makeNewsletterRecords(messages),
+    filters: []
+  };
+}
+function seedDemoData(sqlite, referenceNow = Date.now()) {
+  const dataset = buildDemoDataset(referenceNow);
+  sqlite.exec(`
+    DELETE FROM execution_items;
+    DELETE FROM execution_runs;
+    DELETE FROM rules;
+    DELETE FROM newsletter_senders;
+    DELETE FROM emails;
+  `);
+  const insertEmail = sqlite.prepare(`
+    INSERT INTO emails (
+      id, thread_id, from_address, from_name, to_addresses, subject, snippet, date,
+      is_read, is_starred, label_ids, size_estimate, has_attachments, list_unsubscribe, synced_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const insertRule = sqlite.prepare(`
+    INSERT INTO rules (
+      id, name, description, enabled, yaml_hash, conditions, actions, priority, deployed_at, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const insertRun = sqlite.prepare(`
+    INSERT INTO execution_runs (
+      id, source_type, rule_id, dry_run, requested_actions, query, status, created_at, undone_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const insertItem = sqlite.prepare(`
+    INSERT INTO execution_items (
+      id, run_id, email_id, status, applied_actions, before_label_ids, after_label_ids, error_message, executed_at, undone_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const insertNewsletter = sqlite.prepare(`
+    INSERT INTO newsletter_senders (
+      id, email, name, message_count, unread_count, status, unsubscribe_link, detection_reason, first_seen, last_seen
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const transaction = sqlite.transaction(() => {
+    for (const entry of dataset.messages) {
+      insertEmail.run(
+        entry.message.id,
+        entry.message.threadId,
+        entry.message.fromAddress,
+        entry.message.fromName,
+        JSON.stringify(entry.message.toAddresses),
+        entry.message.subject,
+        entry.message.snippet,
+        entry.message.date,
+        entry.message.isRead ? 1 : 0,
+        entry.message.isStarred ? 1 : 0,
+        JSON.stringify(entry.message.labelIds),
+        entry.message.sizeEstimate,
+        entry.message.hasAttachments ? 1 : 0,
+        entry.message.listUnsubscribe,
+        referenceNow
+      );
+    }
+    for (const rule of dataset.rules) {
+      insertRule.run(
+        rule.id,
+        rule.name,
+        rule.description,
+        rule.enabled ? 1 : 0,
+        rule.yamlHash,
+        JSON.stringify(rule.conditions),
+        JSON.stringify(rule.actions),
+        rule.priority,
+        rule.deployedAt,
+        rule.createdAt
+      );
+    }
+    for (const run of dataset.executionRuns) {
+      insertRun.run(
+        run.id,
+        run.sourceType,
+        run.ruleId,
+        run.dryRun ? 1 : 0,
+        JSON.stringify(run.requestedActions),
+        run.query,
+        run.status,
+        run.createdAt,
+        run.undoneAt
+      );
+    }
+    for (const item of dataset.executionItems) {
+      insertItem.run(
+        item.id,
+        item.runId,
+        item.emailId,
+        item.status,
+        JSON.stringify(item.appliedActions),
+        JSON.stringify(item.beforeLabelIds),
+        JSON.stringify(item.afterLabelIds),
+        item.errorMessage,
+        item.executedAt,
+        item.undoneAt
+      );
+    }
+    for (const newsletter of dataset.newsletters) {
+      insertNewsletter.run(
+        newsletter.id,
+        newsletter.email,
+        newsletter.name,
+        newsletter.messageCount,
+        newsletter.unreadCount,
+        newsletter.status,
+        newsletter.unsubscribeLink,
+        newsletter.detectionReason,
+        newsletter.firstSeen,
+        newsletter.lastSeen
+      );
+    }
+    sqlite.prepare(
+      `
+        UPDATE sync_state
+        SET account_email = ?,
+            history_id = ?,
+            last_full_sync = ?,
+            last_incremental_sync = ?,
+            total_messages = ?,
+            full_sync_cursor = NULL,
+            full_sync_processed = 0,
+            full_sync_total = 0
+        WHERE id = 1
+        `
+    ).run(
+      dataset.accountEmail,
+      dataset.historyId,
+      referenceNow - 2 * 60 * 60 * 1e3,
+      referenceNow - 5 * 60 * 1e3,
+      dataset.messages.length
+    );
+  });
+  transaction();
+  return dataset;
+}
+
+// src/core/demo/index.ts
+var DEMO_ENV_KEYS = [
+  "INBOXCTL_DATA_DIR",
+  "INBOXCTL_DB_PATH",
+  "INBOXCTL_RULES_DIR",
+  "INBOXCTL_TOKENS_PATH",
+  "GOOGLE_CLIENT_ID",
+  "GOOGLE_CLIENT_SECRET",
+  "GOOGLE_REDIRECT_URI"
+];
+async function seedDemoRulesDirectory(rulesDir) {
+  const sourcePath = fileURLToPath(
+    new URL("../rules/example.yaml", import.meta.url)
+  );
+  const targetPath = join(rulesDir, "example.yaml");
+  await mkdir(rulesDir, { recursive: true });
+  await writeFile(targetPath, await readFile(sourcePath, "utf8"), "utf8");
+}
+async function runDemoSession() {
+  const previousEnv = Object.fromEntries(
+    DEMO_ENV_KEYS.map((key) => [key, process.env[key]])
+  );
+  const tempDir = await mkdtemp(join(tmpdir(), "inboxctl-demo-"));
+  const dbPath = join(tempDir, "demo.db");
+  const rulesDir = join(tempDir, "rules");
+  const tokensPath = join(tempDir, "tokens.json");
+  const referenceNow = Date.now();
+  process.env.INBOXCTL_DATA_DIR = tempDir;
+  process.env.INBOXCTL_DB_PATH = dbPath;
+  process.env.INBOXCTL_RULES_DIR = rulesDir;
+  process.env.INBOXCTL_TOKENS_PATH = tokensPath;
+  process.env.GOOGLE_CLIENT_ID = "demo-client-id";
+  process.env.GOOGLE_CLIENT_SECRET = "demo-client-secret";
+  process.env.GOOGLE_REDIRECT_URI = "http://127.0.0.1:3456/callback";
+  try {
+    await mkdir(dirname(tokensPath), { recursive: true });
+    await seedDemoRulesDirectory(rulesDir);
+    initializeDb(dbPath);
+    const sqlite = getSqlite(dbPath);
+    const dataset = seedDemoData(sqlite, referenceNow);
+    await saveTokens(tokensPath, {
+      accessToken: "demo-access-token",
+      refreshToken: "demo-refresh-token",
+      expiryDate: referenceNow + 365 * 24 * 60 * 60 * 1e3,
+      email: DEMO_ACCOUNT_EMAIL
+    });
+    const config = loadConfig();
+    setGmailTransportOverride(config.dataDir, createDemoTransport(dataset));
+    await syncLabels({ config, forceRefresh: true });
+    await startTuiApp({ noSync: true });
+  } finally {
+    try {
+      clearGmailTransportOverride(tempDir);
+      closeDb(dbPath);
+      await rm(tempDir, { recursive: true, force: true });
+    } finally {
+      for (const key of DEMO_ENV_KEYS) {
+        const value = previousEnv[key];
+        if (value === void 0) {
+          delete process.env[key];
+        } else {
+          process.env[key] = value;
+        }
+      }
+    }
+  }
+}
+
+// src/core/setup/setup.ts
+import {
+  cancel,
+  confirm,
+  intro,
+  isCancel,
+  log,
+  note,
+  outro,
+  password,
+  spinner,
+  text
+} from "@clack/prompts";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { resolve } from "path";
+
+// src/core/setup/gcloud.ts
+import { spawnSync } from "child_process";
+import open from "open";
+function runGcloud(args, inheritStdio = false) {
+  const result = spawnSync("gcloud", args, {
+    encoding: "utf8",
+    stdio: inheritStdio ? "inherit" : "pipe"
+  });
+  if (result.error) {
+    return {
+      success: false,
+      stdout: "",
+      stderr: "",
+      error: result.error.message
+    };
+  }
+  return {
+    success: result.status === 0,
+    stdout: typeof result.stdout === "string" ? result.stdout : "",
+    stderr: typeof result.stderr === "string" ? result.stderr : ""
+  };
+}
+function normalizeValue(value) {
+  const trimmed = value.trim();
+  if (!trimmed || trimmed === "(unset)") {
+    return null;
+  }
+  return trimmed;
+}
+function checkGcloudInstalled() {
+  return runGcloud(["--version"]).success;
+}
+function getGcloudActiveAccount() {
+  const result = runGcloud([
+    "auth",
+    "list",
+    "--filter=status:ACTIVE",
+    "--format=value(account)"
+  ]);
+  if (!result.success) {
+    return null;
+  }
+  return normalizeValue(result.stdout);
+}
+function checkGcloudAuthenticated() {
+  return getGcloudActiveAccount() !== null;
+}
+function runGcloudAuthLogin() {
+  const result = runGcloud(["auth", "login"], true);
+  return result.success ? { success: true } : { success: false, error: result.error || result.stderr || "gcloud auth login failed." };
+}
+function getGcloudProject() {
+  const result = runGcloud(["config", "get-value", "project", "--quiet"]);
+  if (!result.success) {
+    return null;
+  }
+  return normalizeValue(result.stdout);
+}
+function enableApi(projectId, api) {
+  const result = runGcloud(["services", "enable", api, "--project", projectId]);
+  if (result.success) {
+    return { success: true };
+  }
+  return {
+    success: false,
+    error: normalizeValue(result.stderr) || normalizeValue(result.stdout) || result.error || `Failed to enable ${api}.`
+  };
+}
+function openBrowser(url) {
+  void open(url, {
+    wait: false,
+    newInstance: false
+  }).catch(() => {
+  });
+}
+
+// src/core/setup/credentials.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { dirname as dirname2 } from "path";
+function readStoredConfig(configPath) {
+  if (!existsSync(configPath)) {
+    return {};
+  }
+  const raw = readFileSync(configPath, "utf8");
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Invalid config file at ${configPath}: expected JSON object`);
+  }
+  return parsed;
+}
+function writeGoogleCredentials(credentials, configPath = getConfigFilePath(getDefaultDataDir())) {
+  const current = readStoredConfig(configPath);
+  ensureDir(dirname2(configPath));
+  const next = {
+    ...current,
+    google: {
+      ...current.google || {},
+      clientId: credentials.clientId,
+      clientSecret: credentials.clientSecret,
+      redirectUri: credentials.redirectUri || current.google?.redirectUri || DEFAULT_GOOGLE_REDIRECT_URI
+    }
+  };
+  writeFileSync(configPath, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+}
+
+// src/core/setup/setup.ts
+var GMAIL_API = "gmail.googleapis.com";
+var AUDIENCE_URL = "https://console.cloud.google.com/auth/audience";
+var CREDENTIALS_URL = "https://console.cloud.google.com/apis/credentials";
+function withProject(url, projectId) {
+  return projectId ? `${url}?project=${encodeURIComponent(projectId)}` : url;
+}
+function validateProjectId(value) {
+  if (!value?.trim()) {
+    return "Enter a Google Cloud project ID.";
+  }
+  return void 0;
+}
+function validateClientId(value) {
+  if (!value?.trim()) {
+    return "Enter a Google OAuth client ID.";
+  }
+  if (!value.includes(".apps.googleusercontent.com")) {
+    return "Google client IDs usually end with .apps.googleusercontent.com.";
+  }
+  return void 0;
+}
+function validateClientSecret(value) {
+  if (!value?.trim()) {
+    return "Enter a Google OAuth client secret.";
+  }
+  return void 0;
+}
+function validateRedirectUri(value) {
+  if (!value?.trim()) {
+    return "Enter a redirect URI.";
+  }
+  try {
+    const parsed = new URL(value);
+    if (!parsed.protocol.startsWith("http")) {
+      return "Redirect URI must start with http:// or https://.";
+    }
+  } catch {
+    return "Enter a valid redirect URI.";
+  }
+  return void 0;
+}
+async function promptValue(promise, cancelMessage) {
+  const value = await promise;
+  if (isCancel(value)) {
+    cancel(cancelMessage);
+    return null;
+  }
+  return value;
+}
+function printConsentScreenHelp(projectId) {
+  note(
+    [
+      "In Google Cloud Console, go to Google Auth Platform > Audience.",
+      "",
+      "1. Set User type:",
+      "   External \u2014 required for personal Gmail (@gmail.com).",
+      "   Internal \u2014 only if your account is part of a Google Workspace org.",
+      "             Personal Gmail accounts cannot use Internal.",
+      "",
+      "2. Complete the Branding section (app name, support email, etc.)",
+      "",
+      '3. Publishing status should be "Testing" (this is the default).',
+      "",
+      "4. IMPORTANT: Scroll down to Test Users and click + Add Users.",
+      "   Add your Gmail address here. Without this you will get",
+      '   "Error 403: access_denied" when signing in.',
+      "",
+      `Console: ${withProject(AUDIENCE_URL, projectId)}`
+    ].join("\n"),
+    "OAuth Consent Screen (Audience)"
+  );
+}
+function printCredentialHelp(projectId, redirectUri) {
+  note(
+    [
+      "Create an OAuth 2.0 client with these settings:",
+      "",
+      '1. Application type: "Web application"',
+      '2. Name: "inboxctl"',
+      `3. Authorized redirect URI: ${redirectUri}`,
+      "4. Click Create and copy the Client ID and Client Secret",
+      "",
+      `Console: ${withProject(CREDENTIALS_URL, projectId)}`
+    ].join("\n"),
+    "OAuth Credentials"
+  );
+}
+function findEnvFile() {
+  const candidates = [
+    resolve(process.cwd(), ".env"),
+    resolve(process.cwd(), ".env.local")
+  ];
+  return candidates.find((p) => existsSync2(p)) || null;
+}
+function updateEnvFile(envPath, credentials) {
+  let content = readFileSync2(envPath, "utf8");
+  const replacements = [
+    ["GOOGLE_CLIENT_ID", credentials.clientId],
+    ["GOOGLE_CLIENT_SECRET", credentials.clientSecret],
+    ["GOOGLE_REDIRECT_URI", credentials.redirectUri]
+  ];
+  for (const [key, value] of replacements) {
+    const regex = new RegExp(`^${key}=.*$`, "m");
+    if (regex.test(content)) {
+      content = content.replace(regex, `${key}=${value}`);
+    }
+  }
+  writeFileSync2(envPath, content, "utf8");
+}
+async function handleEnvironmentOverrides(credentials) {
+  const overrides = ["GOOGLE_CLIENT_ID", "GOOGLE_CLIENT_SECRET", "GOOGLE_REDIRECT_URI"].filter((key) => Boolean(process.env[key]));
+  if (overrides.length === 0) {
+    return;
+  }
+  const envPath = findEnvFile();
+  if (envPath && credentials) {
+    log.warn(
+      `Your .env file (${envPath}) has credentials that override config.json.`
+    );
+    const shouldUpdate = await promptValue(
+      confirm({
+        message: "Update .env with the new credentials too?",
+        initialValue: true
+      }),
+      "Setup cancelled."
+    );
+    if (shouldUpdate) {
+      updateEnvFile(envPath, credentials);
+      process.env.GOOGLE_CLIENT_ID = credentials.clientId;
+      process.env.GOOGLE_CLIENT_SECRET = credentials.clientSecret;
+      process.env.GOOGLE_REDIRECT_URI = credentials.redirectUri;
+      log.success(`.env updated at ${envPath}`);
+    } else {
+      note(
+        `Your .env values still override config.json for: ${overrides.join(", ")}.
+If auth fails, update or remove those overrides in your .env file.`,
+        "Environment Overrides"
+      );
+    }
+  } else {
+    note(
+      `Environment variables override config.json for: ${overrides.join(", ")}.
+If the wizard's saved credentials do not take effect, update or remove those overrides first.`,
+      "Environment Overrides"
+    );
+  }
+}
+function verifyOAuthSetup() {
+  const config = loadConfig();
+  const readiness = getOAuthReadiness(config);
+  if (!readiness.ready) {
+    throw new Error(`OAuth credentials are still incomplete: ${readiness.missing.join(", ")}`);
+  }
+  const client = createOAuthClient(config);
+  client.generateAuthUrl({
+    access_type: "offline",
+    scope: GMAIL_SCOPES
+  });
+}
+async function runSetupWizard(options = {}) {
+  intro("inboxctl Setup Wizard");
+  const initialConfig = loadConfig();
+  const configPath = getConfigFilePath(initialConfig.dataDir);
+  const existingGoogleStatus = getGoogleCredentialStatus(initialConfig);
+  let useGcloud = !options.skipGcloud;
+  let projectId = options.project || null;
+  let credentialsUpdated = false;
+  let gmailApiEnabled = false;
+  let authenticatedEmail = null;
+  if (useGcloud) {
+    const gcloudSpinner = spinner();
+    gcloudSpinner.start("Checking gcloud CLI...");
+    if (!checkGcloudInstalled()) {
+      gcloudSpinner.error("gcloud CLI not found.");
+      note(
+        "Install the Google Cloud CLI to let inboxctl enable the Gmail API for you.\nYou can still continue with the manual credential flow if you prefer.",
+        "gcloud CLI"
+      );
+      const continueManual = await promptValue(
+        confirm({
+          message: "Continue with manual setup only?",
+          initialValue: true
+        }),
+        "Setup cancelled."
+      );
+      if (!continueManual) {
+        cancel("Setup cancelled.");
+        return {
+          completed: false,
+          configPath,
+          projectId,
+          credentialsUpdated,
+          usedGcloud: false,
+          authenticatedEmail
+        };
+      }
+      useGcloud = false;
+    } else {
+      const account = getGcloudActiveAccount();
+      gcloudSpinner.stop(account ? `gcloud CLI found (${account})` : "gcloud CLI found");
+    }
+  }
+  if (useGcloud && !checkGcloudAuthenticated()) {
+    log.warn("gcloud is installed but not authenticated.");
+    const shouldLogin = await promptValue(
+      confirm({
+        message: "Run `gcloud auth login` now?",
+        initialValue: true
+      }),
+      "Setup cancelled."
+    );
+    if (!shouldLogin) {
+      const continueManual = await promptValue(
+        confirm({
+          message: "Continue without gcloud and finish setup manually?",
+          initialValue: true
+        }),
+        "Setup cancelled."
+      );
+      if (!continueManual) {
+        cancel("Setup cancelled.");
+        return {
+          completed: false,
+          configPath,
+          projectId,
+          credentialsUpdated,
+          usedGcloud: false,
+          authenticatedEmail
+        };
+      }
+      useGcloud = false;
+    } else {
+      const loginResult = runGcloudAuthLogin();
+      if (!loginResult.success || !checkGcloudAuthenticated()) {
+        throw new Error(loginResult.error || "gcloud authentication did not complete successfully.");
+      }
+      const account = getGcloudActiveAccount();
+      log.success(account ? `Authenticated as ${account}` : "gcloud authentication complete.");
+    }
+  }
+  if (useGcloud) {
+    projectId = projectId || getGcloudProject();
+    if (!projectId) {
+      projectId = await promptValue(
+        text({
+          message: "Google Cloud project ID",
+          placeholder: "my-project-123",
+          validate: validateProjectId
+        }),
+        "Setup cancelled."
+      );
+    } else {
+      log.step(`Using project: ${projectId}`);
+    }
+    if (!projectId) {
+      cancel("Setup cancelled.");
+      return {
+        completed: false,
+        configPath,
+        projectId: null,
+        credentialsUpdated,
+        usedGcloud: true,
+        authenticatedEmail
+      };
+    }
+    const enableSpinner = spinner();
+    enableSpinner.start("Enabling Gmail API...");
+    const enabled = enableApi(projectId, GMAIL_API);
+    if (!enabled.success) {
+      enableSpinner.error(`Failed to enable Gmail API: ${enabled.error}`);
+      const continueManual = await promptValue(
+        confirm({
+          message: "Continue anyway and finish the remaining setup steps manually?",
+          initialValue: false
+        }),
+        "Setup cancelled."
+      );
+      if (!continueManual) {
+        cancel("Setup cancelled.");
+        return {
+          completed: false,
+          configPath,
+          projectId,
+          credentialsUpdated,
+          usedGcloud: true,
+          authenticatedEmail
+        };
+      }
+    } else {
+      enableSpinner.stop("Gmail API enabled.");
+      gmailApiEnabled = true;
+    }
+  }
+  const consentAlreadyConfigured = existingGoogleStatus.configured ? await promptValue(
+    confirm({
+      message: "Is the OAuth consent screen already configured for this project?",
+      initialValue: false
+    }),
+    "Setup cancelled."
+  ) : false;
+  if (consentAlreadyConfigured === null) {
+    return {
+      completed: false,
+      configPath,
+      projectId,
+      credentialsUpdated,
+      usedGcloud: useGcloud,
+      authenticatedEmail
+    };
+  }
+  if (!consentAlreadyConfigured) {
+    printConsentScreenHelp(projectId);
+    log.step(`Opening ${withProject(AUDIENCE_URL, projectId)}`);
+    openBrowser(withProject(AUDIENCE_URL, projectId));
+    const completedConsent = await promptValue(
+      confirm({
+        message: "Have you completed the consent screen setup?",
+        initialValue: false
+      }),
+      "Setup cancelled."
+    );
+    if (!completedConsent) {
+      cancel("Finish the consent screen setup, then rerun `inboxctl setup`.");
+      return {
+        completed: false,
+        configPath,
+        projectId,
+        credentialsUpdated,
+        usedGcloud: useGcloud,
+        authenticatedEmail
+      };
+    }
+    note(
+      `When you sign in, you may see "This app isn't verified".
+This is normal for personal/testing apps. Click "Advanced", then
+"Go to inboxctl (unsafe)" to continue.`,
+      "Unverified App Warning"
+    );
+  } else {
+    note(
+      `Quick check \u2014 verify these in Google Auth Platform > Audience:
+
+- User type is External (required for personal Gmail)
+- Your Gmail address is listed under Test Users
+  (without this you will get "Error 403: access_denied")
+
+Verify at: ${withProject(AUDIENCE_URL, projectId)}`,
+      "Consent Screen Checklist"
+    );
+    note(
+      `When you sign in, you may see "This app isn't verified".
+This is normal for personal/testing apps. Click "Advanced", then
+"Go to inboxctl (unsafe)" to continue.`,
+      "Unverified App Warning"
+    );
+  }
+  const shouldReplaceCredentials = existingGoogleStatus.configured ? await promptValue(
+    confirm({
+      message: "Google OAuth credentials already exist. Replace them?",
+      initialValue: false
+    }),
+    "Setup cancelled."
+  ) : true;
+  if (shouldReplaceCredentials === null) {
+    return {
+      completed: false,
+      configPath,
+      projectId,
+      credentialsUpdated,
+      usedGcloud: useGcloud,
+      authenticatedEmail
+    };
+  }
+  const redirectUri = initialConfig.google.redirectUri || DEFAULT_GOOGLE_REDIRECT_URI;
+  if (shouldReplaceCredentials) {
+    printCredentialHelp(projectId, redirectUri);
+    log.step(`Opening ${withProject(CREDENTIALS_URL, projectId)}`);
+    openBrowser(withProject(CREDENTIALS_URL, projectId));
+    const clientId = await promptValue(
+      text({
+        message: "Paste your Google Client ID",
+        placeholder: "123456789.apps.googleusercontent.com",
+        validate: validateClientId
+      }),
+      "Setup cancelled."
+    );
+    if (!clientId) {
+      return {
+        completed: false,
+        configPath,
+        projectId,
+        credentialsUpdated,
+        usedGcloud: useGcloud,
+        authenticatedEmail
+      };
+    }
+    const clientSecret = await promptValue(
+      password({
+        message: "Paste your Google Client Secret",
+        validate: validateClientSecret
+      }),
+      "Setup cancelled."
+    );
+    if (!clientSecret) {
+      return {
+        completed: false,
+        configPath,
+        projectId,
+        credentialsUpdated,
+        usedGcloud: useGcloud,
+        authenticatedEmail
+      };
+    }
+    const selectedRedirectUri = await promptValue(
+      text({
+        message: "Redirect URI",
+        initialValue: redirectUri,
+        validate: validateRedirectUri
+      }),
+      "Setup cancelled."
+    );
+    if (!selectedRedirectUri) {
+      return {
+        completed: false,
+        configPath,
+        projectId,
+        credentialsUpdated,
+        usedGcloud: useGcloud,
+        authenticatedEmail
+      };
+    }
+    const saveSpinner = spinner();
+    saveSpinner.start(`Saving credentials to ${configPath}...`);
+    writeGoogleCredentials({
+      clientId,
+      clientSecret,
+      redirectUri: selectedRedirectUri
+    }, configPath);
+    saveSpinner.stop("Credentials saved.");
+    credentialsUpdated = true;
+    await handleEnvironmentOverrides({
+      clientId,
+      clientSecret,
+      redirectUri: selectedRedirectUri
+    });
+  } else {
+    log.step("Keeping existing Google OAuth credentials from config.json.");
+    await handleEnvironmentOverrides(null);
+  }
+  const verifySpinner = spinner();
+  verifySpinner.start("Verifying setup...");
+  verifyOAuthSetup();
+  verifySpinner.stop("OAuth credentials look valid.");
+  const shouldAuthenticateNow = await promptValue(
+    confirm({
+      message: "Authenticate a Gmail account now?",
+      initialValue: true
+    }),
+    "Setup cancelled."
+  );
+  if (shouldAuthenticateNow === null) {
+    return {
+      completed: false,
+      configPath,
+      projectId,
+      credentialsUpdated,
+      usedGcloud: useGcloud,
+      authenticatedEmail
+    };
+  }
+  if (shouldAuthenticateNow) {
+    log.step("Starting Gmail sign-in in your browser...");
+    try {
+      const activeConfig = loadConfig();
+      const authResult = await startOAuthFlow(activeConfig);
+      authenticatedEmail = authResult.email;
+      const reconciliation = reconcileCacheForAuthenticatedAccount(
+        activeConfig.dbPath,
+        authenticatedEmail,
+        { clearLegacyUnscoped: true }
+      );
+      log.success(
+        authenticatedEmail && authenticatedEmail !== "unknown" ? `Authenticated Gmail account: ${authenticatedEmail}` : "Gmail authentication complete."
+      );
+      if (reconciliation.cleared) {
+        log.step("Local cache reset to avoid mixing data from another Gmail account.");
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("access_denied") || message.includes("access denied")) {
+        log.error("Google blocked the sign-in request.");
+        note(
+          "This usually means one of:\n- Your Gmail address is not added as a test user (for External apps)\n- You chose Internal but are using a personal Gmail account\n\nFix it in Google Auth Platform > Audience, then retry with: inboxctl auth login",
+          "Access Denied"
+        );
+      } else {
+        throw error;
+      }
+    }
+  }
+  note(
+    [
+      gmailApiEnabled && projectId ? `\u2713 Gmail API enabled for project ${projectId}` : "\u2713 Gmail API step reviewed",
+      "\u2713 OAuth consent screen reviewed",
+      existingGoogleStatus.configured && !credentialsUpdated ? "\u2713 Existing OAuth credentials kept" : `\u2713 OAuth credentials saved to ${configPath}`,
+      authenticatedEmail ? `\u2713 Gmail authenticated as ${authenticatedEmail}` : "\u2713 Gmail authentication ready",
+      "",
+      authenticatedEmail ? "You can start using inboxctl now." : "Next: run `inboxctl auth login` to authenticate your Gmail account."
+    ].join("\n"),
+    "Setup Complete"
+  );
+  outro("Setup complete.");
+  return {
+    completed: true,
+    configPath,
+    projectId,
+    credentialsUpdated,
+    usedGcloud: useGcloud,
+    authenticatedEmail
+  };
+}
+
+// src/cli.ts
+var program = new Command();
+var colorEnabled = output.isTTY && process.env.NO_COLOR === void 0;
+function ansi(code, value) {
+  return colorEnabled ? `\x1B[${code}m${value}\x1B[0m` : value;
+}
+var ui = {
+  bold: (value) => ansi(1, value),
+  dim: (value) => ansi(2, value),
+  cyan: (value) => ansi(36, value),
+  green: (value) => ansi(32, value),
+  yellow: (value) => ansi(33, value),
+  red: (value) => ansi(31, value),
+  magenta: (value) => ansi(35, value)
+};
+function stripAnsi2(value) {
+  return value.replace(/\u001B\[[0-9;]*m/g, "");
+}
+function truncate2(value, width) {
+  if (width <= 0) {
+    return "";
+  }
+  if (value.length <= width) {
+    return value;
+  }
+  if (width <= 1) {
+    return value.slice(0, width);
+  }
+  return `${value.slice(0, width - 1)}\u2026`;
+}
+function pad2(value, width) {
+  const visible = stripAnsi2(value);
+  if (visible.length >= width) {
+    return value;
+  }
+  return `${value}${" ".repeat(width - visible.length)}`;
+}
+function printSection(title) {
+  console.log(ui.bold(title));
+}
+function printKeyValue(label, value) {
+  console.log(`${ui.dim(`${label}:`)} ${value}`);
+}
+function formatStatus(status) {
+  const upper = status.toUpperCase();
+  switch (status) {
+    case "applied":
+    case "undone":
+      return ui.green(upper);
+    case "warning":
+    case "partial":
+    case "noop":
+      return ui.yellow(upper);
+    case "error":
+      return ui.red(upper);
+    case "planned":
+      return ui.cyan(upper);
+  }
+}
+function hasLabelChange(item) {
+  return item.beforeLabelIds.join("\0") !== item.afterLabelIds.join("\0");
+}
+function formatList(values) {
+  return values.length > 0 ? values.join(", ") : "none";
+}
+async function loadRuntimeStatus() {
+  const config = loadConfig();
+  initializeDb(config.dbPath);
+  const tokens = await loadTokens(config.tokensPath);
+  const googleStatus = getGoogleCredentialStatus(config);
+  const gmailReadiness = getGmailReadiness(config, tokens);
+  return {
+    config,
+    tokensPresent: tokens !== null,
+    tokenExpired: tokens ? isTokenExpired(tokens) : null,
+    googleConfigured: googleStatus.configured,
+    googleMissing: googleStatus.missing,
+    gmailReady: gmailReadiness.ready
+  };
+}
+function printCheckpointSummary(status) {
+  printSection("Environment");
+  printKeyValue("dataDir", status.config.dataDir);
+  printKeyValue("dbPath", status.config.dbPath);
+  printKeyValue("rulesDir", status.config.rulesDir);
+  printKeyValue("tokensPath", status.config.tokensPath);
+  printKeyValue(
+    "googleCredentials",
+    status.googleConfigured ? ui.green("configured") : ui.red("missing")
+  );
+  printKeyValue("missingGoogleCredentials", formatList(status.googleMissing));
+  printKeyValue("tokens", status.tokensPresent ? ui.green("present") : ui.red("missing"));
+  printKeyValue(
+    "tokenExpired",
+    status.tokenExpired === null ? ui.dim("unknown (no tokens yet)") : status.tokenExpired ? ui.red("yes") : ui.green("no")
+  );
+  printKeyValue("gmailReady", status.gmailReady ? ui.green("yes") : ui.red("no"));
+}
+function printGoogleCheckpointInstructions(status) {
+  console.log("");
+  console.log("Gmail access is not ready yet.");
+  if (!status.googleConfigured) {
+    console.log("Still needed:");
+    console.log(`- GOOGLE_CLIENT_ID${status.googleMissing.includes("GOOGLE_CLIENT_ID") ? " (missing)" : ""}`);
+    console.log(
+      `- GOOGLE_CLIENT_SECRET${status.googleMissing.includes("GOOGLE_CLIENT_SECRET") ? " (missing)" : ""}`
+    );
+    console.log("- OAuth consent screen configured in Google Cloud");
+    console.log("- Localhost redirect URI allowed for the OAuth client");
+    console.log("- Run `inboxctl setup` to configure this interactively");
+    return;
+  }
+  if (!status.tokensPresent) {
+    console.log("Google OAuth credentials are configured, but no Gmail account is authenticated yet.");
+    console.log("- Run `inboxctl auth login` to sign in");
+    return;
+  }
+  if (status.tokenExpired) {
+    console.log("A Gmail account was authenticated before, but the saved token is expired or unusable.");
+    console.log("- Run `inboxctl auth login` again");
+    return;
+  }
+  console.log("Google OAuth is configured, but Gmail readiness still failed.");
+  console.log("- Re-run `inboxctl auth login`");
+}
+async function requireLiveGmailReadiness(commandName) {
+  const status = await loadRuntimeStatus();
+  if (!status.gmailReady) {
+    console.log(`${commandName} requires authenticated Gmail access.`);
+    printCheckpointSummary(status);
+    printGoogleCheckpointInstructions(status);
+    process.exitCode = 1;
+    return;
+  }
+}
+async function resolveAuthenticatedEmail(config) {
+  const tokens = await loadTokens(config.tokensPath);
+  if (!tokens) {
+    return null;
+  }
+  if (tokens.email && tokens.email !== "unknown") {
+    return tokens.email;
+  }
+  const transport = await getGmailTransport(config);
+  const profile = await transport.getProfile();
+  if (!profile.emailAddress) {
+    return null;
+  }
+  await saveTokens(config.tokensPath, {
+    ...tokens,
+    email: profile.emailAddress
+  });
+  return profile.emailAddress;
+}
+function formatEmailRow(email) {
+  const state = pad2(email.isRead ? ui.dim("read") : ui.yellow("unread"), 6);
+  const date = ui.dim(new Date(email.date).toISOString().slice(0, 10));
+  const sender = pad2(truncate2(email.fromAddress, 30), 30);
+  const subject = truncate2(email.subject, 58);
+  const id = ui.dim(email.id);
+  return `${state}  ${date}  ${sender}  ${subject} ${id}`;
+}
+function printEmailTableHeader() {
+  console.log(
+    [
+      pad2(ui.dim("STATE"), 6),
+      ui.dim("DATE"),
+      pad2(ui.dim("FROM"), 30),
+      ui.dim("SUBJECT"),
+      ui.dim("ID")
+    ].join("  ")
+  );
+}
+function formatTimestamp(value) {
+  if (!value) {
+    return "-";
+  }
+  return new Date(value).toISOString();
+}
+function formatDate(value) {
+  if (!value) {
+    return "-";
+  }
+  const timestamp = value instanceof Date ? value.getTime() : value;
+  return new Date(timestamp).toISOString().slice(0, 10);
+}
+function formatRelativeTime2(value) {
+  if (!value) {
+    return "-";
+  }
+  const timestamp = value instanceof Date ? value.getTime() : value;
+  const diff = Date.now() - timestamp;
+  if (diff < 0) {
+    return formatDate(timestamp);
+  }
+  if (diff < 6e4) {
+    return `${Math.max(1, Math.floor(diff / 1e3))}s ago`;
+  }
+  if (diff < 36e5) {
+    return `${Math.floor(diff / 6e4)}m ago`;
+  }
+  if (diff < 864e5) {
+    return `${Math.floor(diff / 36e5)}h ago`;
+  }
+  if (diff < 6048e5) {
+    return `${Math.floor(diff / 864e5)}d ago`;
+  }
+  if (diff < 2592e6) {
+    return `${Math.floor(diff / 6048e5)}w ago`;
+  }
+  return formatDate(timestamp);
+}
+function formatPercent2(value) {
+  const normalized = Number.isInteger(value) ? String(value) : value.toFixed(1).replace(/\.0$/, "");
+  return `${normalized}%`;
+}
+function formatSenderIdentity(name, email, width) {
+  const identity = name && name !== email ? `${name} <${email}>` : email;
+  return pad2(truncate2(identity, width), width);
+}
+function parseIntegerOption(value, label, min = 1) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < min) {
+    throw new Error(`${label} must be an integer greater than or equal to ${min}.`);
+  }
+  return parsed;
+}
+function parsePercentOption(value, label) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  if (Number.isNaN(parsed) || parsed < 0 || parsed > 100) {
+    throw new Error(`${label} must be between 0 and 100.`);
+  }
+  return parsed;
+}
+function printInboxOverview(overview) {
+  printSection("Inbox Overview");
+  printKeyValue("total", String(overview.total));
+  printKeyValue("unread", overview.unread > 0 ? ui.yellow(String(overview.unread)) : ui.dim("0"));
+  printKeyValue("starred", overview.starred > 0 ? ui.magenta(String(overview.starred)) : ui.dim("0"));
+  printKeyValue(
+    "today",
+    `${overview.today.received} received, ${overview.today.unread} unread`
+  );
+  printKeyValue(
+    "thisWeek",
+    `${overview.thisWeek.received} received, ${overview.thisWeek.unread} unread`
+  );
+  printKeyValue(
+    "thisMonth",
+    `${overview.thisMonth.received} received, ${overview.thisMonth.unread} unread`
+  );
+  printKeyValue(
+    "oldestUnread",
+    overview.oldestUnread ? `${formatRelativeTime2(overview.oldestUnread)} (${formatDate(overview.oldestUnread)})` : "-"
+  );
+}
+function printTopSendersTable(label, senders) {
+  printSection(`Top Senders (${label})`);
+  console.log(
+    [
+      pad2(ui.dim("SENDER"), 42),
+      pad2(ui.dim("TOTAL"), 7),
+      pad2(ui.dim("UNREAD"), 8),
+      pad2(ui.dim("UNREAD%"), 8),
+      ui.dim("LAST EMAIL")
+    ].join("  ")
+  );
+  for (const sender of senders) {
+    console.log(
+      [
+        formatSenderIdentity(sender.name, sender.email, 42),
+        pad2(String(sender.totalMessages), 7),
+        pad2(String(sender.unreadMessages), 8),
+        pad2(formatPercent2(sender.unreadRate), 8),
+        formatRelativeTime2(sender.lastEmailDate)
+      ].join("  ")
+    );
+  }
+}
+function printNewslettersTable(newsletters) {
+  printSection("Newsletters");
+  console.log(
+    [
+      pad2(ui.dim("SENDER"), 36),
+      pad2(ui.dim("TOTAL"), 7),
+      pad2(ui.dim("UNREAD"), 8),
+      pad2(ui.dim("UNREAD%"), 8),
+      pad2(ui.dim("STATUS"), 14),
+      pad2(ui.dim("LAST EMAIL"), 11),
+      ui.dim("REASON")
+    ].join("  ")
+  );
+  for (const sender of newsletters) {
+    const statusColor = sender.status === "active" ? ui.green(sender.status) : sender.status === "archived" ? ui.dim(sender.status) : ui.yellow(sender.status);
+    console.log(
+      [
+        formatSenderIdentity(sender.name, sender.email, 36),
+        pad2(String(sender.messageCount), 7),
+        pad2(String(sender.unreadCount), 8),
+        pad2(formatPercent2(sender.unreadRate), 8),
+        pad2(statusColor, 14),
+        pad2(formatRelativeTime2(sender.lastSeen), 11),
+        truncate2(sender.detectionReason, 32)
+      ].join("  ")
+    );
+  }
+}
+function printLabelDistributionTable(labels2) {
+  printSection("Label Distribution");
+  console.log(
+    [
+      pad2(ui.dim("LABEL"), 22),
+      pad2(ui.dim("TOTAL"), 7),
+      pad2(ui.dim("UNREAD"), 8),
+      ui.dim("ID")
+    ].join("  ")
+  );
+  for (const label of labels2) {
+    console.log(
+      [
+        pad2(truncate2(label.labelName, 22), 22),
+        pad2(String(label.totalMessages), 7),
+        pad2(String(label.unreadMessages), 8),
+        ui.dim(label.labelId)
+      ].join("  ")
+    );
+  }
+}
+function printVolumeTable(label, points) {
+  printSection(`Volume (${label})`);
+  console.log(
+    [
+      pad2(ui.dim("PERIOD"), 12),
+      pad2(ui.dim("RECEIVED"), 10),
+      pad2(ui.dim("READ"), 7),
+      pad2(ui.dim("UNREAD"), 8),
+      ui.dim("ARCHIVED")
+    ].join("  ")
+  );
+  for (const point of points) {
+    console.log(
+      [
+        pad2(point.period, 12),
+        pad2(String(point.received), 10),
+        pad2(String(point.read), 7),
+        pad2(String(point.unread), 8),
+        String(point.archived)
+      ].join("  ")
+    );
+  }
+}
+function printSenderDetail(detail) {
+  printSection(detail.query);
+  printKeyValue("type", detail.type);
+  printKeyValue("name", detail.name);
+  printKeyValue("messages", String(detail.totalMessages));
+  printKeyValue("unread", `${detail.unreadMessages} (${formatPercent2(detail.unreadRate)})`);
+  printKeyValue("firstSeen", formatDate(detail.firstEmailDate));
+  printKeyValue(
+    "lastSeen",
+    `${formatRelativeTime2(detail.lastEmailDate)} (${formatDate(detail.lastEmailDate)})`
+  );
+  printKeyValue("labels", detail.labels.join(", ") || "-");
+  if (detail.type === "domain") {
+    printKeyValue("matchedSenders", String(detail.matchingSenders.length));
+    for (const sender of detail.matchingSenders) {
+      console.log(`- ${sender}`);
+    }
+  }
+  if (detail.recentEmails.length === 0) {
+    return;
+  }
+  console.log("");
+  printSection("Recent Emails");
+  console.log(
+    [
+      pad2(ui.dim("STATE"), 6),
+      pad2(ui.dim("DATE"), 10),
+      pad2(ui.dim("FROM"), 30),
+      ui.dim("SUBJECT")
+    ].join("  ")
+  );
+  for (const email of detail.recentEmails) {
+    console.log(
+      [
+        pad2(email.isRead ? ui.dim("read") : ui.yellow("unread"), 6),
+        pad2(formatDate(email.date), 10),
+        pad2(truncate2(email.fromAddress, 30), 30),
+        truncate2(email.subject || "(no subject)", 60)
+      ].join("  ")
+    );
+  }
+}
+function getVolumeRange(period) {
+  const end = Date.now();
+  const dayMs = 24 * 60 * 60 * 1e3;
+  switch (period) {
+    case "day":
+      return { start: end - 30 * dayMs, end };
+    case "week":
+      return { start: end - 26 * 7 * dayMs, end };
+    case "month":
+      return { start: end - 365 * dayMs, end };
+  }
+}
+function formatActions(actions) {
+  if (actions.length === 0) {
+    return "none";
+  }
+  return actions.map((action) => {
+    switch (action.type) {
+      case "label":
+        return `label:${action.label}`;
+      case "forward":
+        return `forward:${action.to}`;
+      case "archive":
+        return "archive";
+      case "mark_read":
+        return "mark_read";
+      case "mark_spam":
+        return "mark_spam";
+    }
+  }).join(", ");
+}
+async function promptForConfirmation(message) {
+  const rl = createInterface({ input, output });
+  try {
+    const answer = await rl.question(`${message} [y/N] `);
+    const normalized = answer.trim().toLowerCase();
+    return normalized === "y" || normalized === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function collectMessageIdsForQuery(query) {
+  const config = loadConfig();
+  const transport = await getGmailTransport(config);
+  const ids = /* @__PURE__ */ new Set();
+  let pageToken;
+  do {
+    const response = await transport.listMessages({
+      query,
+      maxResults: 500,
+      pageToken
+    });
+    for (const message of response.messages || []) {
+      if (message.id) {
+        ids.add(message.id);
+      }
+    }
+    pageToken = response.nextPageToken || void 0;
+  } while (pageToken);
+  return [...ids];
+}
+async function resolveMessageIds(id, query) {
+  if (query) {
+    return collectMessageIdsForQuery(query);
+  }
+  if (!id) {
+    throw new Error("Provide an email ID or use --query to target matching Gmail messages.");
+  }
+  return [id];
+}
+async function confirmBatchIfNeeded(query, ids, verb) {
+  if (!query || ids.length <= 1) {
+    return;
+  }
+  const confirmed = await promptForConfirmation(
+    `Found ${ids.length} emails matching "${query}"
+${verb} all ${ids.length} emails?`
+  );
+  if (!confirmed) {
+    throw new Error("Cancelled.");
+  }
+}
+async function recordManualRun(options) {
+  const run = await createExecutionRun({
+    sourceType: "manual",
+    ruleId: null,
+    dryRun: false,
+    requestedActions: options.requestedActions,
+    query: options.query || null,
+    status: options.result.items.every((item) => item.status === "applied") ? "applied" : options.result.items.some((item) => item.status === "applied" || item.status === "warning") ? "partial" : "error"
+  });
+  await addExecutionItems(
+    run.id,
+    options.result.items.map((item) => ({
+      emailId: item.emailId,
+      status: item.status,
+      appliedActions: options.requestedActions,
+      beforeLabelIds: item.beforeLabelIds,
+      afterLabelIds: item.afterLabelIds,
+      errorMessage: item.errorMessage || null
+    }))
+  );
+  return run.id;
+}
+function printMutationSummary(result, runId) {
+  const applied = result.items.filter((item) => item.status === "applied").length;
+  const warnings = result.items.filter((item) => item.status === "warning").length;
+  const errors = result.items.filter((item) => item.status === "error").length;
+  const noops = result.items.filter((item) => item.status === "applied" && !hasLabelChange(item)).length;
+  printSection(`Run ${ui.dim(runId)}`);
+  printKeyValue("total", String(result.items.length));
+  printKeyValue("applied", ui.green(String(applied)));
+  printKeyValue("noChange", noops > 0 ? ui.yellow(String(noops)) : ui.dim("0"));
+  printKeyValue("warnings", warnings > 0 ? ui.yellow(String(warnings)) : ui.dim("0"));
+  printKeyValue("errors", errors > 0 ? ui.red(String(errors)) : ui.dim("0"));
+  console.log("");
+  for (const item of result.items) {
+    const displayStatus = item.status === "applied" && !hasLabelChange(item) ? "noop" : item.status;
+    const line = [
+      pad2(formatStatus(displayStatus), 9),
+      ui.dim(item.emailId),
+      `${ui.dim("before")} ${item.beforeLabelIds.join(",") || "-"}`,
+      `${ui.dim("after")} ${item.afterLabelIds.join(",") || "-"}`
+    ].join("  ");
+    console.log(line);
+    if (item.errorMessage) {
+      console.log(`  ${ui.yellow("note")} ${item.errorMessage}`);
+    }
+  }
+}
+function printHistoryTable(runs) {
+  printSection("History");
+  console.log(
+    [
+      pad2(ui.dim("STATUS"), 10),
+      pad2(ui.dim("ACTION"), 20),
+      pad2(ui.dim("WHEN"), 22),
+      pad2(ui.dim("RUN ID"), 38),
+      ui.dim("QUERY")
+    ].join("  ")
+  );
+  for (const run of runs) {
+    console.log(
+      [
+        pad2(formatStatus(run.status), 10),
+        pad2(truncate2(formatActions(run.requestedActions), 20), 20),
+        pad2(ui.dim(formatTimestamp(run.createdAt)), 22),
+        pad2(ui.dim(run.id), 38),
+        truncate2(run.query || "-", 60)
+      ].join("  ")
+    );
+  }
+}
+function formatEnabled(enabled) {
+  return enabled ? ui.green("enabled") : ui.yellow("disabled");
+}
+function printRuleDeploySummary(result) {
+  const results = Array.isArray(result) ? result : [result];
+  printSection("Rules Deployed");
+  console.log(
+    [
+      pad2(ui.dim("STATUS"), 10),
+      pad2(ui.dim("NAME"), 28),
+      pad2(ui.dim("PRIORITY"), 8),
+      pad2(ui.dim("ENABLED"), 10),
+      ui.dim("FILE")
+    ].join("  ")
+  );
+  for (const entry of results) {
+    const statusColor = entry.status === "created" ? ui.green(entry.status.toUpperCase()) : entry.status === "updated" ? ui.yellow(entry.status.toUpperCase()) : ui.dim(entry.status.toUpperCase());
+    console.log(
+      [
+        pad2(statusColor, 10),
+        pad2(entry.name, 28),
+        pad2(String(entry.priority), 8),
+        pad2(formatEnabled(entry.enabled), 10),
+        truncate2("-", 60)
+      ].join("  ")
+    );
+  }
+}
+function printRuleStatusTable(rules2) {
+  printSection("Rules");
+  console.log(
+    [
+      pad2(ui.dim("NAME"), 28),
+      pad2(ui.dim("STATE"), 10),
+      pad2(ui.dim("PRIORITY"), 8),
+      pad2(ui.dim("RUNS"), 6),
+      pad2(ui.dim("LAST RUN"), 22),
+      ui.dim("ACTIONS")
+    ].join("  ")
+  );
+  for (const rule of rules2) {
+    console.log(
+      [
+        pad2(truncate2(rule.name, 28), 28),
+        pad2(formatEnabled(rule.enabled), 10),
+        pad2(String(rule.priority), 8),
+        pad2(String(rule.totalRuns), 6),
+        pad2(ui.dim(formatTimestamp(rule.lastExecutionAt)), 22),
+        truncate2(formatActions(rule.actions), 40)
+      ].join("  ")
+    );
+  }
+}
+function printRuleStatusDetail(rule) {
+  printSection(rule.name);
+  printKeyValue("description", rule.description || "-");
+  printKeyValue("enabled", formatEnabled(rule.enabled));
+  printKeyValue("priority", String(rule.priority));
+  printKeyValue("actions", formatActions(rule.actions));
+  printKeyValue("totalRuns", String(rule.totalRuns));
+  printKeyValue("appliedRuns", String(rule.appliedRuns));
+  printKeyValue("partialRuns", String(rule.partialRuns));
+  printKeyValue("errorRuns", String(rule.errorRuns));
+  printKeyValue("undoneRuns", String(rule.undoneRuns));
+  printKeyValue("lastRunId", rule.lastRunId ? ui.dim(rule.lastRunId) : "-");
+  printKeyValue("lastExecutionAt", ui.dim(formatTimestamp(rule.lastExecutionAt)));
+}
+function printRuleRunResult(result) {
+  printSection(`Rule ${result.rule.name}`);
+  printKeyValue("mode", result.dryRun ? ui.cyan("dry-run") : ui.green("apply"));
+  printKeyValue("runId", ui.dim(result.runId));
+  printKeyValue("status", formatStatus(result.status));
+  printKeyValue("matched", String(result.matchedCount));
+  printKeyValue("actions", formatActions(result.rule.actions));
+  console.log("");
+  if (result.items.length === 0) {
+    console.log("No matching cached emails.");
+    return;
+  }
+  for (const item of result.items) {
+    const subject = truncate2(item.subject || "(no subject)", 50);
+    const from = truncate2(item.fromAddress || "-", 28);
+    const date = ui.dim(new Date(item.date).toISOString().slice(0, 10));
+    console.log(
+      [
+        pad2(formatStatus(item.status), 9),
+        pad2(from, 28),
+        pad2(date, 12),
+        subject
+      ].join("  ")
+    );
+    console.log(`  ${ui.dim(item.emailId)} matched=${item.matchedFields.join(",") || "-"}`);
+    if (item.errorMessage) {
+      console.log(`  ${ui.yellow("note")} ${item.errorMessage}`);
+    }
+  }
+  if (result.dryRun) {
+    console.log("");
+    console.log("Run again with `--apply` to execute these actions.");
+  }
+}
+function printRunAllRulesResult(result) {
+  if (result.results.length === 0) {
+    console.log("No enabled rules are currently deployed.");
+    return;
+  }
+  for (const ruleResult of result.results) {
+    printRuleRunResult(ruleResult);
+    console.log("");
+  }
+}
+function printDriftReport(result) {
+  printSection("Rule Drift");
+  console.log(
+    [
+      pad2(ui.dim("STATUS"), 14),
+      pad2(ui.dim("NAME"), 28),
+      pad2(ui.dim("DEPLOYED"), 16),
+      pad2(ui.dim("FILE"), 16),
+      ui.dim("PATH")
+    ].join("  ")
+  );
+  for (const entry of result.entries) {
+    const label = entry.status === "in_sync" ? ui.green("IN_SYNC") : entry.status === "changed" ? ui.yellow("CHANGED") : ui.red(entry.status.toUpperCase());
+    console.log(
+      [
+        pad2(label, 14),
+        pad2(truncate2(entry.name, 28), 28),
+        pad2(truncate2(entry.deployedHash || "-", 16), 16),
+        pad2(truncate2(entry.fileHash || "-", 16), 16),
+        truncate2(entry.filePath || "-", 60)
+      ].join("  ")
+    );
+  }
+}
+program.name("inboxctl").description("CLI email management with MCP server, rules-as-code, and TUI").version("0.1.0").option("--demo", "Launch the seeded demo mailbox").option("--no-sync", "Launch the TUI without running the initial background sync");
+program.command("setup").description("Run the interactive Google Cloud and OAuth setup wizard").option("--skip-gcloud", "Skip gcloud detection and API enablement").option("--project <id>", "Pre-set the Google Cloud project ID").action(async (options) => {
+  try {
+    await runSetupWizard({
+      skipGcloud: options.skipGcloud,
+      project: options.project
+    });
+  } catch (error) {
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+var auth = program.command("auth").description("Gmail authentication");
+auth.command("login").description("Authenticate with Gmail via OAuth2").action(async () => {
+  const config = loadConfig();
+  try {
+    const result = await startOAuthFlow(config);
+    const reconciliation = reconcileCacheForAuthenticatedAccount(
+      config.dbPath,
+      result.email,
+      { clearLegacyUnscoped: true }
+    );
+    console.log(`Authenticated Gmail account: ${result.email}`);
+    console.log(`Redirect URI used: ${result.redirectUri}`);
+    if (reconciliation.cleared) {
+      console.log("Local cache reset to avoid mixing data from another Gmail account.");
+    }
+  } catch (error) {
+    console.log(error instanceof Error ? error.message : String(error));
+    const status = await loadRuntimeStatus();
+    printCheckpointSummary(status);
+    printGoogleCheckpointInstructions(status);
+    process.exitCode = 1;
+  }
+});
+auth.command("status").description("Show authentication status").action(async () => {
+  const status = await loadRuntimeStatus();
+  printCheckpointSummary(status);
+  if (status.tokensPresent) {
+    try {
+      const email = await resolveAuthenticatedEmail(status.config);
+      if (email) {
+        console.log(`authenticatedEmail: ${email}`);
+      }
+    } catch (error) {
+      console.log(
+        `authenticatedEmail: unavailable (${error instanceof Error ? error.message : String(error)})`
+      );
+    }
+  }
+  if (!status.gmailReady) {
+    printGoogleCheckpointInstructions(status);
+  }
+});
+program.command("sync").description("Sync emails from Gmail").option("--full", "Force full sync (ignore incremental)").action(async (options) => {
+  const status = await loadRuntimeStatus();
+  if (!status.gmailReady) {
+    await requireLiveGmailReadiness("sync");
+    return;
+  }
+  const result = options.full ? await fullSync((synced, total) => {
+    console.log(`synced=${synced}${total ? ` total=${total}` : ""}`);
+  }) : await incrementalSync();
+  console.log(`mode: ${result.mode}`);
+  console.log(`messagesProcessed: ${result.messagesProcessed}`);
+  console.log(`historyId: ${result.historyId}`);
+  console.log(`usedHistoryFallback: ${result.usedHistoryFallback ? "yes" : "no"}`);
+  const syncStatus = await getSyncStatus();
+  console.log(`cacheTotalMessages: ${syncStatus.totalMessages}`);
+});
+program.command("inbox").description("List recent inbox emails").option("-n, --count <number>", "Number of emails to show", "20").action(async (options) => {
+  const emails = await getRecentEmails(Number(options.count));
+  if (emails.length === 0) {
+    console.log("No cached emails yet. Run `inboxctl sync` first.");
+    return;
+  }
+  printSection("Inbox");
+  printEmailTableHeader();
+  for (const email of emails) {
+    console.log(formatEmailRow(email));
+  }
+});
+program.command("search <query>").description("Search emails using Gmail query syntax").option("-n, --count <number>", "Max results", "20").action(async (query, options) => {
+  const status = await loadRuntimeStatus();
+  if (!status.gmailReady) {
+    await requireLiveGmailReadiness("search");
+    return;
+  }
+  const emails = await listMessages(query, Number(options.count));
+  if (emails.length === 0) {
+    console.log("No matching Gmail messages.");
+    return;
+  }
+  printSection(`Search ${ui.dim(query)}`);
+  printEmailTableHeader();
+  for (const email of emails) {
+    console.log(formatEmailRow(email));
+  }
+});
+program.command("email <id>").description("View a single email").action(async (id) => {
+  const status = await loadRuntimeStatus();
+  if (!status.gmailReady) {
+    await requireLiveGmailReadiness("email");
+    return;
+  }
+  const email = await getMessage(id);
+  printSection(email.subject || "Email");
+  printKeyValue("from", email.fromAddress);
+  printKeyValue("to", email.toAddresses.join(", "));
+  printKeyValue("date", new Date(email.date).toISOString());
+  printKeyValue("labels", email.labelIds.join(", ") || "-");
+  console.log("");
+  console.log(email.textPlain || email.body || email.snippet);
+});
+program.command("archive [id]").description("Archive email(s)").option("-q, --query <query>", "Archive all emails matching query").action(async (id, options) => {
+  const status = await loadRuntimeStatus();
+  if (!status.gmailReady) {
+    await requireLiveGmailReadiness("archive");
+    return;
+  }
+  try {
+    const ids = await resolveMessageIds(id, options.query);
+    if (ids.length === 0) {
+      console.log("No matching Gmail messages.");
+      return;
+    }
+    await confirmBatchIfNeeded(options.query, ids, "Archive");
+    const result = await archiveEmails(ids);
+    const runId = await recordManualRun({
+      query: options.query,
+      requestedActions: [{ type: "archive" }],
+      result
+    });
+    printMutationSummary(result, runId);
+  } catch (error) {
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+program.command("label <idOrLabel> [label]").description("Apply label to email(s)").option("-q, --query <query>", "Label all emails matching query").action(async (idOrLabel, label, options) => {
+  const status = await loadRuntimeStatus();
+  if (!status.gmailReady) {
+    await requireLiveGmailReadiness("label");
+    return;
+  }
+  const labelName = options.query ? label || idOrLabel : label;
+  const id = options.query ? void 0 : idOrLabel;
+  if (!labelName) {
+    console.log("Provide a label name.");
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const ids = await resolveMessageIds(id, options.query);
+    if (ids.length === 0) {
+      console.log("No matching Gmail messages.");
+      return;
+    }
+    await confirmBatchIfNeeded(options.query, ids, "Apply label to");
+    const result = await labelEmails(ids, labelName);
+    const runId = await recordManualRun({
+      query: options.query,
+      requestedActions: [{ type: "label", label: labelName }],
+      result
+    });
+    printMutationSummary(result, runId);
+  } catch (error) {
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+program.command("read [id]").description("Mark email(s) as read").option("-q, --query <query>", "Mark all matching emails as read").action(async (id, options) => {
+  const status = await loadRuntimeStatus();
+  if (!status.gmailReady) {
+    await requireLiveGmailReadiness("read");
+    return;
+  }
+  try {
+    const ids = await resolveMessageIds(id, options.query);
+    if (ids.length === 0) {
+      console.log("No matching Gmail messages.");
+      return;
+    }
+    await confirmBatchIfNeeded(options.query, ids, "Mark as read");
+    const result = await markRead(ids);
+    const runId = await recordManualRun({
+      query: options.query,
+      requestedActions: [{ type: "mark_read" }],
+      result
+    });
+    printMutationSummary(result, runId);
+  } catch (error) {
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+program.command("forward <id> <email>").description("Forward email to another address").action(async (id, email) => {
+  const status = await loadRuntimeStatus();
+  if (!status.gmailReady) {
+    await requireLiveGmailReadiness("forward");
+    return;
+  }
+  try {
+    const result = await forwardEmail(id, email);
+    const runId = await recordManualRun({
+      requestedActions: [{ type: "forward", to: email }],
+      result
+    });
+    printMutationSummary(result, runId);
+  } catch (error) {
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+program.command("undo <run-id>").description("Undo a previous action run").action(async (runId) => {
+  const status = await loadRuntimeStatus();
+  if (!status.gmailReady) {
+    await requireLiveGmailReadiness("undo");
+    return;
+  }
+  try {
+    const result = await undoRun(runId);
+    printSection(`Undo ${ui.dim(result.runId)}`);
+    printKeyValue("status", formatStatus(result.status));
+    printKeyValue("undone", ui.green(String(result.undoneCount)));
+    printKeyValue("warnings", result.warningCount > 0 ? ui.yellow(String(result.warningCount)) : ui.dim("0"));
+    printKeyValue("errors", result.errorCount > 0 ? ui.red(String(result.errorCount)) : ui.dim("0"));
+    for (const warning of result.warnings) {
+      console.log(`${ui.yellow("warning")} ${warning}`);
+    }
+  } catch (error) {
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+program.command("history").description("Show recent run history").option("-n, --count <number>", "Number of entries", "20").option("--email <id>", "Filter by email ID").action(async (options) => {
+  const runs = options.email ? await getRunsByEmail(options.email) : await getRecentRuns(Number(options.count));
+  if (runs.length === 0) {
+    console.log("No action history yet.");
+    return;
+  }
+  printHistoryTable(runs);
+});
+var labels = program.command("labels").description("Manage Gmail labels");
+labels.command("list").description("List all Gmail labels").action(async () => {
+  const status = await loadRuntimeStatus();
+  if (!status.gmailReady) {
+    await requireLiveGmailReadiness("labels list");
+    return;
+  }
+  const labels2 = await listLabels();
+  printSection("Labels");
+  console.log(
+    [
+      pad2(ui.dim("TYPE"), 8),
+      pad2(ui.dim("NAME"), 24),
+      pad2(ui.dim("MESSAGES"), 10),
+      pad2(ui.dim("UNREAD"), 8),
+      ui.dim("ID")
+    ].join("  ")
+  );
+  for (const label of labels2) {
+    console.log(
+      [
+        pad2(label.type === "system" ? ui.cyan(label.type) : ui.magenta(label.type), 8),
+        pad2(truncate2(label.name, 24), 24),
+        pad2(String(label.messagesTotal), 10),
+        pad2(String(label.messagesUnread), 8),
+        ui.dim(label.id)
+      ].join("  ")
+    );
+  }
+});
+labels.command("create <name>").description("Create a new Gmail label").action(async (name) => {
+  const status = await loadRuntimeStatus();
+  if (!status.gmailReady) {
+    await requireLiveGmailReadiness("labels create");
+    return;
+  }
+  try {
+    const label = await createLabel(name);
+    printSection("Label Created");
+    printKeyValue("name", label.name);
+    printKeyValue("id", ui.dim(label.id));
+  } catch (error) {
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+var stats = program.command("stats").description("Email analytics");
+stats.command("overview", { isDefault: true }).description("Inbox overview stats").action(async () => {
+  const overview = await getInboxOverview();
+  if (overview.total === 0) {
+    console.log("No cached emails yet. Run `inboxctl sync` first.");
+    return;
+  }
+  printInboxOverview(overview);
+});
+stats.command("senders").description("Top senders by volume").option("--top <number>", "Number of senders", "20").option("--period <period>", "Time period (day|week|month|year|all)", "all").option("--min-unread <percent>", "Minimum unread rate filter").action(async (options) => {
+  try {
+    const top = parseIntegerOption(options.top, "top");
+    const minUnread = parsePercentOption(options.minUnread, "min-unread");
+    const period = options.period;
+    if (!["day", "week", "month", "year", "all"].includes(period)) {
+      throw new Error("period must be one of: day, week, month, year, all.");
+    }
+    const senders = await getTopSenders({
+      limit: top,
+      period,
+      minUnreadRate: minUnread
+    });
+    if (senders.length === 0) {
+      console.log("No cached sender stats matched that filter.");
+      return;
+    }
+    printTopSendersTable(period, senders);
+  } catch (error) {
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+stats.command("newsletters").description("Detected newsletters and mailing lists").option("--min-unread <percent>", "Minimum unread rate filter").action(async (options) => {
+  try {
+    const minUnread = parsePercentOption(options.minUnread, "min-unread");
+    const newsletters = await getNewsletters({
+      minUnreadRate: minUnread
+    });
+    if (newsletters.length === 0) {
+      console.log("No newsletter senders matched that filter.");
+      return;
+    }
+    printNewslettersTable(newsletters);
+  } catch (error) {
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+stats.command("labels").description("Email count per label").action(async () => {
+  const labels2 = await getLabelDistribution();
+  if (labels2.length === 0) {
+    console.log("No cached emails yet. Run `inboxctl sync` first.");
+    return;
+  }
+  printLabelDistributionTable(labels2);
+});
+stats.command("volume").description("Email volume over time").option("--period <period>", "Granularity (day|week|month)", "day").action(async (options) => {
+  try {
+    const period = options.period;
+    if (!["day", "week", "month"].includes(period)) {
+      throw new Error("period must be one of: day, week, month.");
+    }
+    const points = await getVolumeByPeriod(period, getVolumeRange(period));
+    if (points.length === 0) {
+      console.log("No cached emails yet. Run `inboxctl sync` first.");
+      return;
+    }
+    printVolumeTable(period, points);
+  } catch (error) {
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+stats.command("sender <email>").description("Detailed stats for a sender or @domain").action(async (email) => {
+  const detail = await getSenderStats(email);
+  if (!detail) {
+    console.log(`No cached emails found for ${email}.`);
+    return;
+  }
+  printSenderDetail(detail);
+});
+var rules = program.command("rules").description("Rule management (IaC)");
+rules.command("deploy [file]").description("Deploy rules from YAML files").action(async (file) => {
+  const config = loadConfig();
+  try {
+    const result = file ? await deployLoadedRule(await loadRuleFile(file)) : await deployAllRules(config.rulesDir);
+    printRuleDeploySummary(result);
+  } catch (error) {
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+rules.command("status [name]").description("Show deployed rules and their status").action(async (name) => {
+  try {
+    if (name) {
+      const rule = await getRuleStatus(name);
+      if (!rule) {
+        console.log(`Rule not found: ${name}`);
+        process.exitCode = 1;
+        return;
+      }
+      printRuleStatusDetail(rule);
+      return;
+    }
+    const rules2 = await getAllRulesStatus();
+    if (rules2.length === 0) {
+      console.log("No rules have been deployed yet.");
+      return;
+    }
+    printRuleStatusTable(rules2);
+  } catch (error) {
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+rules.command("run [name]").description("Execute a rule against matching emails").option("--apply", "Actually execute (default is dry-run)").option("--max <number>", "Maximum emails to process", "100").option("--all", "Run all enabled rules").action(async (name, options) => {
+  const maxEmails = Number(options.max);
+  if (!Number.isInteger(maxEmails) || maxEmails <= 0) {
+    console.log(`Invalid --max value: ${options.max}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (!options.all && !name) {
+    console.log("Provide a rule name or use --all.");
+    process.exitCode = 1;
+    return;
+  }
+  if (options.apply) {
+    const status = await loadRuntimeStatus();
+    if (!status.gmailReady) {
+      await requireLiveGmailReadiness("rules run --apply");
+      return;
+    }
+  }
+  try {
+    if (options.all) {
+      const result2 = await runAllRules({
+        dryRun: !options.apply,
+        maxEmails
+      });
+      printRunAllRulesResult(result2);
+      return;
+    }
+    const result = await runRule(name, {
+      dryRun: !options.apply,
+      maxEmails
+    });
+    printRuleRunResult(result);
+  } catch (error) {
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+rules.command("undo <run-id>").description("Undo a specific rule run").action(async (runId) => {
+  const status = await loadRuntimeStatus();
+  if (!status.gmailReady) {
+    await requireLiveGmailReadiness("rules undo");
+    return;
+  }
+  try {
+    const result = await undoRun(runId);
+    printSection(`Undo ${ui.dim(result.runId)}`);
+    printKeyValue("status", formatStatus(result.status));
+    printKeyValue("undone", ui.green(String(result.undoneCount)));
+    printKeyValue("warnings", result.warningCount > 0 ? ui.yellow(String(result.warningCount)) : ui.dim("0"));
+    printKeyValue("errors", result.errorCount > 0 ? ui.red(String(result.errorCount)) : ui.dim("0"));
+  } catch (error) {
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+rules.command("enable <name>").description("Enable a deployed rule").action(async (name) => {
+  try {
+    const rule = await enableRule(name);
+    printSection("Rule Enabled");
+    printKeyValue("name", rule.name);
+    printKeyValue("enabled", formatEnabled(rule.enabled));
+  } catch (error) {
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+rules.command("disable <name>").description("Disable a deployed rule").action(async (name) => {
+  try {
+    const rule = await disableRule(name);
+    printSection("Rule Disabled");
+    printKeyValue("name", rule.name);
+    printKeyValue("enabled", formatEnabled(rule.enabled));
+  } catch (error) {
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+rules.command("diff").description("Show drift between YAML files and deployed rules").action(async () => {
+  const config = loadConfig();
+  try {
+    const result = await detectDrift(config.rulesDir);
+    if (result.entries.length === 0) {
+      console.log("No rule files found.");
+      return;
+    }
+    printDriftReport(result);
+  } catch (error) {
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+var filters = program.command("filters").description("Gmail server-side filters (always-on, applied at delivery time)");
+filters.command("list").description("List all Gmail server-side filters").action(async () => {
+  try {
+    const all = await listFilters();
+    if (all.length === 0) {
+      console.log("No Gmail filters found.");
+      return;
+    }
+    printSection("Gmail Filters");
+    console.log(
+      [
+        pad2(ui.dim("ID"), 32),
+        pad2(ui.dim("CRITERIA"), 36),
+        ui.dim("ACTIONS")
+      ].join("  ")
+    );
+    for (const f of all) {
+      const criteria = [];
+      if (f.criteria.from) criteria.push(`from:${f.criteria.from}`);
+      if (f.criteria.to) criteria.push(`to:${f.criteria.to}`);
+      if (f.criteria.subject) criteria.push(`subject:${f.criteria.subject}`);
+      if (f.criteria.query) criteria.push(`query:${f.criteria.query}`);
+      if (f.criteria.hasAttachment) criteria.push("has-attachment");
+      if (f.criteria.size != null) criteria.push(`size:${f.criteria.sizeComparison ?? ""}${f.criteria.size}`);
+      const actions = [];
+      if (f.actions.archive) actions.push("archive");
+      if (f.actions.markRead) actions.push("mark-read");
+      if (f.actions.star) actions.push("star");
+      if (f.actions.addLabelNames.length > 0) actions.push(`label:${f.actions.addLabelNames.join(",")}`);
+      if (f.actions.forward) actions.push(`forward:${f.actions.forward}`);
+      console.log(
+        [
+          pad2(ui.dim(f.id), 32),
+          pad2(truncate2(criteria.join(" "), 36), 36),
+          truncate2(actions.join(", ") || "-", 60)
+        ].join("  ")
+      );
+    }
+  } catch (error) {
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+filters.command("get <id>").description("Get details of a Gmail server-side filter").action(async (id) => {
+  try {
+    const f = await getFilter(id);
+    printSection("Filter");
+    printKeyValue("id", f.id);
+    console.log();
+    console.log(ui.bold("Criteria"));
+    if (f.criteria.from) printKeyValue("  from", f.criteria.from);
+    if (f.criteria.to) printKeyValue("  to", f.criteria.to);
+    if (f.criteria.subject) printKeyValue("  subject", f.criteria.subject);
+    if (f.criteria.query) printKeyValue("  query", f.criteria.query);
+    if (f.criteria.negatedQuery) printKeyValue("  not", f.criteria.negatedQuery);
+    if (f.criteria.hasAttachment) printKeyValue("  has-attachment", "yes");
+    if (f.criteria.excludeChats) printKeyValue("  exclude-chats", "yes");
+    if (f.criteria.size != null) {
+      printKeyValue(
+        "  size",
+        `${f.criteria.sizeComparison ?? ""} ${f.criteria.size} bytes`
+      );
+    }
+    console.log();
+    console.log(ui.bold("Actions"));
+    if (f.actions.archive) printKeyValue("  archive", "yes");
+    if (f.actions.markRead) printKeyValue("  mark-read", "yes");
+    if (f.actions.star) printKeyValue("  star", "yes");
+    if (f.actions.addLabelNames.length > 0) printKeyValue("  add-label", f.actions.addLabelNames.join(", "));
+    if (f.actions.removeLabelNames.length > 0) printKeyValue("  remove-label", f.actions.removeLabelNames.join(", "));
+    if (f.actions.forward) printKeyValue("  forward", f.actions.forward);
+  } catch (error) {
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+filters.command("create").description("Create a Gmail server-side filter").option("--from <address>", "Match emails from this address").option("--to <address>", "Match emails sent to this address").option("--subject <text>", "Match emails with this text in the subject").option("--query <q>", "Match using Gmail search syntax").option("--negated-query <q>", "Exclude emails matching this Gmail query").option("--has-attachment", "Match emails with attachments").option("--exclude-chats", "Exclude chat messages from matches").option("--size <bytes>", "Match emails by size threshold", parseInt).option("--size-comparison <direction>", "larger or smaller (use with --size)").option("--label <name>", "Apply this label to matching emails (created if missing)").option("--archive", "Archive matching emails (skip inbox)").option("--mark-read", "Mark matching emails as read").option("--star", "Star matching emails").option("--forward <email>", "Forward matching emails to this address").action(async (opts) => {
+  try {
+    const f = await createFilter({
+      from: opts.from,
+      to: opts.to,
+      subject: opts.subject,
+      query: opts.query,
+      negatedQuery: opts.negatedQuery,
+      hasAttachment: opts.hasAttachment || void 0,
+      excludeChats: opts.excludeChats || void 0,
+      size: opts.size,
+      sizeComparison: opts.sizeComparison,
+      labelName: opts.label,
+      archive: opts.archive || void 0,
+      markRead: opts.markRead || void 0,
+      star: opts.star || void 0,
+      forward: opts.forward
+    });
+    printSection("Filter Created");
+    printKeyValue("id", f.id);
+    const criteriaStr = [];
+    if (f.criteria.from) criteriaStr.push(`from:${f.criteria.from}`);
+    if (f.criteria.to) criteriaStr.push(`to:${f.criteria.to}`);
+    if (f.criteria.subject) criteriaStr.push(`subject:${f.criteria.subject}`);
+    if (f.criteria.query) criteriaStr.push(f.criteria.query);
+    if (criteriaStr.length > 0) printKeyValue("criteria", criteriaStr.join(", "));
+    const actionsStr = [];
+    if (f.actions.archive) actionsStr.push("archive");
+    if (f.actions.markRead) actionsStr.push("mark-read");
+    if (f.actions.star) actionsStr.push("star");
+    if (f.actions.addLabelNames.length > 0) actionsStr.push(`label: ${f.actions.addLabelNames.join(", ")}`);
+    if (f.actions.forward) actionsStr.push(`forward: ${f.actions.forward}`);
+    if (actionsStr.length > 0) printKeyValue("actions", actionsStr.join(", "));
+    console.log();
+    console.log(ui.dim("Note: filters apply to incoming mail from now on. To process existing mail, use `inboxctl rules`."));
+  } catch (error) {
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+filters.command("delete <id>").description("Delete a Gmail server-side filter").action(async (id) => {
+  try {
+    await deleteFilter(id);
+    printSection("Filter Deleted");
+    printKeyValue("id", id);
+  } catch (error) {
+    console.log(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+});
+program.command("demo").description("Launch the seeded demo mailbox for screenshots, recordings, and safe exploration").action(async () => {
+  await runDemoSession();
+});
+program.command("mcp").description("Start MCP server on stdio").action(async () => {
+  await startMcpServer();
+});
+program.action(async (options) => {
+  if (options.demo) {
+    await runDemoSession();
+    return;
+  }
+  await startTuiApp({
+    noSync: Boolean(options.noSync)
+  });
+});
+program.parse();
+//# sourceMappingURL=cli.js.map