gogcli-mcp 2.18.2 → 2.18.4

package/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
   },
   "metadata": {
     "description": "Google Sheets (and more) for Claude via gogcli — read, write, and manage spreadsheets",
-    "version": "2.18.2"
+    "version": "2.18.4"
   },
   "plugins": [
     {
@@ -15,7 +15,7 @@
       "displayName": "gogcli",
       "source": "./",
       "description": "Google Sheets (and more) for Claude via gogcli — read, write, and manage spreadsheets",
-      "version": "2.18.2",
+      "version": "2.18.4",
       "author": {
         "name": "Chris Hall"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "gogcli-mcp",
   "displayName": "gogcli",
-  "version": "2.18.2",
+  "version": "2.18.4",
   "description": "Google Sheets (and more) for Claude via gogcli — read, write, and manage spreadsheets",
   "author": {
     "name": "Chris Hall",

package/dist/index.js

@@ -31285,6 +31285,198 @@ async function runBinary(args, options = {}) {
   return spawnExecutor(fullArgs, { timeout, interactive: false, spawner, binary: true });
 }
 
+// src/timestamps.ts
+var DEFAULT_DISPLAY_TZ = "America/New_York";
+function isValidTimeZone(tz) {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: tz });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function displayTimeZone() {
+  const configured = readEnvVar("DISPLAY_TZ");
+  if (configured && isValidTimeZone(configured)) return configured;
+  return DEFAULT_DISPLAY_TZ;
+}
+function naiveSourceTimeZone() {
+  const configured = readEnvVar("GOG_TIMEZONE");
+  if (configured && isValidTimeZone(configured)) return configured;
+  return displayTimeZone();
+}
+function offsetAt(instant, tz) {
+  const w = wallPartsIn(instant, tz);
+  const asUTC = Date.UTC(w.year, w.month - 1, w.day, w.hour, w.minute, w.second, instant.getUTCMilliseconds());
+  const minutes = Math.round((asUTC - instant.getTime()) / 6e4);
+  const sign = minutes < 0 ? "-" : "+";
+  const abs = Math.abs(minutes);
+  return `${sign}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`;
+}
+function wallPartsIn(instant, tz) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: tz,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    // h23 pins midnight to hour 00; without it some ICU builds render hour 24.
+    hourCycle: "h23"
+  }).formatToParts(instant);
+  const out = {};
+  for (const p of parts) {
+    if (p.type !== "literal") out[p.type] = Number(p.value);
+  }
+  return out;
+}
+function wallTimeToInstant(y, mo, d, h, mi, s, ms, tz) {
+  let guess = Date.UTC(y, mo - 1, d, h, mi, s, ms);
+  for (let i = 0; i < 2; i += 1) {
+    const seen = wallPartsIn(new Date(guess), tz);
+    const seenUTC = Date.UTC(seen.year, seen.month - 1, seen.day, seen.hour, seen.minute, seen.second, ms);
+    const drift = Date.UTC(y, mo - 1, d, h, mi, s, ms) - seenUTC;
+    if (drift === 0) break;
+    guess += drift;
+  }
+  return new Date(guess);
+}
+function pad(n, width = 2) {
+  return String(n).padStart(width, "0");
+}
+function isoWithOffset(instant, tz, offset) {
+  const w = wallPartsIn(instant, tz);
+  const msPart = instant.getUTCMilliseconds();
+  const frac = msPart ? `.${pad(msPart, 3)}` : "";
+  return `${pad(w.year, 4)}-${pad(w.month)}-${pad(w.day)}T${pad(w.hour)}:${pad(w.minute)}:${pad(w.second)}${frac}${offset}`;
+}
+function formatInstant(instant, tz = displayTimeZone()) {
+  const offset = offsetAt(instant, tz);
+  const display = new Intl.DateTimeFormat("en-US", {
+    timeZone: tz,
+    weekday: "short",
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    timeZoneName: "short"
+  }).format(instant);
+  return { iso: isoWithOffset(instant, tz, offset), display };
+}
+var TIMESTAMP_KEYS = /* @__PURE__ */ new Set([
+  "date",
+  // gog gmail message/thread listings ("2026-07-28 03:36")
+  "dateTime",
+  // Calendar event start/end
+  "internalDate",
+  // Gmail, epoch milliseconds (authoritative)
+  "modifiedTime",
+  // Drive
+  "createdTime",
+  // Drive
+  "createTime",
+  "updateTime",
+  "updated",
+  "originalStartTime",
+  "expirationTime",
+  "lastModified",
+  "sentAt",
+  "viewedAt",
+  "modifiedAt",
+  "fetchedBodyAt",
+  "asOf"
+]);
+var ZONE_NAME_KEYS = /* @__PURE__ */ new Set(["timeZone", "timezone"]);
+var RFC3339_WITH_OFFSET = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2}))?(?:\.(\d{1,9}))?(Z|[+-]\d{2}:?\d{2})$/;
+var NAIVE_DATE_TIME = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2}))?(?:\.(\d{1,9}))?$/;
+var EPOCH_MILLIS = /^\d{13}$/;
+var DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+function isRealCalendarDate(p) {
+  const utc = new Date(Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second));
+  return utc.getUTCFullYear() === p.year && utc.getUTCMonth() === p.month - 1 && utc.getUTCDate() === p.day && utc.getUTCHours() === p.hour && utc.getUTCMinutes() === p.minute && utc.getUTCSeconds() === p.second;
+}
+function parseTimestampValue(key, value, assumeNaiveIn) {
+  if (typeof value !== "string") return null;
+  const raw = value.trim();
+  if (raw === "" || DATE_ONLY.test(raw)) return null;
+  if (key === "internalDate" && EPOCH_MILLIS.test(raw)) {
+    return new Date(Number(raw));
+  }
+  if (RFC3339_WITH_OFFSET.test(raw)) {
+    const parsed = new Date(raw.replace(" ", "T"));
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+  }
+  const naive = NAIVE_DATE_TIME.exec(raw);
+  if (naive) {
+    const [, y, mo, d, h, mi, s, frac] = naive;
+    const ms = frac ? Number(frac.padEnd(3, "0").slice(0, 3)) : 0;
+    const parts = {
+      year: Number(y),
+      month: Number(mo),
+      day: Number(d),
+      hour: Number(h),
+      minute: Number(mi),
+      second: Number(s ?? "0")
+    };
+    if (!isRealCalendarDate(parts)) return null;
+    return wallTimeToInstant(
+      parts.year,
+      parts.month,
+      parts.day,
+      parts.hour,
+      parts.minute,
+      parts.second,
+      ms,
+      assumeNaiveIn
+    );
+  }
+  return null;
+}
+function walk(node, tz, naiveTz) {
+  let changed = false;
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      if (walk(item, tz, naiveTz)) changed = true;
+    }
+    return changed;
+  }
+  if (node === null || typeof node !== "object") return false;
+  const obj = node;
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (value !== null && typeof value === "object") {
+      if (walk(value, tz, naiveTz)) changed = true;
+      continue;
+    }
+    if (ZONE_NAME_KEYS.has(key) || !TIMESTAMP_KEYS.has(key)) continue;
+    const instant = parseTimestampValue(key, value, naiveTz);
+    if (!instant) continue;
+    const { iso, display } = formatInstant(instant, tz);
+    obj[key] = iso;
+    obj[`${key}Display`] = display;
+    changed = true;
+  }
+  return changed;
+}
+function detectIndent(text) {
+  const match = /\n(\s+)\S/.exec(text);
+  return match ? match[1].replace(/\t/g, "  ").length : 0;
+}
+function normalizeTimestamps(text, tz = displayTimeZone(), naiveTz = naiveSourceTimeZone()) {
+  const trimmed = text.trim();
+  if (trimmed === "" || !/^[[{]/.test(trimmed)) return text;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return text;
+  }
+  if (!walk(parsed, tz, naiveTz)) return text;
+  return JSON.stringify(parsed, null, detectIndent(text));
+}
+
 // src/tools/utils.ts
 var PAYLOAD_INLINE_MAX = 4096;
 function payloadArg(inlineFlag, fileFlag, value, ext) {
@@ -31385,7 +31577,8 @@ ${accounts || "(none)"}${hint}`);
 }
 async function runOrDiagnose(args, options) {
   try {
-    return rawTextResult(await run(args, options));
+    const raw = await run(args, options);
+    return rawTextResult(options.lossless ? raw : normalizeTimestamps(raw));
   } catch (err) {
     return diagnose(err);
   }
@@ -32457,14 +32650,16 @@ function registerDriveTools(server) {
       const { name, mimeType } = fileMeta(await run(["drive", "get", fileId], { account }));
       const params = JSON.stringify({ fileId, alt: "media" });
       const blob = await runBinary(["api", "call", "drive", "v3", "files.get", `--params=${params}`], { account });
+      const type = mimeType ?? "application/octet-stream";
+      const unrenderableHint = type.startsWith("image/") ? "" : ` If your client does not render a ${type} resource, gog_drive_extract_text returns the same file as text (PDFs included, via OCR).`;
       return {
         content: [
-          { type: "text", text: `${name ?? fileId} (${mimeType ?? "application/octet-stream"}) \u2014 ${Buffer.from(blob, "base64").length} bytes, base64 resource below.` },
+          { type: "text", text: `${name ?? fileId} (${type}) \u2014 ${Buffer.from(blob, "base64").length} bytes, base64 resource below.${unrenderableHint}` },
           {
             type: "resource",
             resource: {
               uri: `gogdrive://${fileId}/${encodeURIComponent(name ?? "file")}`,
-              mimeType: mimeType ?? "application/octet-stream",
+              mimeType: type,
               blob
             }
           }
@@ -32857,7 +33052,7 @@ function registerTasksTools(server) {
 }
 
 // src/server.ts
-var VERSION = true ? "2.18.2" : "0.0.0";
+var VERSION = true ? "2.18.4" : "0.0.0";
 var BASE_TOOL_REGISTRARS = [
   registerApiTools,
   registerAuthTools,

package/dist/lib.js

@@ -23183,6 +23183,198 @@ async function runBinary(args, options = {}) {
   return spawnExecutor(fullArgs, { timeout, interactive: false, spawner, binary: true });
 }
 
+// src/timestamps.ts
+var DEFAULT_DISPLAY_TZ = "America/New_York";
+function isValidTimeZone(tz) {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: tz });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function displayTimeZone() {
+  const configured = readEnvVar("DISPLAY_TZ");
+  if (configured && isValidTimeZone(configured)) return configured;
+  return DEFAULT_DISPLAY_TZ;
+}
+function naiveSourceTimeZone() {
+  const configured = readEnvVar("GOG_TIMEZONE");
+  if (configured && isValidTimeZone(configured)) return configured;
+  return displayTimeZone();
+}
+function offsetAt(instant, tz) {
+  const w = wallPartsIn(instant, tz);
+  const asUTC = Date.UTC(w.year, w.month - 1, w.day, w.hour, w.minute, w.second, instant.getUTCMilliseconds());
+  const minutes = Math.round((asUTC - instant.getTime()) / 6e4);
+  const sign = minutes < 0 ? "-" : "+";
+  const abs = Math.abs(minutes);
+  return `${sign}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`;
+}
+function wallPartsIn(instant, tz) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: tz,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    // h23 pins midnight to hour 00; without it some ICU builds render hour 24.
+    hourCycle: "h23"
+  }).formatToParts(instant);
+  const out = {};
+  for (const p of parts) {
+    if (p.type !== "literal") out[p.type] = Number(p.value);
+  }
+  return out;
+}
+function wallTimeToInstant(y, mo, d, h, mi, s, ms, tz) {
+  let guess = Date.UTC(y, mo - 1, d, h, mi, s, ms);
+  for (let i = 0; i < 2; i += 1) {
+    const seen = wallPartsIn(new Date(guess), tz);
+    const seenUTC = Date.UTC(seen.year, seen.month - 1, seen.day, seen.hour, seen.minute, seen.second, ms);
+    const drift = Date.UTC(y, mo - 1, d, h, mi, s, ms) - seenUTC;
+    if (drift === 0) break;
+    guess += drift;
+  }
+  return new Date(guess);
+}
+function pad(n, width = 2) {
+  return String(n).padStart(width, "0");
+}
+function isoWithOffset(instant, tz, offset) {
+  const w = wallPartsIn(instant, tz);
+  const msPart = instant.getUTCMilliseconds();
+  const frac = msPart ? `.${pad(msPart, 3)}` : "";
+  return `${pad(w.year, 4)}-${pad(w.month)}-${pad(w.day)}T${pad(w.hour)}:${pad(w.minute)}:${pad(w.second)}${frac}${offset}`;
+}
+function formatInstant(instant, tz = displayTimeZone()) {
+  const offset = offsetAt(instant, tz);
+  const display = new Intl.DateTimeFormat("en-US", {
+    timeZone: tz,
+    weekday: "short",
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    timeZoneName: "short"
+  }).format(instant);
+  return { iso: isoWithOffset(instant, tz, offset), display };
+}
+var TIMESTAMP_KEYS = /* @__PURE__ */ new Set([
+  "date",
+  // gog gmail message/thread listings ("2026-07-28 03:36")
+  "dateTime",
+  // Calendar event start/end
+  "internalDate",
+  // Gmail, epoch milliseconds (authoritative)
+  "modifiedTime",
+  // Drive
+  "createdTime",
+  // Drive
+  "createTime",
+  "updateTime",
+  "updated",
+  "originalStartTime",
+  "expirationTime",
+  "lastModified",
+  "sentAt",
+  "viewedAt",
+  "modifiedAt",
+  "fetchedBodyAt",
+  "asOf"
+]);
+var ZONE_NAME_KEYS = /* @__PURE__ */ new Set(["timeZone", "timezone"]);
+var RFC3339_WITH_OFFSET = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2}))?(?:\.(\d{1,9}))?(Z|[+-]\d{2}:?\d{2})$/;
+var NAIVE_DATE_TIME = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2}))?(?:\.(\d{1,9}))?$/;
+var EPOCH_MILLIS = /^\d{13}$/;
+var DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+function isRealCalendarDate(p) {
+  const utc = new Date(Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second));
+  return utc.getUTCFullYear() === p.year && utc.getUTCMonth() === p.month - 1 && utc.getUTCDate() === p.day && utc.getUTCHours() === p.hour && utc.getUTCMinutes() === p.minute && utc.getUTCSeconds() === p.second;
+}
+function parseTimestampValue(key, value, assumeNaiveIn) {
+  if (typeof value !== "string") return null;
+  const raw = value.trim();
+  if (raw === "" || DATE_ONLY.test(raw)) return null;
+  if (key === "internalDate" && EPOCH_MILLIS.test(raw)) {
+    return new Date(Number(raw));
+  }
+  if (RFC3339_WITH_OFFSET.test(raw)) {
+    const parsed = new Date(raw.replace(" ", "T"));
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+  }
+  const naive = NAIVE_DATE_TIME.exec(raw);
+  if (naive) {
+    const [, y, mo, d, h, mi, s, frac] = naive;
+    const ms = frac ? Number(frac.padEnd(3, "0").slice(0, 3)) : 0;
+    const parts = {
+      year: Number(y),
+      month: Number(mo),
+      day: Number(d),
+      hour: Number(h),
+      minute: Number(mi),
+      second: Number(s ?? "0")
+    };
+    if (!isRealCalendarDate(parts)) return null;
+    return wallTimeToInstant(
+      parts.year,
+      parts.month,
+      parts.day,
+      parts.hour,
+      parts.minute,
+      parts.second,
+      ms,
+      assumeNaiveIn
+    );
+  }
+  return null;
+}
+function walk(node, tz, naiveTz) {
+  let changed = false;
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      if (walk(item, tz, naiveTz)) changed = true;
+    }
+    return changed;
+  }
+  if (node === null || typeof node !== "object") return false;
+  const obj = node;
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (value !== null && typeof value === "object") {
+      if (walk(value, tz, naiveTz)) changed = true;
+      continue;
+    }
+    if (ZONE_NAME_KEYS.has(key) || !TIMESTAMP_KEYS.has(key)) continue;
+    const instant = parseTimestampValue(key, value, naiveTz);
+    if (!instant) continue;
+    const { iso, display } = formatInstant(instant, tz);
+    obj[key] = iso;
+    obj[`${key}Display`] = display;
+    changed = true;
+  }
+  return changed;
+}
+function detectIndent(text) {
+  const match = /\n(\s+)\S/.exec(text);
+  return match ? match[1].replace(/\t/g, "  ").length : 0;
+}
+function normalizeTimestamps(text, tz = displayTimeZone(), naiveTz = naiveSourceTimeZone()) {
+  const trimmed = text.trim();
+  if (trimmed === "" || !/^[[{]/.test(trimmed)) return text;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return text;
+  }
+  if (!walk(parsed, tz, naiveTz)) return text;
+  return JSON.stringify(parsed, null, detectIndent(text));
+}
+
 // src/tools/utils.ts
 var PAYLOAD_INLINE_MAX = 4096;
 function payloadArg(inlineFlag, fileFlag, value, ext) {
@@ -23288,7 +23480,8 @@ ${accounts || "(none)"}${hint}`);
 }
 async function runOrDiagnose(args, options) {
   try {
-    return rawTextResult(await run(args, options));
+    const raw = await run(args, options);
+    return rawTextResult(options.lossless ? raw : normalizeTimestamps(raw));
   } catch (err) {
     return diagnose(err);
   }
@@ -24363,14 +24556,16 @@ function registerDriveTools(server) {
       const { name, mimeType } = fileMeta(await run(["drive", "get", fileId], { account }));
       const params = JSON.stringify({ fileId, alt: "media" });
       const blob = await runBinary(["api", "call", "drive", "v3", "files.get", `--params=${params}`], { account });
+      const type = mimeType ?? "application/octet-stream";
+      const unrenderableHint = type.startsWith("image/") ? "" : ` If your client does not render a ${type} resource, gog_drive_extract_text returns the same file as text (PDFs included, via OCR).`;
       return {
         content: [
-          { type: "text", text: `${name ?? fileId} (${mimeType ?? "application/octet-stream"}) \u2014 ${Buffer.from(blob, "base64").length} bytes, base64 resource below.` },
+          { type: "text", text: `${name ?? fileId} (${type}) \u2014 ${Buffer.from(blob, "base64").length} bytes, base64 resource below.${unrenderableHint}` },
           {
             type: "resource",
             resource: {
               uri: `gogdrive://${fileId}/${encodeURIComponent(name ?? "file")}`,
-              mimeType: mimeType ?? "application/octet-stream",
+              mimeType: type,
               blob
             }
           }
@@ -24763,7 +24958,7 @@ function registerTasksTools(server) {
 }
 
 // src/server.ts
-var VERSION = true ? "2.18.2" : "0.0.0";
+var VERSION = true ? "2.18.4" : "0.0.0";
 var BASE_TOOL_REGISTRARS = [
   registerApiTools,
   registerAuthTools,

package/manifest.json

@@ -3,7 +3,7 @@
   "manifest_version": "0.3",
   "name": "gogcli-mcp",
   "display_name": "gogcli",
-  "version": "2.18.2",
+  "version": "2.18.4",
   "description": "Google Sheets (and more) for Claude via gogcli — read, write, and manage spreadsheets",
   "author": {
     "name": "Chris Hall",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gogcli-mcp",
-  "version": "2.18.2",
+  "version": "2.18.4",
   "mcpName": "io.github.chrischall/gogcli-mcp",
   "description": "MCP server wrapping gogcli for Google service access",
   "author": "Claude Code (AI) <https://www.anthropic.com/claude>",

package/server.json

@@ -7,12 +7,12 @@
     "source": "github",
     "subfolder": "packages/gogcli-mcp"
   },
-  "version": "2.18.2",
+  "version": "2.18.4",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "gogcli-mcp",
-      "version": "2.18.2",
+      "version": "2.18.4",
       "transport": {
         "type": "stdio"
       },

package/src/timestamps.ts

@@ -0,0 +1,312 @@
+// Canonical timestamp handling for every gog response.
+//
+// gog renders message/thread dates in its configured timezone (GOG_TIMEZONE)
+// and emits several shapes: naive wall-clock ("2026-07-28 03:36"), naive ISO,
+// RFC3339 with a real offset (straight from a Google API), and epoch
+// milliseconds (Gmail's internalDate). Unlabeled values are the dangerous
+// ones: a reader assumes local time and is wrong by the UTC offset, which can
+// put an event on the wrong calendar DAY — the failure that actually matters
+// when reasoning about response windows and day boundaries.
+//
+// Every value that survives detection is rewritten to ISO-8601 WITH an
+// explicit offset and paired with a `<key>Display` sibling rendered in the
+// operator's zone, weekday included, because a wrong weekday is what makes a
+// date-boundary error visible at a glance.
+
+import { readEnvVar } from '@chrischall/mcp-utils';
+
+// Fallback display zone for this deployment. IANA name, never a fixed offset —
+// a hardcoded -04:00 would be an hour wrong from November through March.
+export const DEFAULT_DISPLAY_TZ = 'America/New_York';
+
+function isValidTimeZone(tz: string): boolean {
+  try {
+    new Intl.DateTimeFormat('en-US', { timeZone: tz });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// The zone all *Display fields render in, and the zone a NAIVE source value is
+// assumed to be wall-clock in. Keep GOG_TIMEZONE on the gog side in sync with
+// this: gog formats naive values in its own zone, and we re-attach the offset
+// using ours. An invalid DISPLAY_TZ falls back rather than throwing, so a typo
+// degrades the label instead of breaking every tool.
+export function displayTimeZone(): string {
+  const configured = readEnvVar('DISPLAY_TZ');
+  if (configured && isValidTimeZone(configured)) return configured;
+  return DEFAULT_DISPLAY_TZ;
+}
+
+// The zone a NAIVE source value is wall-clock in — which is whatever zone gog
+// formatted it in, i.e. GOG_TIMEZONE. Reading it directly rather than assuming
+// it equals DISPLAY_TZ removes an invisible "keep these two in sync"
+// requirement: if they ever diverged, every naive value would silently gain the
+// wrong offset and nothing would surface it. Falls back to the display zone,
+// which is the correct guess when gog is running with the same configuration.
+export function naiveSourceTimeZone(): string {
+  const configured = readEnvVar('GOG_TIMEZONE');
+  if (configured && isValidTimeZone(configured)) return configured;
+  return displayTimeZone();
+}
+
+// Offset of `tz` at a given instant, as "+HH:MM"/"-HH:MM". Uses the IANA
+// database via Intl, so DST is handled per-instant rather than per-zone.
+function offsetAt(instant: Date, tz: string): string {
+  // Derived arithmetically rather than parsed out of Intl's "GMT-04:00" label:
+  // the gap between the zone's wall clock and the instant IS the offset, and
+  // zone offsets are always whole minutes.
+  const w = wallPartsIn(instant, tz);
+  const asUTC = Date.UTC(w.year, w.month - 1, w.day, w.hour, w.minute, w.second, instant.getUTCMilliseconds());
+  const minutes = Math.round((asUTC - instant.getTime()) / 60_000);
+  const sign = minutes < 0 ? '-' : '+';
+  const abs = Math.abs(minutes);
+  return `${sign}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`;
+}
+
+// Wall-clock fields of `instant` as seen in `tz`, via Intl so the IANA rules
+// (including DST) apply.
+function wallPartsIn(instant: Date, tz: string): Record<string, number> {
+  const parts = new Intl.DateTimeFormat('en-US', {
+    timeZone: tz,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+    // h23 pins midnight to hour 00; without it some ICU builds render hour 24.
+    hourCycle: 'h23',
+  }).formatToParts(instant);
+  const out: Record<string, number> = {};
+  for (const p of parts) {
+    if (p.type !== 'literal') out[p.type] = Number(p.value);
+  }
+  return out;
+}
+
+// Interpret naive wall-clock fields as an instant in `tz`. There is no direct
+// inverse of the zone rules, so guess UTC, measure how far the guess lands from
+// the requested wall time in that zone, and correct. Two passes settle the case
+// where the correction itself crosses a DST boundary.
+function wallTimeToInstant(
+  y: number, mo: number, d: number, h: number, mi: number, s: number, ms: number, tz: string,
+): Date {
+  let guess = Date.UTC(y, mo - 1, d, h, mi, s, ms);
+  for (let i = 0; i < 2; i += 1) {
+    const seen = wallPartsIn(new Date(guess), tz);
+    const seenUTC = Date.UTC(seen.year, seen.month - 1, seen.day, seen.hour, seen.minute, seen.second, ms);
+    const drift = Date.UTC(y, mo - 1, d, h, mi, s, ms) - seenUTC;
+    if (drift === 0) break;
+    guess += drift;
+  }
+  return new Date(guess);
+}
+
+export interface CanonicalTimestamp {
+  /** ISO-8601 with an explicit offset, e.g. 2026-07-27T23:31:09-04:00. */
+  iso: string;
+  /** Human rendering in the display zone, weekday first. */
+  display: string;
+}
+
+function pad(n: number, width = 2): string {
+  return String(n).padStart(width, '0');
+}
+
+// Render `instant` as ISO-8601 carrying `offset`'s wall time and label.
+function isoWithOffset(instant: Date, tz: string, offset: string): string {
+  const w = wallPartsIn(instant, tz);
+  const msPart = instant.getUTCMilliseconds();
+  const frac = msPart ? `.${pad(msPart, 3)}` : '';
+  return `${pad(w.year, 4)}-${pad(w.month)}-${pad(w.day)}T${pad(w.hour)}:${pad(w.minute)}:${pad(w.second)}${frac}${offset}`;
+}
+
+// The one place an instant becomes user-visible text. Every emitted timestamp
+// goes through here, so no call site can reintroduce a naive value.
+export function formatInstant(instant: Date, tz = displayTimeZone()): CanonicalTimestamp {
+  const offset = offsetAt(instant, tz);
+  const display = new Intl.DateTimeFormat('en-US', {
+    timeZone: tz,
+    weekday: 'short',
+    month: 'short',
+    day: 'numeric',
+    year: 'numeric',
+    hour: 'numeric',
+    minute: '2-digit',
+    timeZoneName: 'short',
+  }).format(instant);
+  return { iso: isoWithOffset(instant, tz, offset), display };
+}
+
+// Keys whose STRING values are timestamps in gog/Google payloads. Deliberately
+// an allowlist: near-miss names abound (updatedCells, updatedRange, updatedRows,
+// formattedValue, verificationStatus) and a name-pattern match would rewrite
+// spreadsheet cell data. A value must ALSO match a timestamp shape below, so
+// both the key and the value have to agree before anything is touched.
+const TIMESTAMP_KEYS = new Set([
+  'date',              // gog gmail message/thread listings ("2026-07-28 03:36")
+  'dateTime',          // Calendar event start/end
+  'internalDate',      // Gmail, epoch milliseconds (authoritative)
+  'modifiedTime',      // Drive
+  'createdTime',       // Drive
+  'createTime',
+  'updateTime',
+  'updated',
+  'originalStartTime',
+  'expirationTime',
+  'lastModified',
+  'sentAt',
+  'viewedAt',
+  'modifiedAt',
+  'fetchedBodyAt',
+  'asOf',
+]);
+
+// Keys that hold a zone NAME rather than an instant. They cannot match a
+// timestamp shape anyway, but naming them documents the hazard.
+const ZONE_NAME_KEYS = new Set(['timeZone', 'timezone']);
+
+const RFC3339_WITH_OFFSET = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2}))?(?:\.(\d{1,9}))?(Z|[+-]\d{2}:?\d{2})$/;
+const NAIVE_DATE_TIME = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2}))?(?:\.(\d{1,9}))?$/;
+// Exactly 13 digits: milliseconds. A 10-digit run is epoch SECONDS, and
+// reading one as milliseconds dates it to 1970.
+const EPOCH_MILLIS = /^\d{13}$/;
+
+// A bare YYYY-MM-DD is a DATE, not an instant — Calendar uses it for all-day
+// events. Converting one would invent a time that the source never asserted.
+const DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+
+// True when the components describe a real calendar instant. Guards against
+// Date.UTC's silent rollover of out-of-range values.
+function isRealCalendarDate(p: {
+  year: number; month: number; day: number; hour: number; minute: number; second: number;
+}): boolean {
+  const utc = new Date(Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second));
+  return utc.getUTCFullYear() === p.year
+    && utc.getUTCMonth() === p.month - 1
+    && utc.getUTCDate() === p.day
+    && utc.getUTCHours() === p.hour
+    && utc.getUTCMinutes() === p.minute
+    && utc.getUTCSeconds() === p.second;
+}
+
+// Resolve a raw field value to an instant, or null when it is not a timestamp.
+// `assumeNaiveIn` is the zone a naive (offset-less) value is wall-clock in.
+export function parseTimestampValue(
+  key: string,
+  value: unknown,
+  assumeNaiveIn: string,
+): Date | null {
+  if (typeof value !== 'string') return null;
+  const raw = value.trim();
+  if (raw === '' || DATE_ONLY.test(raw)) return null;
+
+  // EPOCH_MILLIS is a bounded digit run, so Number() is always finite here.
+  if (key === 'internalDate' && EPOCH_MILLIS.test(raw)) {
+    return new Date(Number(raw));
+  }
+
+  if (RFC3339_WITH_OFFSET.test(raw)) {
+    // The source already knows its offset; trust it verbatim.
+    const parsed = new Date(raw.replace(' ', 'T'));
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+  }
+
+  const naive = NAIVE_DATE_TIME.exec(raw);
+  if (naive) {
+    const [, y, mo, d, h, mi, s, frac] = naive;
+    const ms = frac ? Number(frac.padEnd(3, '0').slice(0, 3)) : 0;
+    const parts = {
+      year: Number(y), month: Number(mo), day: Number(d),
+      hour: Number(h), minute: Number(mi), second: Number(s ?? '0'),
+    };
+    // Date.UTC silently rolls impossible components over — month 99 becomes
+    // 2034, Feb 30 becomes Mar 2 — so a typo would surface as a confident wrong
+    // date rather than a rejection. The RFC3339 branch above already returns
+    // null for the same input; match it.
+    //
+    // Checked in UTC space, deliberately: validating against the ZONE's wall
+    // clock would also reject a non-existent spring-forward time like
+    // 2026-03-08 02:30 ET, and shifting such a value forward (as zone libraries
+    // do) is better than dropping a timestamp we can place to within an hour.
+    if (!isRealCalendarDate(parts)) return null;
+    return wallTimeToInstant(
+      parts.year, parts.month, parts.day, parts.hour, parts.minute, parts.second, ms, assumeNaiveIn,
+    );
+  }
+  return null;
+}
+
+// True when a string carries no zone information — the shape this whole module
+// exists to eliminate. Used by the contract test.
+export function isNaiveTimestamp(value: unknown): boolean {
+  return typeof value === 'string' && NAIVE_DATE_TIME.test(value.trim());
+}
+
+// Walk a parsed gog payload, rewriting every allowlisted timestamp to canonical
+// form and attaching its display sibling. Mutates and returns `node`.
+function walk(node: unknown, tz: string, naiveTz: string): boolean {
+  let changed = false;
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      if (walk(item, tz, naiveTz)) changed = true;
+    }
+    return changed;
+  }
+  if (node === null || typeof node !== 'object') return false;
+
+  const obj = node as Record<string, unknown>;
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (value !== null && typeof value === 'object') {
+      if (walk(value, tz, naiveTz)) changed = true;
+      continue;
+    }
+    if (ZONE_NAME_KEYS.has(key) || !TIMESTAMP_KEYS.has(key)) continue;
+    const instant = parseTimestampValue(key, value, naiveTz);
+    if (!instant) continue;
+    const { iso, display } = formatInstant(instant, tz);
+    obj[key] = iso;
+    obj[`${key}Display`] = display;
+    changed = true;
+  }
+  return changed;
+}
+
+// gog's --pretty emits indented JSON. Re-serializing compactly would silently
+// undo a formatting choice the caller explicitly asked for, so mirror whatever
+// indentation the original used.
+function detectIndent(text: string): number {
+  const match = /\n(\s+)\S/.exec(text);
+  return match ? match[1].replace(/\t/g, '  ').length : 0;
+}
+
+// Normalize every timestamp in a gog JSON response. Non-JSON output (plain-text
+// errors, `--plain` results) passes through untouched, as does JSON that is not
+// an object/array, so this can sit on the single response seam safely.
+export function normalizeTimestamps(
+  text: string,
+  tz = displayTimeZone(),
+  naiveTz = naiveSourceTimeZone(),
+): string {
+  const trimmed = text.trim();
+  if (trimmed === '' || !/^[[{]/.test(trimmed)) return text;
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return text;
+  }
+  // The `[`/`{` guard above means anything that parses here is an object or an
+  // array, so `walk` always has something to descend into.
+  //
+  // When nothing was rewritten, return the ORIGINAL text byte-for-byte rather
+  // than a re-serialization. Round-tripping through JSON.parse/stringify is not
+  // lossless — it drops the caller's --pretty formatting and reorders nothing
+  // but reformats everything — and there is no reason to pay that on a response
+  // that carries no timestamps at all.
+  if (!walk(parsed, tz, naiveTz)) return text;
+  return JSON.stringify(parsed, null, detectIndent(text));
+}

package/src/tools/drive.ts

@@ -221,14 +221,24 @@ export function registerDriveTools(server: McpServer): void {
       const { name, mimeType } = fileMeta(await run(['drive', 'get', fileId], { account }));
       const params = JSON.stringify({ fileId, alt: 'media' });
       const blob = await runBinary(['api', 'call', 'drive', 'v3', 'files.get', `--params=${params}`], { account });
+      const type = mimeType ?? 'application/octet-stream';
+      // Several hosts (claude.ai among them) render embedded IMAGE resources
+      // and reject every other type outright — "Resources of type
+      // 'application/pdf' are not currently supported". The fetch succeeded and
+      // the bytes are right here, but the caller sees only the text block, so
+      // that text has to carry the way out rather than end on "resource below".
+      const unrenderableHint = type.startsWith('image/')
+        ? ''
+        : ` If your client does not render a ${type} resource, gog_drive_extract_text`
+          + ' returns the same file as text (PDFs included, via OCR).';
       return {
         content: [
-          { type: 'text', text: `${name ?? fileId} (${mimeType ?? 'application/octet-stream'}) — ${Buffer.from(blob, 'base64').length} bytes, base64 resource below.` },
+          { type: 'text', text: `${name ?? fileId} (${type}) — ${Buffer.from(blob, 'base64').length} bytes, base64 resource below.${unrenderableHint}` },
           {
             type: 'resource',
             resource: {
               uri: `gogdrive://${fileId}/${encodeURIComponent(name ?? 'file')}`,
-              mimeType: mimeType ?? 'application/octet-stream',
+              mimeType: type,
               blob,
             },
           },

package/src/tools/utils.ts

@@ -4,6 +4,7 @@ import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 import { errorResult, rawTextResult } from '@chrischall/mcp-utils';
 import { run } from '../runner.js';
 import type { GogArg } from '../runner.js';
+import { normalizeTimestamps } from '../timestamps.js';
 
 // Byte size at or below which a payload stays on the plain inline flag.
 //
@@ -228,10 +229,21 @@ export async function diagnose(err: unknown): Promise<CallToolResult> {
 
 export async function runOrDiagnose(
   args: GogArg[],
-  options: { account?: string },
+  options: { account?: string; lossless?: boolean },
 ): Promise<CallToolResult> {
   try {
-    return rawTextResult(await run(args, options));
+    // The single seam every tool's output passes through. Normalizing here —
+    // rather than at each call site — is what makes it impossible for a tool to
+    // emit a naive, zone-less timestamp.
+    //
+    // `lossless` opts a tool out. The `*_raw` dumps promise a verbatim copy of
+    // the upstream API response: normalizing them would rewrite the API's own
+    // epoch-millis `internalDate` into an ISO string and flatten the caller's
+    // `--pretty` formatting, so the one tool you reach for when you need ground
+    // truth would stop telling it. Losslessness wins over presentation there —
+    // the friendlier views of the same data are already normalized.
+    const raw = await run(args, options);
+    return rawTextResult(options.lossless ? raw : normalizeTimestamps(raw));
   } catch (err) {
     return diagnose(err);
   }

package/src/worker.ts

@@ -38,7 +38,7 @@ import { gogAuth, type GogProps } from './connector-auth.js';
 // connector with all ~360 tools at once. Add whichever paths you want as separate
 // connectors in claude.ai (each authorizes with the same connector key).
 
-const VERSION = '2.18.2'; // x-release-please-version
+const VERSION = '2.18.4'; // x-release-please-version
 
 // Build an McpAgent subclass whose init() registers `registrars` onto its server,
 // each handler wrapped in the ALS scope carrying the per-session Fly executor.

package/tests/timestamps.test.ts

@@ -0,0 +1,318 @@
+import { describe, expect, it, afterEach, vi } from 'vitest';
+import {
+  DEFAULT_DISPLAY_TZ,
+  displayTimeZone,
+  formatInstant,
+  isNaiveTimestamp,
+  naiveSourceTimeZone,
+  normalizeTimestamps,
+  parseTimestampValue,
+} from '../src/timestamps.js';
+
+const ET = 'America/New_York';
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+});
+
+describe('displayTimeZone', () => {
+  it('defaults to this deployment’s zone', () => {
+    expect(displayTimeZone()).toBe(DEFAULT_DISPLAY_TZ);
+  });
+
+  it('honours DISPLAY_TZ', () => {
+    vi.stubEnv('DISPLAY_TZ', 'America/Los_Angeles');
+    expect(displayTimeZone()).toBe('America/Los_Angeles');
+  });
+
+  it('falls back when DISPLAY_TZ is not a real IANA zone', () => {
+    vi.stubEnv('DISPLAY_TZ', 'Mars/Olympus_Mons');
+    expect(displayTimeZone()).toBe(DEFAULT_DISPLAY_TZ);
+  });
+});
+
+describe('formatInstant', () => {
+  // DST correctness comes from the IANA database, not a fixed offset: the same
+  // zone is -05:00 in January and -04:00 in July.
+  it('renders -05:00 in January and -04:00 in July', () => {
+    const jan = formatInstant(new Date('2026-01-15T17:00:00Z'), ET);
+    const jul = formatInstant(new Date('2026-07-15T17:00:00Z'), ET);
+    expect(jan.iso).toBe('2026-01-15T12:00:00-05:00');
+    expect(jul.iso).toBe('2026-07-15T13:00:00-04:00');
+  });
+
+  it('renders a positive offset east of UTC and +00:00 at UTC', () => {
+    expect(formatInstant(new Date('2026-07-15T17:00:00Z'), 'Asia/Tokyo').iso)
+      .toBe('2026-07-16T02:00:00+09:00');
+    expect(formatInstant(new Date('2026-07-15T17:00:00Z'), 'UTC').iso)
+      .toBe('2026-07-15T17:00:00+00:00');
+  });
+
+  it('pins midnight to hour 00 rather than 24', () => {
+    expect(formatInstant(new Date('2026-07-15T04:00:00Z'), ET).iso)
+      .toBe('2026-07-15T00:00:00-04:00');
+  });
+
+  it('handles a zone at a half-hour offset', () => {
+    expect(formatInstant(new Date('2026-07-15T00:00:00Z'), 'Asia/Kolkata').iso)
+      .toBe('2026-07-15T05:30:00+05:30');
+  });
+
+  it('includes the weekday, which is what makes a date-boundary error visible', () => {
+    const { display } = formatInstant(new Date('2026-07-28T03:36:00Z'), ET);
+    expect(display).toContain('Mon');
+    expect(display).toContain('Jul 27');
+    expect(display).toContain('11:36 PM');
+  });
+});
+
+describe('parseTimestampValue', () => {
+  it('treats Gmail internalDate as authoritative epoch milliseconds', () => {
+    const instant = parseTimestampValue('internalDate', '1785296160000', ET);
+    expect(instant?.toISOString()).toBe(new Date(1785296160000).toISOString());
+  });
+
+  it('interprets a naive wall-clock value in the configured zone', () => {
+    const instant = parseTimestampValue('date', '2026-07-27 23:36', ET);
+    expect(instant?.toISOString()).toBe('2026-07-28T03:36:00.000Z');
+  });
+
+  it('trusts an offset the source already carries', () => {
+    const instant = parseTimestampValue('sentAt', '2026-07-27T23:31:09-04:00', ET);
+    expect(instant?.toISOString()).toBe('2026-07-28T03:31:09.000Z');
+  });
+
+  // A bare date is a DATE (Calendar all-day events use it); converting one
+  // would invent a time the source never asserted.
+  it('leaves a date-only value alone', () => {
+    expect(parseTimestampValue('date', '2026-07-28', ET)).toBeNull();
+  });
+
+  it('ignores non-timestamp strings', () => {
+    expect(parseTimestampValue('date', 'not a date', ET)).toBeNull();
+  });
+
+  it('ignores a non-string value under a timestamp key', () => {
+    expect(parseTimestampValue('updated', 1785296160000, ET)).toBeNull();
+    expect(parseTimestampValue('updated', null, ET)).toBeNull();
+  });
+
+  // Shape-matching but not a real date: month 99 satisfies the regex's \d{2}
+  // yet Date rejects it. Must not produce an Invalid Date in the payload.
+  it('rejects a well-shaped but impossible date', () => {
+    expect(parseTimestampValue('sentAt', '2026-99-01T00:00:00Z', ET)).toBeNull();
+  });
+});
+
+describe('normalizeTimestamps', () => {
+  // The reported failure: a 11:36 PM Eastern send read as 03:36 the NEXT day.
+  it('reports a late-evening send on the correct calendar day', () => {
+    const out = JSON.parse(normalizeTimestamps(
+      JSON.stringify({ messages: [{ id: 'm1', date: '2026-07-28 03:36' }] }),
+      'UTC',
+    ));
+    // Source rendered in UTC; re-read in ET it must land on Jul 27.
+    const et = JSON.parse(normalizeTimestamps(
+      JSON.stringify({ messages: [{ id: 'm1', internalDate: String(Date.parse('2026-07-28T03:36:00Z')) }] }),
+      ET,
+    ));
+    expect(out.messages[0].date).toMatch(/[+-]\d{2}:\d{2}$|Z$/);
+    expect(et.messages[0].internalDate).toBe('2026-07-27T23:36:00-04:00');
+    expect(et.messages[0].internalDateDisplay).toContain('Mon, Jul 27');
+  });
+
+  it('never reports a 10:38 PM ET send on the following day', () => {
+    const sent = Date.parse('2026-07-28T02:38:00Z'); // 10:38 PM ET on Jul 27
+    const out = JSON.parse(normalizeTimestamps(
+      JSON.stringify({ internalDate: String(sent) }), ET,
+    ));
+    expect(out.internalDate.startsWith('2026-07-27')).toBe(true);
+    expect(out.internalDateDisplay).toContain('Jul 27');
+  });
+
+  it('adds an explicit offset and a display sibling to every allowlisted field', () => {
+    const out = JSON.parse(normalizeTimestamps(JSON.stringify({
+      files: [{ modifiedTime: '2026-07-28T03:36:00Z', createdTime: '2026-07-01T12:00:00Z' }],
+    }), ET));
+    expect(out.files[0].modifiedTime).toBe('2026-07-27T23:36:00-04:00');
+    expect(out.files[0].modifiedTimeDisplay).toContain('Mon, Jul 27');
+    expect(out.files[0].createdTimeDisplay).toBeDefined();
+  });
+
+  it('recurses into nested Calendar structures', () => {
+    const out = JSON.parse(normalizeTimestamps(JSON.stringify({
+      items: [{ start: { dateTime: '2026-07-28T03:36:00Z', timeZone: 'America/New_York' } }],
+    }), ET));
+    expect(out.items[0].start.dateTime).toBe('2026-07-27T23:36:00-04:00');
+    expect(out.items[0].start.dateTimeDisplay).toContain('Jul 27');
+    // A zone NAME is not an instant and must survive untouched.
+    expect(out.items[0].start.timeZone).toBe('America/New_York');
+  });
+
+  // The near-miss names are the real hazard: a name-pattern match would
+  // rewrite spreadsheet cell data.
+  it('leaves near-miss keys and cell values alone', () => {
+    const payload = {
+      updatedCells: 5,
+      updatedRange: 'Sheet1!A1:B2',
+      updatedRows: 2,
+      formattedValue: '2026-07-28 03:36',
+      verificationStatus: 'accepted',
+      values: [['2026-07-28 03:36']],
+    };
+    const out = JSON.parse(normalizeTimestamps(JSON.stringify(payload), ET));
+    expect(out).toEqual(payload);
+  });
+
+  it('passes non-JSON output through untouched', () => {
+    expect(normalizeTimestamps('Error: something failed', ET)).toBe('Error: something failed');
+    expect(normalizeTimestamps('', ET)).toBe('');
+    expect(normalizeTimestamps('not json {', ET)).toBe('not json {');
+    expect(normalizeTimestamps('"a string"', ET)).toBe('"a string"');
+    expect(normalizeTimestamps('{bad json', ET)).toBe('{bad json');
+  });
+
+  it('is idempotent — re-normalizing changes nothing', () => {
+    const once = normalizeTimestamps(JSON.stringify({ date: '2026-07-27 23:36' }), ET);
+    expect(normalizeTimestamps(once, ET)).toBe(once);
+  });
+
+  // Contract test: nothing emitted may lack an offset or Z.
+  it('emits no naive timestamp anywhere in the payload', () => {
+    const out = normalizeTimestamps(JSON.stringify({
+      a: { date: '2026-07-28 03:36' },
+      b: [{ sentAt: '2026-07-27T23:31:09' }],
+      c: { fetchedBodyAt: '2026-07-28T12:11:19.106Z' },
+    }), ET);
+    const parsed = JSON.parse(out);
+    const naive: string[] = [];
+    const scan = (n: unknown): void => {
+      if (Array.isArray(n)) return void n.forEach(scan);
+      if (n && typeof n === 'object') return void Object.values(n).forEach(scan);
+      if (isNaiveTimestamp(n)) naive.push(String(n));
+    };
+    scan(parsed);
+    expect(naive).toEqual([]);
+  });
+
+  // Mixed-zone assertion: one object must not carry both naive and
+  // offset-bearing values.
+  it('never mixes naive and offset-bearing timestamps in one object', () => {
+    const out = JSON.parse(normalizeTimestamps(JSON.stringify({
+      sentAt: '2026-07-27T23:31:09',
+      fetchedBodyAt: '2026-07-28T12:11:19.106Z',
+      asOf: '2026-07-28T20:27:11.426Z',
+    }), ET));
+    const values = [out.sentAt, out.fetchedBodyAt, out.asOf];
+    expect(values.every((v: string) => /([+-]\d{2}:\d{2}|Z)$/.test(v))).toBe(true);
+    expect(values.some(isNaiveTimestamp)).toBe(false);
+  });
+
+  it('keeps contemporaneous events in order and on the same day', () => {
+    const base = Date.parse('2026-07-28T03:31:09Z');
+    const out = JSON.parse(normalizeTimestamps(JSON.stringify({
+      ofw: { sentAt: '2026-07-27T23:31:09' },
+      gmail: { internalDate: String(base + 5 * 60_000) },
+    }), ET));
+    expect(out.ofw.sentAt).toBe('2026-07-27T23:31:09-04:00');
+    expect(out.gmail.internalDate).toBe('2026-07-27T23:36:09-04:00');
+    expect(out.ofw.sentAtDisplay).toContain('Jul 27');
+    expect(out.gmail.internalDateDisplay).toContain('Jul 27');
+  });
+
+  it('DISPLAY_TZ shifts display fields and the offset, nothing else', () => {
+    const payload = JSON.stringify({ id: 'm1', subject: 'S', internalDate: '1785296160000' });
+    const et = JSON.parse(normalizeTimestamps(payload, ET));
+    const pt = JSON.parse(normalizeTimestamps(payload, 'America/Los_Angeles'));
+    expect(et.internalDate).not.toBe(pt.internalDate);
+    expect(et.internalDateDisplay).not.toBe(pt.internalDateDisplay);
+    // Same instant either way.
+    expect(Date.parse(et.internalDate)).toBe(Date.parse(pt.internalDate));
+    // Non-timestamp fields are untouched by the zone.
+    expect(pt.id).toBe('m1');
+    expect(pt.subject).toBe('S');
+  });
+
+  // In UTC, longOffset renders a bare "GMT" with no numeric part, and a naive
+  // wall time needs no correction at all.
+  it('renders UTC as +00:00 with no drift correction', () => {
+    const out = JSON.parse(normalizeTimestamps(
+      JSON.stringify({ date: '2026-07-28 03:36' }), 'UTC', 'UTC',
+    ));
+    expect(out.date).toBe('2026-07-28T03:36:00+00:00');
+    expect(out.dateDisplay).toContain('Jul 28');
+  });
+
+  it('preserves sub-second precision on a naive value', () => {
+    const out = JSON.parse(normalizeTimestamps(
+      JSON.stringify({ fetchedBodyAt: '2026-07-28T12:11:19.106' }), 'UTC', 'UTC',
+    ));
+    expect(out.fetchedBodyAt).toBe('2026-07-28T12:11:19.106+00:00');
+  });
+
+  it('normalizes a top-level array', () => {
+    const out = JSON.parse(normalizeTimestamps(
+      JSON.stringify([{ internalDate: '1785296160000' }]), ET,
+    ));
+    expect(out[0].internalDate).toMatch(/[+-]\d{2}:\d{2}$/);
+  });
+
+  it('leaves an allowlisted key alone when its value is not a timestamp', () => {
+    const payload = { date: 'sometime last week', updated: '' };
+    const out = JSON.parse(normalizeTimestamps(JSON.stringify(payload), ET));
+    expect(out).toEqual(payload);
+  });
+
+  // Re-serializing a response that carries no timestamps would silently reflow
+  // it — including flattening a caller's --pretty formatting.
+  it('returns the original text byte-for-byte when nothing was rewritten', () => {
+    const pretty = '{\n  "id": "m1",\n  "subject": "S"\n}';
+    expect(normalizeTimestamps(pretty, ET)).toBe(pretty);
+  });
+
+  it('preserves the caller’s pretty indentation when it does rewrite', () => {
+    const pretty = '{\n  "id": "m1",\n  "date": "2026-07-27 23:36"\n}';
+    const out = normalizeTimestamps(pretty, ET);
+    expect(out).toContain('\n  "date"');
+    expect(JSON.parse(out).date).toBe('2026-07-27T23:36:00-04:00');
+  });
+
+  // Date.UTC rolls impossible components over instead of rejecting them, so a
+  // typo would surface as a confident wrong date.
+  it('rejects impossible naive dates rather than rolling them over', () => {
+    for (const bad of ['2026-13-05T10:00:00', '2026-02-30T10:00:00', '2026-01-01T25:00:00']) {
+      expect(parseTimestampValue('date', bad, ET)).toBeNull();
+    }
+  });
+
+  // 10 digits is epoch SECONDS; reading it as milliseconds dates it to 1970.
+  it('only treats a 13-digit internalDate as epoch milliseconds', () => {
+    expect(parseTimestampValue('internalDate', '1785209760', ET)).toBeNull();
+    expect(parseTimestampValue('internalDate', '1785209760000', ET)).not.toBeNull();
+  });
+
+  it('reads the naive-source zone from GOG_TIMEZONE, independent of DISPLAY_TZ', () => {
+    vi.stubEnv('GOG_TIMEZONE', 'UTC');
+    vi.stubEnv('DISPLAY_TZ', 'America/New_York');
+    // gog formatted this in UTC; it must be read as UTC and displayed in ET.
+    const out = JSON.parse(normalizeTimestamps(JSON.stringify({ date: '2026-07-28 03:36' })));
+    expect(out.date).toBe('2026-07-27T23:36:00-04:00');
+    expect(out.dateDisplay).toContain('Jul 27');
+  });
+
+  it('naiveSourceTimeZone falls back to the display zone', () => {
+    vi.stubEnv('DISPLAY_TZ', 'America/Los_Angeles');
+    expect(naiveSourceTimeZone()).toBe('America/Los_Angeles');
+    vi.stubEnv('GOG_TIMEZONE', 'Mars/Olympus_Mons');
+    expect(naiveSourceTimeZone()).toBe('America/Los_Angeles');
+  });
+
+  it('handles a DST spring-forward wall time without drifting a day', () => {
+    // 2026-03-08 02:30 ET does not exist (clocks jump 02:00 -> 03:00).
+    const out = JSON.parse(normalizeTimestamps(
+      JSON.stringify({ date: '2026-03-08 02:30' }), ET,
+    ));
+    expect(out.date.startsWith('2026-03-08')).toBe(true);
+    expect(out.date).toMatch(/[+-]\d{2}:\d{2}$/);
+  });
+});

package/tests/tools/drive.test.ts

@@ -371,6 +371,25 @@ describe('gog_drive_read_bytes', () => {
     );
   });
 
+  it('names the text fallback when the resource type is one hosts refuse to render', async () => {
+    // The bytes arrive fine; some hosts just drop a non-image embedded resource
+    // ("Resources of type 'application/pdf' are not currently supported"), and
+    // then the text block is all the caller gets.
+    vi.mocked(runner.run).mockResolvedValueOnce(JSON.stringify({ file: { name: 'a.pdf', mimeType: 'application/pdf' } }));
+    vi.mocked(runner.runBinary).mockResolvedValueOnce(Buffer.from('%PDF-1.4').toString('base64'));
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_drive_read_bytes', { fileId: 'f1' });
+    expect(result.content[0].text).toContain('gog_drive_extract_text');
+  });
+
+  it('does not add the fallback hint for an image, which hosts do render', async () => {
+    vi.mocked(runner.run).mockResolvedValueOnce(JSON.stringify({ file: { name: 'a.png', mimeType: 'image/png' } }));
+    vi.mocked(runner.runBinary).mockResolvedValueOnce(Buffer.from('x').toString('base64'));
+    const harness = await setupHandlers();
+    const result = await harness.callTool('gog_drive_read_bytes', { fileId: 'f3' });
+    expect(result.content[0].text).not.toContain('gog_drive_extract_text');
+  });
+
   it('falls back to octet-stream and "file" when metadata lacks name/mime', async () => {
     vi.mocked(runner.run).mockResolvedValueOnce('{}');
     vi.mocked(runner.runBinary).mockResolvedValueOnce(Buffer.from('x').toString('base64'));

package/tests/tools/utils.test.ts

@@ -95,6 +95,25 @@ describe('runOrDiagnose', () => {
     expect(result.isError).toBeUndefined();
   });
 
+  // The `*_raw` dumps promise a verbatim copy of the upstream API response.
+  // Normalizing them would rewrite the API's own epoch-millis internalDate into
+  // an ISO string and flatten the caller's --pretty formatting, so the one tool
+  // you reach for when you need ground truth would stop telling it.
+  it('leaves a lossless response byte-for-byte untouched', async () => {
+    const raw = '{\n  "id": "m1",\n  "internalDate": "1785209760000"\n}';
+    vi.mocked(runner.run).mockResolvedValue(raw);
+    const result = await runOrDiagnose(['gmail', 'raw', 'm1'], { lossless: true });
+    expect(result.content[0].text).toBe(raw);
+  });
+
+  it('normalizes timestamps when lossless is not set', async () => {
+    vi.mocked(runner.run).mockResolvedValue('{"internalDate":"1785209760000"}');
+    const result = await runOrDiagnose(['gmail', 'messages'], {});
+    const parsed = JSON.parse(result.content[0].text as string);
+    expect(parsed.internalDate).toMatch(/[+-]\d{2}:\d{2}$/);
+    expect(parsed.internalDateDisplay).toBeDefined();
+  });
+
   it('appends auth list on non-auth failure', async () => {
     vi.mocked(runner.run)
       .mockRejectedValueOnce(new Error('Doc not found'))