ofw-mcp 2.7.0 → 2.8.0

package/dist/bundle.js

@@ -13672,9 +13672,9 @@ var ZodSet = class _ZodSet extends ZodType {
       }
     }
     const valueType = this._def.valueType;
-    function finalizeSet(elements2) {
+    function finalizeSet(elements3) {
       const parsedSet = /* @__PURE__ */ new Set();
-      for (const element of elements2) {
+      for (const element of elements3) {
         if (element.status === "aborted")
           return INVALID;
         if (element.status === "dirty")
@@ -13683,11 +13683,11 @@ var ZodSet = class _ZodSet extends ZodType {
       }
       return { status: status.value, value: parsedSet };
     }
-    const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
+    const elements2 = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
     if (ctx.common.async) {
-      return Promise.all(elements).then((elements2) => finalizeSet(elements2));
+      return Promise.all(elements2).then((elements3) => finalizeSet(elements3));
     } else {
-      return finalizeSet(elements);
+      return finalizeSet(elements2);
     }
   }
   min(minSize, message) {
@@ -38407,7 +38407,7 @@ async function loginWithPassword(username, password) {
 // package.json
 var package_default = {
   name: "ofw-mcp",
-  version: "2.7.0",
+  version: "2.8.0",
   license: "MIT",
   mcpName: "io.github.chrischall/ofw-mcp",
   description: "OurFamilyWizard MCP server for Claude \u2014 developed and maintained by AI (Claude Code)",
@@ -38449,13 +38449,13 @@ var package_default = {
     zod: "^4.4.3"
   },
   devDependencies: {
-    "@chrischall/mcp-connector": "^1.0.0",
+    "@chrischall/mcp-connector": "^1.1.1",
     "@cloudflare/vitest-pool-workers": "^0.18.4",
     "@cloudflare/workers-oauth-provider": "^0.8.1",
     "@cloudflare/workers-types": "^5.20260708.1",
     "@types/node": "^26.0.0",
     "@vitest/coverage-v8": "^4.1.7",
-    agents: "^0.17.3",
+    agents: "^0.19.0",
     esbuild: "^0.28.0",
     typescript: "^7.0.2",
     vitest: "^4.1.7",
@@ -38972,7 +38972,7 @@ async function walkPages(client2, folder, folderId, opts, store) {
         await fetchAttachmentMetaBudgeted(client2, item.id, detailFileIds, store, budget);
       }
     }
-    await store.upsertMessages(toUpsert);
+    if (toUpsert.length > 0) await store.upsertMessages(toUpsert);
     if (pageBudgetHit) {
       return { synced, unread, newestId, pagesFetched, done: false, nextPage: page };
     }
@@ -39235,6 +39235,20 @@ function getCalendarWritesAllowed() {
   if (mode === "all") return true;
   return mode === "drafts" && parseBoolEnv("OFW_CALENDAR_WRITES");
 }
+function getAllowMarkRead() {
+  const raw = process.env.OFW_ALLOW_MARK_READ;
+  if (typeof raw !== "string" || raw.trim().length === 0) return true;
+  const value = raw.trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(value)) return true;
+  if (["0", "false", "no", "off"].includes(value)) return false;
+  console.error(
+    `[ofw-mcp] Unrecognized OFW_ALLOW_MARK_READ "${raw.trim()}" \u2014 failing closed to "false" (no tool may mark a message read on OFW). Valid values: true, false.`
+  );
+  return false;
+}
+function getFetchUnreadBodies() {
+  return parseBoolEnv("OFW_FETCH_UNREAD_BODIES");
+}
 function getDefaultInlineAttachments() {
   return parseBoolEnv("OFW_INLINE_ATTACHMENTS");
 }
@@ -39408,6 +39422,10 @@ async function fetchServerDraft(client2, id) {
     recipients: mapRecipients(detail.recipients)
   };
 }
+var SUBSTANTIVE_FIELDS = ["subject", "body", "recipients"];
+function substantiveChanges(changed) {
+  return changed.filter((f) => SUBSTANTIVE_FIELDS.includes(f));
+}
 function diffFields(a, b) {
   const changed = [];
   if (a.subject !== b.subject) changed.push("subject");
@@ -39431,6 +39449,17 @@ function checkDraftFreshness(input) {
     if (expectedRevision === actual) {
       return { verdict: "FRESH", reason: "expectedRevision matches the live server draft.", changedFields: [] };
     }
+    if (cached2 !== null && draftRevision(cached2) === expectedRevision) {
+      const changedFields2 = diffFields(server, cached2);
+      if (substantiveChanges(changedFields2).length === 0) {
+        return {
+          verdict: "FRESH",
+          reason: `Only connector-authored metadata (${changedFields2.join(", ")}) changed since you read the draft; its subject, body and recipients are unchanged, so this is not a conflict.`,
+          changedFields: changedFields2,
+          metadataOnly: true
+        };
+      }
+    }
     return {
       verdict: "STALE",
       reason: `expectedRevision ${expectedRevision} does not match the live server draft (${actual}) \u2014 it changed after you read it.`,
@@ -39448,6 +39477,14 @@ function checkDraftFreshness(input) {
   if (changedFields.length === 0) {
     return { verdict: "FRESH", reason: "The cached draft matches the live server draft.", changedFields: [] };
   }
+  if (substantiveChanges(changedFields).length === 0) {
+    return {
+      verdict: "FRESH",
+      reason: `Only connector-authored metadata (${changedFields.join(", ")}) differs from the cached copy; subject, body and recipients match, so this is not a conflict.`,
+      changedFields,
+      metadataOnly: true
+    };
+  }
   return {
     verdict: "STALE",
     reason: `The draft on OurFamilyWizard differs from the cached copy (${changedFields.join(", ")}) \u2014 it was edited outside this tool.`,
@@ -39468,6 +39505,872 @@ function staleDraftPayload(input) {
   };
 }
 
+// src/extract/inflate.ts
+var MAX_DECOMPRESSED_BYTES = 32 * 1024 * 1024;
+var DecompressionLimitError = class extends Error {
+  constructor(label, limit) {
+    super(`${label} expands past the ${limit}-byte decompression cap`);
+    this.name = "DecompressionLimitError";
+  }
+};
+async function inflateBounded(data, format, limit, label) {
+  const stream = new Blob([data]).stream().pipeThrough(new DecompressionStream(format));
+  const reader = stream.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    total += value.length;
+    if (total > limit) {
+      await reader.cancel();
+      throw new DecompressionLimitError(label, limit);
+    }
+    chunks.push(value);
+  }
+  return Buffer.concat(chunks);
+}
+
+// src/extract/zip.ts
+var EOCD_SIG = 101010256;
+var CENTRAL_SIG = 33639248;
+var LOCAL_SIG = 67324752;
+var ZIP64_SENTINEL = 4294967295;
+var ZIP_MAX_UNCOMPRESSED_BYTES = MAX_DECOMPRESSED_BYTES;
+function findEocd(bytes) {
+  const earliest = Math.max(0, bytes.length - (22 + 65535));
+  for (let i = bytes.length - 22; i >= earliest; i--) {
+    if (bytes.readUInt32LE(i) === EOCD_SIG) return i;
+  }
+  throw new Error("not a ZIP archive (no end-of-central-directory record)");
+}
+async function readZip(bytes, opts = {}) {
+  const limit = opts.maxUncompressedBytes ?? ZIP_MAX_UNCOMPRESSED_BYTES;
+  const eocd = findEocd(bytes);
+  const count = bytes.readUInt16LE(eocd + 10);
+  const cdOffset = bytes.readUInt32LE(eocd + 16);
+  if (cdOffset === ZIP64_SENTINEL || count === 65535) {
+    throw new Error("ZIP64 archives are not supported");
+  }
+  const entries = /* @__PURE__ */ new Map();
+  let p = cdOffset;
+  for (let i = 0; i < count; i++) {
+    if (bytes.readUInt32LE(p) !== CENTRAL_SIG) {
+      throw new Error(`corrupt ZIP central directory at offset ${p}`);
+    }
+    const nameLen = bytes.readUInt16LE(p + 28);
+    const extraLen = bytes.readUInt16LE(p + 30);
+    const commentLen = bytes.readUInt16LE(p + 32);
+    const name = bytes.toString("utf8", p + 46, p + 46 + nameLen);
+    entries.set(name, {
+      name,
+      method: bytes.readUInt16LE(p + 10),
+      compressedSize: bytes.readUInt32LE(p + 20),
+      uncompressedSize: bytes.readUInt32LE(p + 24),
+      localOffset: bytes.readUInt32LE(p + 42)
+    });
+    p += 46 + nameLen + extraLen + commentLen;
+  }
+  const cache = /* @__PURE__ */ new Map();
+  async function read(name) {
+    const cached2 = cache.get(name);
+    if (cached2) return cached2;
+    const entry = entries.get(name);
+    if (!entry) return null;
+    if (entry.uncompressedSize > limit) {
+      throw new Error(
+        `ZIP member ${name} is too large to extract (${entry.uncompressedSize} bytes)`
+      );
+    }
+    const lo = entry.localOffset;
+    if (bytes.readUInt32LE(lo) !== LOCAL_SIG) {
+      throw new Error(`corrupt ZIP local header for ${name}`);
+    }
+    const start = lo + 30 + bytes.readUInt16LE(lo + 26) + bytes.readUInt16LE(lo + 28);
+    const raw = bytes.subarray(start, start + entry.compressedSize);
+    let out;
+    if (entry.method === 0) out = Buffer.from(raw);
+    else if (entry.method === 8) out = await inflateBounded(raw, "deflate-raw", limit, `ZIP member ${name}`);
+    else throw new Error(`unsupported ZIP compression method ${entry.method} for ${name}`);
+    cache.set(name, out);
+    return out;
+  }
+  return {
+    names: () => [...entries.keys()],
+    has: (name) => entries.has(name),
+    read,
+    async readText(name) {
+      const buf = await read(name);
+      if (!buf) return null;
+      const text = buf.toString("utf8");
+      return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+    }
+  };
+}
+
+// src/extract/xml.ts
+var NAMED_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'"
+};
+function decodeXmlEntities(text) {
+  if (!text.includes("&")) return text;
+  return text.replace(/&(#x?[0-9a-fA-F]+|[a-zA-Z]+);/g, (whole, body) => {
+    if (body[0] === "#") {
+      const code = body[1] === "x" || body[1] === "X" ? parseInt(body.slice(2), 16) : parseInt(body.slice(1), 10);
+      return String.fromCodePoint(code);
+    }
+    return NAMED_ENTITIES[body] ?? whole;
+  });
+}
+function* elements(xml, tag) {
+  const re = new RegExp(`<${tag}((?:\\s[^>]*?)?)(?:\\s*/>|>([\\s\\S]*?)</${tag}>)`, "g");
+  for (let m = re.exec(xml); m !== null; m = re.exec(xml)) {
+    yield { attrs: m[1], inner: m[2] ?? "" };
+  }
+}
+function attr(attrs, name) {
+  const m = new RegExp(`(?:^|\\s)${name}\\s*=\\s*("([^"]*)"|'([^']*)')`).exec(attrs);
+  if (!m) return null;
+  return decodeXmlEntities(m[2] ?? m[3]);
+}
+function textOf(xml, tag) {
+  let out = "";
+  for (const el of elements(xml, tag)) out += decodeXmlEntities(el.inner);
+  return out;
+}
+
+// src/extract/ooxml.ts
+function resolvePartPath(baseDir, target) {
+  if (target.startsWith("/")) return target.slice(1);
+  const segments = (baseDir + target).split("/");
+  const out = [];
+  for (const segment of segments) {
+    if (segment === "." || segment === "") continue;
+    if (segment === "..") out.pop();
+    else out.push(segment);
+  }
+  return out.join("/");
+}
+function dirOf(partPath) {
+  const i = partPath.lastIndexOf("/");
+  return i === -1 ? "" : partPath.slice(0, i + 1);
+}
+async function readRels(zip, partPath) {
+  const dir = dirOf(partPath);
+  const base = partPath.slice(dir.length);
+  const xml = await zip.readText(`${dir}_rels/${base}.rels`);
+  if (!xml) return [];
+  const rels = [];
+  for (const el of elements(xml, "Relationship")) {
+    const id = attr(el.attrs, "Id");
+    const target = attr(el.attrs, "Target");
+    if (!id || !target) continue;
+    rels.push({ id, target: resolvePartPath(dir, target), type: attr(el.attrs, "Type") ?? "" });
+  }
+  return rels;
+}
+function findPart(zip, conventional, fileName) {
+  if (zip.has(conventional)) return conventional;
+  return zip.names().find((n) => n.endsWith(`/${fileName}`) || n === fileName) ?? null;
+}
+
+// src/extract/spreadsheet.ts
+var DEFAULT_MAX_CELLS = 2e5;
+var BUILTIN_DATE_FORMATS = /* @__PURE__ */ new Set([14, 15, 16, 17, 18, 19, 20, 21, 22, 45, 46, 47]);
+var SERIAL_EPOCH_OFFSET = 25569;
+function excelSerialToIso(serial, date1904) {
+  const base = date1904 ? serial + 1462 : serial;
+  const corrected = Math.floor(base) < 60 ? base + 1 : base;
+  const date5 = new Date(Math.round((corrected - SERIAL_EPOCH_OFFSET) * 864e5));
+  if (Number.isNaN(date5.getTime())) return null;
+  const iso = date5.toISOString();
+  if (base < 1) return iso.slice(11, 19);
+  return iso.slice(11, 19) === "00:00:00" ? iso.slice(0, 10) : iso.slice(0, 19);
+}
+function isDateFormat(numFmtId, formatCode) {
+  if (BUILTIN_DATE_FORMATS.has(numFmtId)) return true;
+  if (!formatCode) return false;
+  const bare = formatCode.replace(/"[^"]*"/g, "").replace(/\[[^\]]*\]/g, "").replace(/\\./g, "");
+  return /[ymdhs]/i.test(bare);
+}
+function columnIndex(ref) {
+  const m = /^([A-Z]+)/.exec(ref);
+  if (!m) return null;
+  let index = 0;
+  for (const ch of m[1]) index = index * 26 + (ch.charCodeAt(0) - 64);
+  return index - 1;
+}
+function csvField(value) {
+  return /[",\r\n]/.test(value) ? `"${value.replace(/"/g, '""')}"` : value;
+}
+function toCsv(rows, cols) {
+  return rows.map((row) => Array.from({ length: cols }, (_, i) => csvField(row[i] ?? "")).join(",")).join("\n");
+}
+async function readStyles(zip, dir) {
+  const xml = await zip.readText(`${dir}styles.xml`);
+  if (!xml) return { dateStyles: [] };
+  const custom2 = /* @__PURE__ */ new Map();
+  for (const el of elements(xml, "numFmt")) {
+    const id = Number(attr(el.attrs, "numFmtId"));
+    const code = attr(el.attrs, "formatCode");
+    if (Number.isFinite(id) && code !== null) custom2.set(id, code);
+  }
+  const dateStyles = [];
+  for (const block of elements(xml, "cellXfs")) {
+    for (const xf of elements(block.inner, "xf")) {
+      const id = Number(attr(xf.attrs, "numFmtId") ?? "0");
+      dateStyles.push(isDateFormat(id, custom2.get(id)));
+    }
+  }
+  return { dateStyles };
+}
+async function readSharedStrings(zip, dir) {
+  const xml = await zip.readText(`${dir}sharedStrings.xml`);
+  if (!xml) return [];
+  return [...elements(xml, "si")].map((si) => textOf(si.inner, "t"));
+}
+function cellValue(attrs, inner, ctx) {
+  const type = attr(attrs, "t") ?? "n";
+  if (type === "inlineStr") return textOf(inner, "t");
+  const raw = textOf(inner, "v");
+  switch (type) {
+    case "s": {
+      const index = Number(raw);
+      return ctx.shared[index] ?? "";
+    }
+    case "b":
+      return raw === "1" ? "TRUE" : "FALSE";
+    case "str":
+    case "e":
+      return raw;
+    default: {
+      const styleIndex = Number(attr(attrs, "s") ?? "-1");
+      const numeric = Number(raw);
+      if (ctx.styles.dateStyles[styleIndex] && raw !== "" && Number.isFinite(numeric)) {
+        return excelSerialToIso(numeric, ctx.date1904) ?? raw;
+      }
+      return raw;
+    }
+  }
+}
+function parseSheet(xml, name, ctx, maxCells) {
+  const rows = [];
+  let cols = 0;
+  let cells = 0;
+  let truncated = false;
+  for (const row of elements(xml, "row")) {
+    if (cells >= maxCells) {
+      truncated = true;
+      break;
+    }
+    const values = [];
+    for (const cell of elements(row.inner, "c")) {
+      const ref = attr(cell.attrs, "r");
+      const index = ref === null ? null : columnIndex(ref);
+      if (index === null) continue;
+      values[index] = cellValue(cell.attrs, cell.inner, ctx);
+      cells++;
+      if (index + 1 > cols) cols = index + 1;
+    }
+    rows.push(values);
+  }
+  return { name, rows: rows.length, cols, csv: toCsv(rows, cols), ...truncated ? { truncated } : {} };
+}
+async function extractXlsx(bytes, opts = {}) {
+  const zip = await readZip(bytes);
+  const workbookPath = findPart(zip, "xl/workbook.xml", "workbook.xml");
+  if (!workbookPath) throw new Error("no workbook part found in the .xlsx archive");
+  const dir = dirOf(workbookPath);
+  const workbookXml = await zip.readText(workbookPath) ?? "";
+  const rels = await readRels(zip, workbookPath);
+  const targetById = new Map(rels.map((r) => [r.id, r.target]));
+  const ctx = {
+    shared: await readSharedStrings(zip, dir),
+    styles: await readStyles(zip, dir),
+    date1904: /<workbookPr[^>]*date1904="(1|true)"/i.test(workbookXml)
+  };
+  const maxCells = opts.maxCells ?? DEFAULT_MAX_CELLS;
+  const sheets = [];
+  const omitted = [];
+  let index = 0;
+  for (const el of elements(workbookXml, "sheet")) {
+    const position = index++;
+    const name = attr(el.attrs, "name") ?? `Sheet${position + 1}`;
+    if (opts.select && !opts.select(position, name)) {
+      omitted.push(name);
+      continue;
+    }
+    const relId = attr(el.attrs, "r:id") ?? attr(el.attrs, "id");
+    const path = (relId && targetById.get(relId)) ?? resolvePartPath(dir, `worksheets/sheet${position + 1}.xml`);
+    const xml = await zip.readText(path);
+    if (xml === null) {
+      omitted.push(`${name} (sheet part not found in the workbook)`);
+      continue;
+    }
+    sheets.push(parseSheet(xml, name, ctx, maxCells));
+  }
+  const truncated = sheets.some((s) => s.truncated);
+  return {
+    kind: "spreadsheet",
+    sheets,
+    ...omitted.length ? { omitted } : {},
+    ...truncated ? { truncated } : {}
+  };
+}
+function parseDelimitedRows(text, delimiter) {
+  const rows = [];
+  let row = [];
+  let field = "";
+  let quoted = false;
+  let dirty = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (quoted) {
+      if (ch !== '"') {
+        field += ch;
+        continue;
+      }
+      if (text[i + 1] === '"') {
+        field += '"';
+        i++;
+        continue;
+      }
+      quoted = false;
+      continue;
+    }
+    if (ch === '"') {
+      quoted = true;
+      dirty = true;
+      continue;
+    }
+    if (ch === delimiter) {
+      row.push(field);
+      field = "";
+      dirty = true;
+      continue;
+    }
+    if (ch === "\r") continue;
+    if (ch === "\n") {
+      row.push(field);
+      rows.push(row);
+      row = [];
+      field = "";
+      dirty = false;
+      continue;
+    }
+    field += ch;
+    dirty = true;
+  }
+  if (dirty || field !== "") {
+    row.push(field);
+    rows.push(row);
+  }
+  return rows;
+}
+function extractDelimited(text, name, delimiter) {
+  const rows = parseDelimitedRows(text, delimiter);
+  const cols = rows.reduce((max, r) => Math.max(max, r.length), 0);
+  return {
+    kind: "spreadsheet",
+    sheets: [{ name, rows: rows.length, cols, csv: toCsv(rows, cols) }]
+  };
+}
+
+// src/extract/document.ts
+var RUN_CONTENT = /<w:t(?:\s[^>]*)?>([\s\S]*?)<\/w:t>|<w:(tab|br|cr)\s*\/>/g;
+function paragraphText(inner) {
+  let text = "";
+  for (let m = RUN_CONTENT.exec(inner); m !== null; m = RUN_CONTENT.exec(inner)) {
+    if (m[1] !== void 0) text += decodeXmlEntities(m[1]);
+    else text += m[2] === "tab" ? "	" : "\n";
+  }
+  RUN_CONTENT.lastIndex = 0;
+  return text;
+}
+function styledParagraph(inner) {
+  const text = paragraphText(inner);
+  if (text === "") return "";
+  const style = /<w:pStyle\s[^>]*w:val="([^"]*)"/.exec(inner)?.[1] ?? "";
+  const heading = /^Heading(\d)$/.exec(style);
+  if (heading) return `${"#".repeat(Math.min(Number(heading[1]), 6))} ${text}`;
+  if (style === "Title" || style === "Subtitle") return `# ${text}`;
+  if (style === "ListParagraph") return `- ${text}`;
+  return text;
+}
+function tableText(inner) {
+  const rows = [];
+  for (const tr of elements(inner, "w:tr")) {
+    const cells = [];
+    for (const tc of elements(tr.inner, "w:tc")) {
+      const parts = [];
+      for (const p of elements(tc.inner, "w:p")) {
+        const text = paragraphText(p.inner);
+        if (text !== "") parts.push(text);
+      }
+      cells.push(parts.join(" "));
+    }
+    rows.push(`| ${cells.join(" | ")} |`);
+  }
+  return rows.join("\n");
+}
+var BLOCK = /<w:tbl(?:\s[^>]*?)?>[\s\S]*?<\/w:tbl>|<w:p(?:\s[^>]*?)?(?:\s*\/>|>([\s\S]*?)<\/w:p>)/g;
+async function extractDocx(bytes) {
+  const zip = await readZip(bytes);
+  const path = findPart(zip, "word/document.xml", "document.xml");
+  if (!path) throw new Error("no document part found in the .docx archive");
+  const xml = await zip.readText(path) ?? "";
+  const blocks = [];
+  for (let m = BLOCK.exec(xml); m !== null; m = BLOCK.exec(xml)) {
+    const text = m[0].startsWith("<w:tbl") ? tableText(m[0]) : styledParagraph(m[1] ?? "");
+    if (text !== "") blocks.push(text);
+  }
+  BLOCK.lastIndex = 0;
+  return { kind: "document", text: blocks.join("\n\n") };
+}
+
+// src/extract/presentation.ts
+var SLIDE_PATH = /^ppt\/slides\/slide(\d+)\.xml$/;
+function slideText(xml) {
+  const lines = [];
+  for (const p of elements(xml, "a:p")) {
+    let line = "";
+    for (const t of elements(p.inner, "a:t")) line += decodeXmlEntities(t.inner);
+    if (line !== "") lines.push(line);
+  }
+  return lines.join("\n");
+}
+async function extractPptx(bytes, opts = {}) {
+  const zip = await readZip(bytes);
+  const paths = zip.names().map((name) => ({ name, n: Number(SLIDE_PATH.exec(name)?.[1]) })).filter((e) => Number.isFinite(e.n)).sort((a, b) => a.n - b.n);
+  if (paths.length === 0) throw new Error("no slides found in the .pptx archive");
+  const slides = [];
+  const omitted = [];
+  for (let i = 0; i < paths.length; i++) {
+    const { name } = paths[i];
+    const number4 = i + 1;
+    if (opts.select && !opts.select(i, `slide ${number4}`)) {
+      omitted.push(`slide ${number4}`);
+      continue;
+    }
+    const text = slideText(await zip.readText(name) ?? "");
+    const notesRel = (await readRels(zip, name)).find((r) => r.type.endsWith("/notesSlide"));
+    const notesXml = notesRel ? await zip.readText(notesRel.target) : null;
+    const notes = notesXml === null ? "" : slideText(notesXml);
+    slides.push({ number: number4, text, ...notes ? { notes } : {} });
+  }
+  return {
+    kind: "presentation",
+    slides,
+    ...omitted.length ? { omitted } : {}
+  };
+}
+
+// src/extract/pdf.ts
+var OBJ_HEADER = /(\d+)\s+\d+\s+obj\b/g;
+function parseObjects(text) {
+  const objects = /* @__PURE__ */ new Map();
+  for (let m = OBJ_HEADER.exec(text); m !== null; m = OBJ_HEADER.exec(text)) {
+    const start = m.index + m[0].length;
+    const end = text.indexOf("endobj", start);
+    objects.set(Number(m[1]), {
+      num: Number(m[1]),
+      body: text.slice(start, end === -1 ? void 0 : end),
+      start
+    });
+  }
+  OBJ_HEADER.lastIndex = 0;
+  return objects;
+}
+function refsIn(fragment) {
+  return [...fragment.matchAll(/(\d+)\s+\d+\s+R\b/g)].map((m) => Number(m[1]));
+}
+function orderedPages(objects) {
+  const isPage = (o) => /\/Type\s*\/Page[^s]/.test(o.body);
+  const inFileOrder = [...objects.values()].filter(isPage).sort((a, b) => a.start - b.start);
+  const catalog = [...objects.values()].find((o) => /\/Type\s*\/Catalog/.test(o.body));
+  const rootRef = catalog ? refsIn(/\/Pages\s+[^/>]*/.exec(catalog.body)?.[0] ?? "")[0] : void 0;
+  if (rootRef === void 0) return inFileOrder;
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (num) => {
+    if (seen.has(num)) return;
+    seen.add(num);
+    const obj = objects.get(num);
+    if (!obj) return;
+    if (isPage(obj)) {
+      ordered.push(obj);
+      return;
+    }
+    const kids = /\/Kids\s*\[([^\]]*)\]/.exec(obj.body)?.[1];
+    if (kids) for (const kid of refsIn(kids)) walk(kid);
+  };
+  walk(rootRef);
+  return ordered.length > 0 ? ordered : inFileOrder;
+}
+function streamBytes(bytes, obj) {
+  const marker = /stream\r?\n/.exec(obj.body);
+  if (!marker) return null;
+  const from = obj.start + marker.index + marker[0].length;
+  const declared = /\/Length\s+(\d+)(?!\s+\d+\s+R)/.exec(obj.body);
+  if (declared) return bytes.subarray(from, from + Number(declared[1]));
+  const end = bytes.indexOf("endstream", from, "latin1");
+  return bytes.subarray(from, end === -1 ? void 0 : end);
+}
+async function decodeStream(bytes, obj) {
+  const raw = streamBytes(bytes, obj);
+  if (!raw) return null;
+  const filter = /\/Filter\s*(\/\w+|\[[^\]]*\])/.exec(obj.body)?.[1] ?? "";
+  if (filter === "") return raw;
+  if (!filter.includes("FlateDecode")) return null;
+  try {
+    return await inflateBounded(raw, "deflate", MAX_DECOMPRESSED_BYTES, "PDF stream");
+  } catch (err) {
+    if (err instanceof DecompressionLimitError) throw err;
+    return null;
+  }
+}
+function readLiteral(text, i) {
+  let value = "";
+  let depth = 1;
+  let p = i + 1;
+  for (; p < text.length; p++) {
+    const ch = text[p];
+    if (ch === "\\") {
+      const esc2 = text[++p];
+      const simple = { n: "\n", r: "\r", t: "	", b: "\b", f: "\f" };
+      if (simple[esc2]) {
+        value += simple[esc2];
+        continue;
+      }
+      const octal = /^[0-7]{1,3}/.exec(text.slice(p, p + 3))?.[0];
+      if (octal) {
+        value += String.fromCharCode(parseInt(octal, 8));
+        p += octal.length - 1;
+        continue;
+      }
+      if (esc2 === "\n") continue;
+      value += esc2;
+      continue;
+    }
+    if (ch === "(") {
+      depth++;
+      value += ch;
+      continue;
+    }
+    if (ch === ")") {
+      depth--;
+      if (depth === 0) break;
+      value += ch;
+      continue;
+    }
+    value += ch;
+  }
+  return { value, next: p };
+}
+function decodeHexString(hex3) {
+  const clean = hex3.replace(/[^0-9a-fA-F]/g, "");
+  const padded = clean.length % 2 === 1 ? `${clean}0` : clean;
+  const buf = Buffer.from(padded, "hex");
+  if (buf.length >= 2 && buf.length % 2 === 0 && buf[0] === 254 && buf[1] === 255) {
+    return buf.subarray(2).swap16().toString("utf16le");
+  }
+  if (buf.length % 2 === 0 && buf.length > 0 && buf.every((b, i) => i % 2 === 1 || b === 0)) {
+    return buf.swap16().toString("utf16le");
+  }
+  return buf.toString("latin1");
+}
+function textFromContentStream(content) {
+  let out = "";
+  let pending = "";
+  let arrayDepth = 0;
+  for (let i = 0; i < content.length; i++) {
+    const ch = content[i];
+    if (ch === "(") {
+      const { value, next } = readLiteral(content, i);
+      pending += value;
+      i = next;
+      continue;
+    }
+    if (ch === "<" && content[i + 1] === "<") {
+      i++;
+      continue;
+    }
+    if (ch === "<") {
+      const end = content.indexOf(">", i);
+      if (end === -1) break;
+      pending += decodeHexString(content.slice(i + 1, end));
+      i = end;
+      continue;
+    }
+    if (ch === "[") {
+      arrayDepth++;
+      continue;
+    }
+    if (ch === "]") {
+      arrayDepth = 0;
+      continue;
+    }
+    if (arrayDepth > 0 && (ch === "-" || ch >= "0" && ch <= "9")) {
+      const num = /^-?\d+(\.\d+)?/.exec(content.slice(i));
+      if (!num) continue;
+      if (Number(num[0]) <= -100) pending += " ";
+      i += num[0].length - 1;
+      continue;
+    }
+    if (/[A-Za-z'"*]/.test(ch)) {
+      const op = /^[A-Za-z*]+|^['"]/.exec(content.slice(i))?.[0] ?? ch;
+      i += op.length - 1;
+      if (op === "Tj" || op === "TJ") {
+        out += pending;
+        pending = "";
+        continue;
+      }
+      if (op === "'" || op === '"') {
+        out += `
+${pending}`;
+        pending = "";
+        continue;
+      }
+      if (op === "Td" || op === "TD" || op === "T*" || op === "ET") {
+        out += "\n";
+        continue;
+      }
+    }
+  }
+  return out;
+}
+function tidy(text) {
+  return text.replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+async function extractPdf(bytes, opts = {}) {
+  const text = bytes.toString("latin1");
+  if (/\/Encrypt\b/.test(text)) {
+    throw new Error("the PDF is encrypted; its text cannot be extracted");
+  }
+  const objects = parseObjects(text);
+  const pageObjects = orderedPages(objects);
+  if (pageObjects.length === 0) throw new Error("no pages found in the PDF");
+  const pages = [];
+  const omitted = [];
+  for (let i = 0; i < pageObjects.length; i++) {
+    const number4 = i + 1;
+    if (opts.select && !opts.select(i, `page ${number4}`)) {
+      omitted.push(`page ${number4}`);
+      continue;
+    }
+    const contentsFragment = /\/Contents\s*(\d+\s+\d+\s+R|\[[^\]]*\])/.exec(pageObjects[i].body)?.[1] ?? "";
+    let raw = "";
+    for (const ref of refsIn(contentsFragment)) {
+      const streamObj = objects.get(ref);
+      if (!streamObj) continue;
+      const decoded = await decodeStream(bytes, streamObj);
+      if (decoded) raw += `${decoded.toString("latin1")}
+`;
+    }
+    pages.push({ number: number4, text: tidy(textFromContentStream(raw)) });
+  }
+  const textLayer = pages.some((p) => p.text !== "");
+  return {
+    kind: "pdf",
+    pages,
+    textLayer,
+    ...textLayer ? {} : {
+      note: "This PDF has no extractable text layer \u2014 it is most likely a scan or an image-only export. Reading it requires OCR, which this server does not perform."
+    },
+    ...omitted.length ? { omitted } : {}
+  };
+}
+
+// src/extract/index.ts
+var MIME_KINDS = {
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
+  "application/vnd.ms-excel.sheet.macroenabled.12": "xlsx",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation": "pptx",
+  "application/pdf": "pdf",
+  "text/csv": "csv",
+  "text/tab-separated-values": "tsv",
+  "application/json": "text",
+  "application/xml": "text",
+  "application/xhtml+xml": "text",
+  "application/javascript": "text",
+  "application/x-yaml": "text"
+};
+var EXT_KINDS = {
+  ".xlsx": "xlsx",
+  ".xlsm": "xlsx",
+  ".docx": "docx",
+  ".pptx": "pptx",
+  ".pdf": "pdf",
+  ".csv": "csv",
+  ".tsv": "tsv",
+  ".tab": "tsv",
+  ".txt": "text",
+  ".md": "text",
+  ".json": "text",
+  ".xml": "text",
+  ".html": "text",
+  ".htm": "text",
+  ".log": "text",
+  ".yaml": "text",
+  ".yml": "text",
+  ".ics": "text",
+  ".vcf": "text",
+  ".srt": "text"
+};
+function extractKindFor(mimeType, fileName) {
+  const byMime = MIME_KINDS[mimeType];
+  if (byMime) return byMime;
+  const dot = fileName.lastIndexOf(".");
+  const byExt = dot === -1 ? void 0 : EXT_KINDS[fileName.slice(dot).toLowerCase()];
+  if (byExt) return byExt;
+  return mimeType.startsWith("text/") ? "text" : null;
+}
+function parsePartSpec(spec) {
+  const ranges = [];
+  const names = /* @__PURE__ */ new Set();
+  for (const token of spec.split(",").map((t) => t.trim()).filter(Boolean)) {
+    const range = /^(\d+)\s*-\s*(\d+)$/.exec(token);
+    if (range) {
+      ranges.push([Number(range[1]), Number(range[2])]);
+      continue;
+    }
+    if (/^\d+$/.test(token)) ranges.push([Number(token), Number(token)]);
+    names.add(token.toLowerCase());
+  }
+  if (ranges.length === 0 && names.size === 0) return () => true;
+  return (index, name) => ranges.some(([from, to]) => index + 1 >= from && index + 1 <= to) || names.has(name.toLowerCase());
+}
+function clip(text, budget) {
+  const cut = text.slice(0, budget);
+  const lastBreak = cut.lastIndexOf("\n");
+  return lastBreak > 0 ? cut.slice(0, lastBreak) : cut;
+}
+function omissionNote(label) {
+  return `${label} (omitted: response character budget)`;
+}
+function applyCharBudget(extracted, maxChars) {
+  switch (extracted.kind) {
+    case "text":
+    case "document": {
+      if (extracted.text.length <= maxChars) return extracted;
+      return { ...extracted, text: clip(extracted.text, maxChars), truncated: true };
+    }
+    case "spreadsheet": {
+      const sheets = [];
+      const omitted = [...extracted.omitted ?? []];
+      let budget = maxChars;
+      let truncated = extracted.truncated ?? false;
+      for (const sheet of extracted.sheets) {
+        if (budget <= 0) {
+          omitted.push(omissionNote(sheet.name));
+          truncated = true;
+          continue;
+        }
+        if (sheet.csv.length <= budget) {
+          sheets.push(sheet);
+          budget -= sheet.csv.length;
+          continue;
+        }
+        const csv = clip(sheet.csv, budget);
+        sheets.push({ ...sheet, csv, rows: csv.split("\n").length, truncated: true });
+        budget = 0;
+        truncated = true;
+      }
+      return {
+        ...extracted,
+        sheets,
+        truncated,
+        ...omitted.length ? { omitted } : {}
+      };
+    }
+    case "presentation": {
+      const slides = [];
+      const omitted = [...extracted.omitted ?? []];
+      let budget = maxChars;
+      let truncated = extracted.truncated ?? false;
+      for (const slide of extracted.slides) {
+        const size = slide.text.length + (slide.notes?.length ?? 0);
+        if (budget <= 0) {
+          omitted.push(omissionNote(`slide ${slide.number}`));
+          truncated = true;
+          continue;
+        }
+        if (size <= budget) {
+          slides.push(slide);
+          budget -= size;
+          continue;
+        }
+        slides.push({ ...slide, text: clip(slide.text, budget), notes: void 0 });
+        budget = 0;
+        truncated = true;
+      }
+      return { ...extracted, slides, truncated, ...omitted.length ? { omitted } : {} };
+    }
+    case "pdf": {
+      const pages = [];
+      const omitted = [...extracted.omitted ?? []];
+      let budget = maxChars;
+      let truncated = extracted.truncated ?? false;
+      for (const page of extracted.pages) {
+        if (budget <= 0) {
+          omitted.push(omissionNote(`page ${page.number}`));
+          truncated = true;
+          continue;
+        }
+        if (page.text.length <= budget) {
+          pages.push(page);
+          budget -= page.text.length;
+          continue;
+        }
+        pages.push({ ...page, text: clip(page.text, budget) });
+        budget = 0;
+        truncated = true;
+      }
+      return { ...extracted, pages, truncated, ...omitted.length ? { omitted } : {} };
+    }
+  }
+}
+var DEFAULT_MAX_CHARS = 5e4;
+function decodeText(bytes) {
+  const text = bytes.toString("utf8");
+  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+}
+async function extractAttachment(bytes, mimeType, fileName, opts = {}) {
+  const kind = extractKindFor(mimeType, fileName);
+  if (kind === null) return null;
+  const select = opts.parts === void 0 ? void 0 : parsePartSpec(opts.parts);
+  let extracted;
+  switch (kind) {
+    case "xlsx":
+      extracted = await extractXlsx(bytes, { select });
+      break;
+    case "csv":
+      extracted = extractDelimited(decodeText(bytes), fileName, ",");
+      break;
+    case "tsv":
+      extracted = extractDelimited(decodeText(bytes), fileName, "	");
+      break;
+    case "docx":
+      extracted = await extractDocx(bytes);
+      break;
+    case "pptx":
+      extracted = await extractPptx(bytes, { select });
+      break;
+    case "pdf":
+      extracted = await extractPdf(bytes, { select });
+      break;
+    case "text":
+      extracted = { kind: "text", text: decodeText(bytes) };
+      break;
+  }
+  return applyCharBudget(extracted, opts.maxChars ?? DEFAULT_MAX_CHARS);
+}
+
 // src/tools/attachments.ts
 import { readFileSync, statSync, mkdirSync, writeFileSync } from "node:fs";
 import { basename, dirname as dirname2, extname } from "node:path";
@@ -39555,6 +40458,65 @@ var NodeAttachmentIO = class {
   }
 };
 
+// src/tools/delivery.ts
+async function tryExtract(bytes, mimeType, fileName, opts) {
+  try {
+    const extracted = await extractAttachment(bytes, mimeType, fileName, {
+      maxChars: opts.maxChars,
+      parts: opts.parts
+    });
+    if (!extracted) {
+      return { reason: `no text extractor for ${mimeType} (${fileName})` };
+    }
+    return { extracted, truncated: extracted.truncated ?? false };
+  } catch (err) {
+    return { reason: `extraction failed: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+async function buildInlineDelivery(input) {
+  const { fileId, fileName, mimeType, bytes, forcedInline, options } = input;
+  const meta3 = {
+    fileId,
+    fileName,
+    mimeType,
+    sizeBytes: bytes.length,
+    mode: "inline"
+  };
+  if (forcedInline) meta3.forcedInline = true;
+  const block = () => ({ type: "text", text: JSON.stringify(meta3, null, 2) });
+  if (isHostRenderableImage(mimeType)) {
+    meta3.deliveredVia = "image";
+    return { content: [block(), { type: "image", data: bytes.toString("base64"), mimeType }] };
+  }
+  const attempts = [];
+  if (options.extract === false) {
+    attempts.push("extraction skipped (extract:false)");
+  } else {
+    const outcome = await tryExtract(bytes, mimeType, fileName, options);
+    if (outcome.extracted) {
+      meta3.deliveredVia = "extracted";
+      meta3.extracted = outcome.extracted;
+      meta3.truncated = outcome.truncated;
+      meta3.note = "Content extracted from the file. Pass extract:false to get the raw bytes instead.";
+      return { content: [block()] };
+    }
+    attempts.push(outcome.reason ?? "extraction produced no content");
+  }
+  meta3.deliveredVia = "blob";
+  meta3.deliveryAttempts = attempts;
+  meta3.note = "Returned as raw bytes. Some hosts cannot render an embedded resource of this type; if it came back unreadable, the file has no text extractor here (see deliveryAttempts).";
+  return {
+    content: [block(), {
+      type: "resource",
+      resource: {
+        uri: `ofw://attachment/${fileId}/${encodeURIComponent(fileName)}`,
+        mimeType,
+        blob: bytes.toString("base64")
+      }
+    }]
+  };
+}
+
 // src/tools/messages.ts
 import { basename as basename2, join as join5 } from "node:path";
 var DateSchema = external_exports.looseObject({ dateTime: external_exports.string() });
@@ -39570,7 +40532,9 @@ var SavedDraftDetailSchema = external_exports.looseObject({
   body: external_exports.string().optional(),
   date: DateSchema.optional(),
   replyToId: external_exports.number().nullable().optional(),
-  recipients: external_exports.array(ApiRecipientSchema).optional()
+  recipients: external_exports.array(ApiRecipientSchema).optional(),
+  // Read to audit whether requested myFileIDs actually attached (Defect 3).
+  files: external_exports.array(external_exports.number()).optional()
 });
 var MessageDetailSchema = external_exports.looseObject({
   id: external_exports.number(),
@@ -39622,6 +40586,20 @@ async function draftsFreshness(cache) {
   const cacheStatus = completed === "fresh" && freshness.staleness === "fresh" ? "fresh" : "unverified";
   return { freshness, serverConfirmed: cacheStatus === "fresh", cacheStatus };
 }
+function markReadVerdict(cached2, requested) {
+  const ceiling = getAllowMarkRead();
+  if (ceiling && (requested ?? true)) return null;
+  const wouldStamp = cached2 === null || cached2.folder === "inbox" && !deriveRead(cached2);
+  if (!wouldStamp) return null;
+  const because = ceiling ? "you passed allowMarkRead:false" : "this server runs with OFW_ALLOW_MARK_READ=false";
+  return jsonErrorResponse({
+    error: "MARK_READ_BLOCKED",
+    messageId: cached2?.id ?? null,
+    reason: cached2 === null ? "This id is not in the cache, so whether reading it would mark it read is unknowable without making the request that would." : "This is an unread inbox message; fetching its body would mark it read on OurFamilyWizard.",
+    note: `Refused because ${because}. Reading a message for the first time stamps a "First Viewed" timestamp that your co-parent can see and that forms part of the record \u2014 it cannot be undone. To read it anyway, call again with allowMarkRead:true${ceiling ? "" : " (which this deployment does not permit \u2014 clear OFW_ALLOW_MARK_READ to re-enable)"}.`,
+    ...cached2 === null ? { hint: "Run ofw_sync_messages first: it walks list pages, not bodies, so it can tell you what this id is without stamping anything." } : { subject: cached2.subject, fromUser: cached2.fromUser, sentAt: cached2.sentAt }
+  });
+}
 function registerMessageTools(server, client2, cacheProvider, attachmentIO) {
   const writeMode = getWriteMode();
   const allowSend = writeMode === "all";
@@ -39680,10 +40658,11 @@ function registerMessageTools(server, client2, cacheProvider, attachmentIO) {
     return jsonResponse(payload);
   });
   server.registerTool("ofw_get_message", {
-    description: 'Get a single OurFamilyWizard message OR draft by ID. Reads from local cache when available; otherwise fetches from OFW (which will mark unread inbox messages as read on OFW). For ids that match a draft (in the drafts cache), the response carries folder="drafts" and the body/subject/recipients reflect the drafts cache (which ofw_sync_messages keeps fresh) \u2014 drafts have no `fromUser`, and `sentAt`/`fetchedBodyAt` mirror the draft\'s `modifiedAt`. For inbox/sent messages, folder is "inbox" or "sent" as before.',
+    description: 'Get a single OurFamilyWizard message OR draft by ID. Reads from local cache when available; otherwise fetches from OFW \u2014 and for an UNREAD INBOX message that fetch marks it read and stamps a "First Viewed" time the co-parent can see, which is part of the record and cannot be undone. Pass allowMarkRead:false to refuse such a fetch instead (cached bodies, sent messages and already-read messages are unaffected, because none of them stamp anything). For ids that match a draft (in the drafts cache), the response carries folder="drafts" and the body/subject/recipients reflect the drafts cache (which ofw_sync_messages keeps fresh) \u2014 drafts have no `fromUser`, and `sentAt`/`fetchedBodyAt` mirror the draft\'s `modifiedAt`. For inbox/sent messages, folder is "inbox" or "sent" as before.',
     annotations: { readOnlyHint: false },
     inputSchema: {
-      messageId: external_exports.string().describe("Message ID (also accepts draft IDs \u2014 drafts are routed via the drafts cache)")
+      messageId: external_exports.string().describe("Message ID (also accepts draft IDs \u2014 drafts are routed via the drafts cache)"),
+      allowMarkRead: external_exports.boolean().describe("Default true (the long-standing behaviour). Set false to refuse a fetch that would mark an unread INBOX message as READ on OurFamilyWizard \u2014 an irreversible, co-parent-visible change to the record. Reads that cannot stamp anything (a cached body, a sent message, an already-read message) still succeed. The server-wide OFW_ALLOW_MARK_READ=false is a ceiling this argument cannot raise.").optional()
     }
   }, async (args) => {
     const id = Number(args.messageId);
@@ -39756,6 +40735,8 @@ function registerMessageTools(server, client2, cacheProvider, attachmentIO) {
       const freshness2 = await buildFreshness(cache, { source: "cache", folders: [row2.folder] });
       return jsonResponse({ ...withReadState(row2), attachments: attachments2, freshness: freshness2 });
     }
+    const markReadCheck = markReadVerdict(cached2, args.allowMarkRead);
+    if (markReadCheck !== null) return markReadCheck;
     const detail = parseLenient(
       MessageDetailSchema,
       await client2.request("GET", `/pub/v3/messages/${encodeURIComponent(args.messageId)}`),
@@ -39935,7 +40916,10 @@ ${text}` : text);
       };
     }
     const verdict = checkDraftFreshness({ server: server2, cached: cached2, expectedRevision });
-    if (verdict.verdict === "FRESH") return { ok: true, note: null };
+    if (verdict.verdict === "FRESH") {
+      const note = verdict.metadataOnly ? `NOTE: draft ${draftId} was treated as current for this ${action}. Since you read it, OurFamilyWizard normalized connector-authored metadata (${verdict.changedFields.join(", ")}); the subject, body and recipients are unchanged, so this is not a conflict.` : null;
+      return { ok: true, note };
+    }
     if (force) {
       console.error(`[ofw-mcp] WARNING: force:true overrode a ${verdict.verdict} verdict on draft ${draftId} (${action}). ${verdict.reason}`);
       const echoed = server2 === null ? "The draft no longer existed on OurFamilyWizard." : `The server version that was overwritten is preserved below under "overwrittenServerDraft".`;
@@ -39995,7 +40979,7 @@ ${JSON.stringify(
     return jsonResponse(payload);
   });
   if (allowDrafts) server.registerTool("ofw_save_draft", {
-    description: "Save a message as a draft in OurFamilyWizard. Recipients are optional. Pass messageId to replace an existing draft \u2014 note that under the hood this creates a NEW draft and deletes the old one (OFW's update-in-place endpoint silently no-ops while echoing the posted body, so we don't use it); the response.id will be the NEW id, not the messageId you passed, and the change is documented in a transparency NOTE in the response. If replyToId is provided, the cache may rewrite it to the latest reply in the thread (note included in response). Attach files by passing their fileIds (from ofw_upload_attachment) in myFileIDs. After saving, the tool re-fetches the draft from OFW to populate the local cache from authoritative server state. SAFETY: because replacing DESTROYS the old draft rather than merging, passing messageId first re-reads that draft from OFW and REFUSES the write if it changed since you read it (drafts edited in the OFW web app do not bump any timestamp, so the local cache can be silently behind). The refusal returns the current server body under serverBody \u2014 merge your edit into it and retry with expectedRevision.",
+    description: "Save a message as a draft in OurFamilyWizard. Recipients are optional. Pass messageId to replace an existing draft \u2014 note that under the hood this creates a NEW draft and deletes the old one (OFW's update-in-place endpoint silently no-ops while echoing the posted body, so we don't use it); the response.id will be the NEW id, not the messageId you passed, and the change is documented in a transparency NOTE in the response that also lists which fields (subject/body/recipients/replyToId/attachments) were carried over. If replyToId is provided, the cache may rewrite it to the latest reply in the thread (note included in response). Attach files by passing their fileIds (from ofw_upload_attachment) in myFileIDs. After saving, the tool re-fetches the draft from OFW to populate the local cache from authoritative server state, and the returned `revision` reflects that authoritative state (so it will match on your next edit). FIELD PRESERVATION: the response echoes the effective threading (replyToId/inReplyTo) and, whenever OFW did not carry over a requested replyToId, recipient or attachment, a `warnings[]` entry naming what was dropped \u2014 never a silent null. SAFETY: because replacing DESTROYS the old draft rather than merging, passing messageId first re-reads that draft from OFW and REFUSES the write if its subject/body/recipients changed since you read it (drafts edited in the OFW web app do not bump any timestamp, so the local cache can be silently behind). A pure replyToId normalization by OFW is NOT treated as a conflict. The refusal returns the current server body under serverBody \u2014 merge your edit into it and retry with expectedRevision.",
     annotations: { readOnlyHint: false },
     inputSchema: {
       subject: external_exports.string().describe("Message subject"),
@@ -40050,32 +41034,68 @@ ${JSON.stringify(
     let replaceNote = null;
     let verifyNote = null;
     let newRevision = null;
+    const warnings = [];
     if (newId !== null) {
       verifyNote = verifyWriteLanded("draft", { subject: args.subject, body: args.body }, detail);
+      const effectiveReplyTo = detail.replyToId ?? null;
+      const storedRecipients = mapRecipients(detail.recipients);
       persisted = {
         id: newId,
         subject: detail.subject ?? args.subject,
         body: detail.body ?? "",
-        recipients: mapRecipients(detail.recipients),
-        replyToId: detail.replyToId ?? resolvedReplyTo,
+        recipients: storedRecipients,
+        replyToId: effectiveReplyTo,
         modifiedAt: detail.date?.dateTime ?? (/* @__PURE__ */ new Date()).toISOString(),
         listData: detail
       };
       await cache.upsertDraft(persisted);
       newRevision = draftRevision(persisted);
+      if (resolvedReplyTo !== null && effectiveReplyTo !== resolvedReplyTo) {
+        const rewrittenFrom = requestedReplyTo !== resolvedReplyTo ? ` (rewritten from ${requestedReplyTo})` : "";
+        const outcome = effectiveReplyTo === null ? "OurFamilyWizard did not thread this draft (its inReplyTo/showContext will be empty). The subject and body were saved; only the reply linkage was dropped." : `OurFamilyWizard re-targeted the reply to message ${effectiveReplyTo} instead. The draft IS threaded \u2014 to that message, not the one requested \u2014 and the inReplyTo in this response reflects where it actually landed.`;
+        warnings.push(
+          `replyToId was requested as ${resolvedReplyTo}${rewrittenFrom} but the saved draft came back with replyToId ${effectiveReplyTo === null ? "null" : effectiveReplyTo} \u2014 ${outcome} If threading matters, verify on ourfamilywizard.com.`
+        );
+      }
+      if (args.recipientIds !== void 0 && Array.isArray(detail.recipients)) {
+        const requested = [...new Set(args.recipientIds)].sort((a, b) => a - b);
+        const stored = [...new Set(storedRecipients.map((r) => r.userId))].sort((a, b) => a - b);
+        if (requested.join(",") !== stored.join(",")) {
+          warnings.push(
+            `recipientIds were requested as [${requested.join(", ")}] but the saved draft has [${stored.join(", ")}]. Verify the recipients on ourfamilywizard.com.`
+          );
+        }
+      }
+      if (myFileIDs.length > 0 && Array.isArray(detail.files)) {
+        const storedFiles = new Set(detail.files);
+        const missing = myFileIDs.filter((id) => !storedFiles.has(id));
+        if (missing.length > 0) {
+          warnings.push(
+            `Attachment fileId(s) ${missing.join(", ")} were requested in myFileIDs but are not attached to the saved draft. Re-upload or re-attach if needed.`
+          );
+        }
+      }
       if (args.messageId !== void 0 && args.messageId !== newId) {
         try {
           await deleteOFWMessages(client2, [args.messageId]);
           await cache.deleteDraft(args.messageId);
-          replaceNote = `NOTE: ofw_save_draft replaced draft ${args.messageId} via create-then-delete. The new draft id is ${newId}; the old draft has been deleted. (OFW's update-in-place endpoint silently no-ops on subsequent updates, so we never use it. If you cached the old id anywhere, replace it with the new one.)`;
+          replaceNote = `NOTE: ofw_save_draft replaced draft ${args.messageId} via create-then-delete. The new draft id is ${newId}; the old draft has been deleted. (OFW's update-in-place endpoint silently no-ops on subsequent updates, so we never use it. If you cached the old id anywhere, replace it with the new one.) Fields carried over to the new draft: subject, body, recipients (${persisted.recipients.length}), replyToId (${persisted.replyToId === null ? "none" : persisted.replyToId}), attachments (${myFileIDs.length}).${warnings.length > 0 ? " See warnings above for any field OurFamilyWizard did not carry over." : ""}`;
         } catch (e) {
           replaceNote = `WARNING: New draft ${newId} was created successfully, but the old draft ${args.messageId} could NOT be deleted: ${e.message}. BOTH drafts now exist on OurFamilyWizard and nothing was lost. Verify ${newId} reads correctly, then remove ${args.messageId} with ofw_delete_draft.`;
         }
       }
     }
-    const responseObj = persisted !== null ? { ...persisted, revision: newRevision, cacheStatus: "fresh", serverConfirmed: true } : raw;
+    const responseObj = persisted !== null ? {
+      ...persisted,
+      inReplyTo: persisted.replyToId,
+      revision: newRevision,
+      cacheStatus: "fresh",
+      serverConfirmed: true,
+      ...warnings.length > 0 ? { warnings } : {}
+    } : raw;
     const text = responseObj ? JSON.stringify(responseObj, null, 2) : "Draft saved.";
-    const notes = [forceNote, rewriteNote, verifyNote, replaceNote].filter((n) => n !== null).join("\n\n");
+    const warnNote = warnings.length > 0 ? `WARNING: ${warnings.join("\n\n")}` : null;
+    const notes = [forceNote, rewriteNote, verifyNote, warnNote, replaceNote].filter((n) => n !== null).join("\n\n");
     return textResponse(notes ? `${notes}
 
 ${text}` : text);
@@ -40183,13 +41203,16 @@ ${text}` : text);
     });
   });
   server.registerTool("ofw_download_attachment", {
-    description: 'Download an OFW message attachment by fileId. By default, bytes are saved to disk (~/Downloads/ofw-mcp/) and the response carries the absolute path, mime type, and size for the caller to read back. Pass inline:true to skip disk entirely and return the bytes as MCP content blocks \u2014 host-renderable images (PNG/JPEG/GIF/WEBP) come back as ImageContent (the model sees them directly); every other file comes back as an EmbeddedResource blob carrying the bytes. Reported mime types are always normalized to a bare media type (no charset/name parameters). Use inline for small files where you want the model to read content immediately and the host is sandboxed; use disk for large files or when you want a persistent local copy. The default for `inline` can be flipped server-side via the OFW_INLINE_ATTACHMENTS env var (set to "true" to make inline the default). On a hosted deployment with no filesystem, disk mode is unavailable, so inline is forced (the response is marked forcedInline:true) rather than failing. fileId comes from attachments[].fileId on ofw_get_message. Override disk destination with OFW_ATTACHMENTS_DIR or saveTo. Re-downloading to the same path is a no-op (disk mode only).',
+    description: "Download an OFW message attachment by fileId and return content you can actually read. Inline delivery walks a ladder and returns the first rung that works: (1) host-renderable images (PNG/JPEG/GIF/WEBP) come back as ImageContent; (2) .xlsx/.csv/.tsv, .pdf, .docx, .pptx and text files come back as EXTRACTED CONTENT \u2014 per-sheet CSV, per-page/slide text, document text \u2014 in the response JSON under `extracted`; (3) anything else comes back as an EmbeddedResource blob of the raw bytes. The meta block names the rung as `deliveredVia` and, when it falls through to bytes, lists what was tried in `deliveryAttempts`. Reported mime types are always normalized to a bare media type (no charset/name parameters). In disk mode the bytes are saved to ~/Downloads/ofw-mcp/ and the response carries the absolute path; pass extract:true to ALSO get the extracted content in that response. The default for `inline` can be flipped server-side via the OFW_INLINE_ATTACHMENTS env var. On a hosted deployment with no filesystem, disk mode is unavailable, so inline is forced (forcedInline:true) rather than failing \u2014 a saveTo path never costs you the content. fileId comes from attachments[].fileId on ofw_get_message. Override disk destination with OFW_ATTACHMENTS_DIR or saveTo. Re-downloading to the same path is a no-op (disk mode only).",
     annotations: { readOnlyHint: false },
     inputSchema: {
       fileId: external_exports.number().describe("Attachment file id (from ofw_get_message \u2192 attachments[].fileId)"),
-      inline: external_exports.boolean().describe("If true, return bytes inline as MCP content (ImageContent for host-renderable images, embedded resource blob otherwise) and skip the disk write. If false, write to disk and return the path \u2014 except on a hosted deployment with no filesystem, where inline is forced (forcedInline:true) so the bytes are still returned. If omitted, falls back to the OFW_INLINE_ATTACHMENTS env var (default: false = disk).").optional(),
+      inline: external_exports.boolean().describe("If true, return content inline as MCP content blocks and skip the disk write. If false, write to disk and return the path \u2014 except on a hosted deployment with no filesystem, where inline is forced (forcedInline:true) so the content is still returned. If omitted, falls back to the OFW_INLINE_ATTACHMENTS env var (default: false = disk).").optional(),
       saveTo: external_exports.string().describe("Absolute path or directory to write to. If a directory, the OFW filename is used. Default: ~/Downloads/ofw-mcp/<fileId>-<filename>. Ignored when inline is in effect.").optional(),
-      force: external_exports.boolean().describe("Re-download even if already on disk. Default false. Ignored when inline:true (inline always fetches fresh bytes, or reuses an on-disk copy if present).").optional()
+      force: external_exports.boolean().describe("Re-download even if already on disk. Default false. Ignored when inline:true (inline always fetches fresh bytes, or reuses an on-disk copy if present).").optional(),
+      extract: external_exports.boolean().describe("Whether to extract readable content from the file. Default: on for inline delivery of any non-image type, off in disk mode. Set false to get the raw bytes inline instead of extracted text (e.g. to hash or re-upload the file); set true in disk mode to get both the saved path and the extracted content.").optional(),
+      maxChars: external_exports.number().int().min(500).max(5e5).describe("Ceiling on extracted characters (default 50000). Over it, content is clipped on a row/line boundary, `truncated` is set, and anything dropped whole is listed in `extracted.omitted`.").optional(),
+      parts: external_exports.string().describe('Which sheets / slides / pages to extract, e.g. "1-3,5" (1-based positions) or a sheet name like "2026". A bare number matches either a position or a name. Omit for everything. Unselected parts are listed in `extracted.omitted`.').optional()
     }
   }, async (args) => {
     const fileId = args.fileId;
@@ -40197,6 +41220,7 @@ ${text}` : text);
     const requestedInline = args.inline ?? getDefaultInlineAttachments();
     const inline = requestedInline || !attachmentIO.supportsDisk;
     const forcedInline = inline && !requestedInline;
+    const deliveryOptions = { extract: args.extract, maxChars: args.maxChars, parts: args.parts };
     let cached2 = await cache.getAttachment(fileId);
     if (!cached2) {
       await fetchAttachmentMeta(client2, fileId, 0, cache);
@@ -40216,25 +41240,15 @@ ${text}` : text);
         headerMime = response2.contentType ?? cached2.mimeType;
         fileName2 = response2.suggestedFileName ?? cached2.fileName;
       }
-      const mimeType = resolveDownloadMime(bytes, headerMime, fileName2);
-      const base643 = bytes.toString("base64");
-      const meta3 = {
+      const mimeType2 = resolveDownloadMime(bytes, headerMime, fileName2);
+      return await buildInlineDelivery({
         fileId,
         fileName: fileName2,
-        mimeType,
-        sizeBytes: bytes.length,
-        mode: "inline"
-      };
-      if (forcedInline) meta3.forcedInline = true;
-      const metaBlock = { type: "text", text: JSON.stringify(meta3, null, 2) };
-      if (isHostRenderableImage(mimeType)) {
-        return { content: [metaBlock, { type: "image", data: base643, mimeType }] };
-      }
-      return { content: [metaBlock, { type: "resource", resource: {
-        uri: `ofw://attachment/${fileId}/${encodeURIComponent(fileName2)}`,
-        mimeType,
-        blob: base643
-      } }] };
+        mimeType: mimeType2,
+        bytes,
+        forcedInline,
+        options: deliveryOptions
+      });
     }
     let dest;
     const safeName = basename2(cached2.fileName);
@@ -40245,29 +41259,34 @@ ${text}` : text);
     } else {
       dest = join5(getAttachmentsDir(), `${fileId}-${safeName}`);
     }
+    const extractOnDisk = args.extract === true;
     if (!args.force && cached2.downloadedPath === dest) {
-      return jsonResponse({
-        // No bytes on hand for the no-op case: normalize the cached/extension
-        // MIME (empty buffer sniffs nothing) so a stored `image/png;charset=…`
-        // still reports bare.
-        fileId,
-        path: dest,
-        mimeType: resolveDownloadMime(Buffer.alloc(0), cached2.mimeType, cached2.fileName),
-        sizeBytes: cached2.sizeBytes,
-        fileName: cached2.fileName,
-        note: "already downloaded"
-      });
+      const onDisk = extractOnDisk ? attachmentIO.readDownloaded(dest) : null;
+      if (!extractOnDisk || onDisk) {
+        const mimeType2 = resolveDownloadMime(onDisk ?? Buffer.alloc(0), cached2.mimeType, cached2.fileName);
+        return jsonResponse({
+          fileId,
+          path: dest,
+          mimeType: mimeType2,
+          sizeBytes: cached2.sizeBytes,
+          fileName: cached2.fileName,
+          note: "already downloaded",
+          ...onDisk ? await tryExtract(onDisk, mimeType2, cached2.fileName, deliveryOptions) : {}
+        });
+      }
     }
     const response = await client2.requestBinary("GET", `/pub/v1/myfiles/${fileId}/data`);
     attachmentIO.writeDownload(dest, response.body);
     await cache.markAttachmentDownloaded(fileId, dest);
     const fileName = response.suggestedFileName ?? cached2.fileName;
+    const mimeType = resolveDownloadMime(response.body, response.contentType ?? cached2.mimeType, fileName);
     return jsonResponse({
       fileId,
       path: dest,
-      mimeType: resolveDownloadMime(response.body, response.contentType ?? cached2.mimeType, fileName),
+      mimeType,
       sizeBytes: response.body.length,
-      fileName
+      fileName,
+      ...extractOnDisk ? await tryExtract(response.body, mimeType, fileName, deliveryOptions) : {}
     });
   });
   server.registerTool("ofw_sync_messages", {
@@ -40275,7 +41294,7 @@ ${text}` : text);
     annotations: { readOnlyHint: false },
     inputSchema: {
       folders: external_exports.array(external_exports.enum(["inbox", "sent", "drafts"])).min(1).describe("Folders to sync (default: all three). Must be non-empty if given \u2014 an empty list would sync nothing while reporting success.").optional(),
-      fetchUnreadBodies: external_exports.boolean().describe("If true, also fetch bodies for unread inbox messages (will mark them as read on OFW). Default false.").optional(),
+      fetchUnreadBodies: external_exports.boolean().describe('If true, also fetch bodies for unread inbox messages \u2014 which marks each one READ on OurFamilyWizard and stamps a co-parent-visible "First Viewed" time that cannot be undone. Defaults to the OFW_FETCH_UNREAD_BODIES env var (false unless set), and is forced off entirely when OFW_ALLOW_MARK_READ=false.').optional(),
       deep: external_exports.boolean().describe("If true, walk every OFW page until empty regardless of cache state. Use to backfill gaps. Default false.").optional(),
       maxRequests: external_exports.number().int().min(1).describe("Maximum OFW requests this single call may make before pausing. When hit, the response reports done:false \u2014 call again with the same arguments to continue. Omit to use the server default (OFW_SYNC_MAX_REQUESTS, or unbounded on local installs).").optional()
     }
@@ -40283,7 +41302,10 @@ ${text}` : text);
     const cache = cacheProvider();
     const result = await syncAll(client2, {
       folders: args.folders,
-      fetchUnreadBodies: args.fetchUnreadBodies,
+      // Default from OFW_FETCH_UNREAD_BODIES (false unless set), and capped by
+      // the OFW_ALLOW_MARK_READ ceiling — fetching those bodies is exactly what
+      // stamps a First Viewed time on every unread message it touches.
+      fetchUnreadBodies: getAllowMarkRead() && (args.fetchUnreadBodies ?? getFetchUnreadBodies()),
       deep: args.deep,
       maxRequests: args.maxRequests ?? getSyncMaxRequests()
     }, cache);
@@ -40303,7 +41325,7 @@ ${text}` : text);
     }
   }, async (args) => {
     const cache = cacheProvider();
-    const allowMarkRead = args.allowMarkRead ?? false;
+    const allowMarkRead = getAllowMarkRead() && (args.allowMarkRead ?? false);
     const requestedIds = args.messageIds ?? [];
     const ids = requestedIds.slice(0, MAX_FRESHNESS_IDS);
     const wantFolders = args.folders ?? (requestedIds.length > 0 ? [] : ["inbox", "sent", "drafts"]);
@@ -40322,7 +41344,8 @@ ${text}` : text);
         const serverCount = entry?.totalCount ?? entry?.messageCount ?? entry?.count ?? null;
         const cachedCount = folder === "drafts" ? (await cache.listDraftIds()).length : await cache.countMessages({ folder });
         const state = await cache.getSyncState(folder);
-        const historyComplete = state !== null && state.resumePage === null;
+        const neverSynced = state === null;
+        const historyComplete = !neverSynced && state.resumePage === null;
         const inSync = serverCount === null || !historyComplete ? null : serverCount === cachedCount;
         folders.push({
           folder,
@@ -40332,7 +41355,7 @@ ${text}` : text);
           historyComplete,
           lastVerifiedAt: await getFolderVerifiedAt(cache, folder),
           inSync,
-          ...inSync === null ? { note: serverCount === null ? "OFW did not report a count for this folder, so cached-vs-server cannot be compared. Use the per-id check instead." : "Older history is still being backfilled, so a lower cachedCount is expected and does not indicate drift." } : {}
+          ...inSync === null ? { note: serverCount === null ? "OFW did not report a count for this folder, so cached-vs-server cannot be compared. Use the per-id check instead." : neverSynced ? "This folder has never been synced, so the cache holds nothing to compare. Run ofw_sync_messages." : "Older history is still being backfilled, so a lower cachedCount is expected and does not indicate drift." } : {}
         });
       }
     }
@@ -41165,7 +42188,7 @@ var nodeCacheProvider = () => nodeCache ??= OFWCache.open(getCacheDbPath());
 var nodeAttachmentIO = new NodeAttachmentIO();
 await runMcp({
   name: "ofw",
-  version: "2.7.0",
+  version: "2.8.0",
   // x-release-please-version
   deps: client,
   tools: [