ask-marcel-office-cli 2.4.0 → 2.5.0

package/dist/index.js

@@ -16471,7 +16471,10 @@ var changesIn = (root, container, propsTag, changeTag, scope) => {
 };
 var extractFormatChanges = (root) => [
   ...changesIn(root, "w:r", "w:rPr", "w:rPrChange", "run"),
-  ...changesIn(root, "w:p", "w:pPr", "w:pPrChange", "paragraph")
+  ...changesIn(root, "w:p", "w:pPr", "w:pPrChange", "paragraph"),
+  ...changesIn(root, "w:tbl", "w:tblPr", "w:tblPrChange", "table"),
+  ...changesIn(root, "w:tr", "w:trPr", "w:trPrChange", "row"),
+  ...changesIn(root, "w:tc", "w:tcPr", "w:tcPrChange", "cell")
 ];
 var extractDocxMetadata = async (bytes) => {
   const zipR = await openOoxmlZip(bytes);
@@ -16950,6 +16953,8 @@ var renderTable2 = (tableKids) => {
 `);
 };
 var renderBlock = (node, tag) => {
+  if (tag === "text:tracked-changes")
+    return [];
   const kids = kidsOf(node, tag);
   if (tag === "text:h")
     return [renderHeading(node, kids)];
@@ -17730,7 +17735,7 @@ var meta3 = {
       name: "include-metadata",
       key: "includeMetadata",
       required: false,
-      description: "Pass `--include-metadata true` to surface the side-channel content the rendered body hides. For docx (`## DOCX metadata`): core/app/custom document properties, people registry, external hyperlinks, comments, tracked changes (a deletion sitting next to an insertion by the same author is reported once as a `replacement` carrying `before` + `after`; the halves that pair with nothing stay under `insertions` / `deletions`; `moves` joins the two ends of a moved span by its range name; `formatChanges` names which run or paragraph properties a reviewer altered. Table-structure revisions — cell insert / delete / merge, numbering and section properties — are still unreported), hidden-formatted text (w:vanish), field instructions (MERGEFIELD / HYPERLINK / DOCVARIABLE), bookmarks. For xlsx (`## Workbook metadata`): core/app/custom properties, external relationships, defined names, hidden / very-hidden sheets, legacy cell comments, threaded comments, persons. For pptx (`## PPTX metadata`): properties, external relationships, slide tags, comment authors + comments (legacy + modern), and per-slide title / speaker notes / hidden flag — returned as a standalone document since pptx has no convertible body (use `download-drive-item-as-pdf` for slide visuals). For OpenDocument (`.odt`/`.ods`/`.odp`, `## OpenDocument metadata`): Dublin Core + ODF properties, keywords, user-defined custom fields — appended after the converted body. Each OOXML family also covers its macro-enabled (`.docm` / `.xlsm` / `.pptm`) and template (`.dotx` / `.xltx` / `.potx`, etc.) variants, with a `### Macros (VBA)` section flagging an embedded `vbaProject.bin`. No-op on other sources.",
+      description: "Pass `--include-metadata true` to surface the side-channel content the rendered body hides. For docx (`## DOCX metadata`): core/app/custom document properties, people registry, external hyperlinks, comments, tracked changes (a deletion sitting next to an insertion by the same author is reported once as a `replacement` carrying `before` + `after`; the halves that pair with nothing stay under `insertions` / `deletions`; `moves` joins the two ends of a moved span by its range name; `formatChanges` names which run, paragraph, table, row or cell properties a reviewer altered, and a property whose values hang off child elements rather than its own attributes (`w:tblBorders` is the common one) is reported with its author and scope but names no property. Structural revisions — cell insert / delete / merge, numbering and section properties — are still unreported), hidden-formatted text (w:vanish), field instructions (MERGEFIELD / HYPERLINK / DOCVARIABLE), bookmarks. For xlsx (`## Workbook metadata`): core/app/custom properties, external relationships, defined names, hidden / very-hidden sheets, legacy cell comments, threaded comments, persons. For pptx (`## PPTX metadata`): properties, external relationships, slide tags, comment authors + comments (legacy + modern), and per-slide title / speaker notes / hidden flag — returned as a standalone document since pptx has no convertible body (use `download-drive-item-as-pdf` for slide visuals). For OpenDocument (`.odt`/`.ods`/`.odp`, `## OpenDocument metadata`): Dublin Core + ODF properties, keywords, user-defined custom fields — appended after the converted body. Each OOXML family also covers its macro-enabled (`.docm` / `.xlsm` / `.pptm`) and template (`.dotx` / `.xltx` / `.potx`, etc.) variants, with a `### Macros (VBA)` section flagging an embedded `vbaProject.bin`. No-op on other sources.",
       argumentHint: { kind: "magicValue", values: ["true", "false"] }
     },
     keepQuotedOption,
@@ -19392,9 +19397,12 @@ __export(exports_convert_mail_to_markdown, {
   attachmentsListSchema: () => attachmentsListSchema,
   execute: () => execute18,
   fetchInlineImageBytes: () => fetchInlineImageBytes,
+  formatAddress: () => formatAddress2,
   formatBytes: () => formatBytes,
   isInlineImage: () => isInlineImage,
   meta: () => meta20,
+  nonEmpty: () => nonEmpty,
+  renderMessageAsMarkdown: () => renderMessageAsMarkdown,
   schema: () => schema18
 });
 var schema18 = exports_external.object({
@@ -19405,6 +19413,7 @@ var schema18 = exports_external.object({
 var INLINE_IMAGE_SIZE_LIMIT_BYTES = 2000000;
 var ATTACHMENT_METADATA_SELECT = "$select=id,name,contentType,size,isInline,microsoft.graph.fileAttachment/contentId";
 var nonEmpty = (v) => typeof v === "string" && v !== "";
+var referencesCidImage = (html) => /\bsrc\s*=\s*["']cid:/i.test(html);
 var formatAddress2 = (a) => {
   if (!nonEmpty(a?.address))
     return;
@@ -19453,12 +19462,12 @@ var formatBytes = (n) => {
   return `${(n / 1e6).toFixed(1)} MB`;
 };
 var isInlineImage = (a) => a.isInline === true && nonEmpty(a.contentType) && a.contentType.toLowerCase().startsWith("image/") && nonEmpty(a.contentId);
-var fetchInlineImageBytes = async (graph, messageId, meta20) => {
+var fetchInlineImageBytes = async (graph, resourcePath, meta20) => {
   if ((meta20.size ?? 0) > INLINE_IMAGE_SIZE_LIMIT_BYTES)
     return { meta: meta20, oversize: true };
   if (!nonEmpty(meta20.id))
     return { meta: meta20, oversize: false };
-  const fetched = await graph.get(`/me/messages/${messageId}/attachments/${meta20.id}`);
+  const fetched = await graph.get(`${resourcePath}/attachments/${meta20.id}`);
   if (!fetched.ok)
     return { meta: meta20, oversize: false };
   const body = fetched.value;
@@ -19480,7 +19489,7 @@ var renderOversizePlaceholders = (html, embeds) => {
   }
   return out;
 };
-var renderFileAttachmentsList = (attachments, includeInlineImages = false) => {
+var renderFileAttachmentsList = (attachments, includeInlineImages, fetchHint) => {
   const fileAttachments = attachments.filter((a) => (includeInlineImages || !isInlineImage(a)) && nonEmpty(a.name));
   if (fileAttachments.length === 0)
     return "";
@@ -19490,7 +19499,7 @@ var renderFileAttachmentsList = (attachments, includeInlineImages = false) => {
     const id = nonEmpty(a.id) ? `, id: ${a.id}` : "";
     return `- ${a.name ?? ""}${size}${type}${id})`;
   });
-  return ["**Attachments:**", ...items, "_Use `convert-mail-attachment-to-pdf` or `get-mail-attachment` with the attachment id to fetch._"].join(`
+  return ["**Attachments:**", ...items, fetchHint].join(`
 `);
 };
 var withoutTags = (body) => {
@@ -19504,37 +19513,32 @@ var removedSharePercent = (body, boundary) => {
     return 100;
   return Math.round((total - visibleLength(body.slice(0, boundary))) / total * 100);
 };
-var execute18 = async (graph, params) => {
-  const parsed = schema18.safeParse(params);
-  if (!parsed.success)
-    return err({ type: "validation_error", message: formatZodError(parsed.error) });
-  const { messageId } = parsed.data;
-  const embedInlineImagesEnabled = parsed.data.inlineImages === "true";
-  const keepQuoted = parsed.data.keepQuoted === "true";
-  const fetched = await graph.get(`/me/messages/${messageId}`);
+var renderMessageAsMarkdown = async (graph, resourcePath, options) => {
+  const { inlineImages: embedInlineImagesEnabled, keepQuoted } = options;
+  const fetched = await graph.get(resourcePath);
   if (!fetched.ok)
     return fetched;
   const m = fetched.value;
+  const rawHtml = m.body?.content ?? "";
   let attachments = [];
   let attachmentsListNote;
-  if (m.hasAttachments === true) {
-    const listed = await graph.get(`/me/messages/${messageId}/attachments?${ATTACHMENT_METADATA_SELECT}`);
+  if (m.hasAttachments === true || referencesCidImage(rawHtml)) {
+    const listed = await graph.get(`${resourcePath}/attachments?${ATTACHMENT_METADATA_SELECT}`);
     if (!listed.ok) {
       attachmentsListNote = `attachments-list fetch failed (${listed.error.type}: ${listed.error.message}) — markdown body returned without attachment metadata`;
     } else {
-      const parsed2 = attachmentsListSchema.safeParse(listed.value);
-      if (parsed2.success) {
-        attachments = parsed2.data.value ?? [];
+      const parsed = attachmentsListSchema.safeParse(listed.value);
+      if (parsed.success) {
+        attachments = parsed.data.value ?? [];
       } else {
-        attachmentsListNote = `attachments-list returned a malformed shape (${formatZodError(parsed2.error)}) — markdown body returned without attachment metadata`;
+        attachmentsListNote = `attachments-list returned a malformed shape (${formatZodError(parsed.error)}) — markdown body returned without attachment metadata`;
       }
     }
   }
   const inlineImageCandidates = embedInlineImagesEnabled ? attachments.filter(isInlineImage) : [];
-  const embedResults = await Promise.all(inlineImageCandidates.map((meta20) => fetchInlineImageBytes(graph, messageId, meta20)));
+  const embedResults = await Promise.all(inlineImageCandidates.map((meta20) => fetchInlineImageBytes(graph, resourcePath, meta20)));
   const inlineImages = embedResults.flatMap((r) => r.inline ? [r.inline] : []);
-  const headers = renderHeaders(m);
-  const rawHtml = m.body?.content ?? "";
+  const headers = options.renderHeaders(m);
   const withPlaceholders = renderOversizePlaceholders(rawHtml, embedResults);
   const embedded = inlineImages.length > 0 ? embedInlineImages(withPlaceholders, inlineImages) : withPlaceholders;
   const labelByContentId = new Map;
@@ -19560,7 +19564,7 @@ var execute18 = async (graph, params) => {
     quotedBoundary = findPlainTextQuoteBoundary(inlined);
     bodyMd = stripped.text;
   }
-  const fileList = renderFileAttachmentsList(attachments, !embedInlineImagesEnabled);
+  const fileList = renderFileAttachmentsList(attachments, !embedInlineImagesEnabled, options.attachmentHint);
   const text = [headers, bodyMd, fileList].filter((s) => s !== "").join(`
 
 `);
@@ -19578,8 +19582,20 @@ var execute18 = async (graph, params) => {
     envelope.note = notes.join("; ");
   return ok(envelope);
 };
+var MAIL_ATTACHMENT_HINT = "_Use `convert-mail-attachment-to-pdf` or `get-mail-attachment` with the attachment id to fetch._";
+var execute18 = async (graph, params) => {
+  const parsed = schema18.safeParse(params);
+  if (!parsed.success)
+    return err({ type: "validation_error", message: formatZodError(parsed.error) });
+  return renderMessageAsMarkdown(graph, `/me/messages/${parsed.data.messageId}`, {
+    inlineImages: parsed.data.inlineImages === "true",
+    keepQuoted: parsed.data.keepQuoted === "true",
+    attachmentHint: MAIL_ATTACHMENT_HINT,
+    renderHeaders
+  });
+};
 var meta20 = {
-  summary: "Render a single Outlook email as markdown — headers (`**Subject:**`, `**From:**`, `**To:**`, `**Cc:**` only when present, `**Date:**`), followed by the body run through turndown. By default NO image bytes are fetched: every inline `cid:` image renders as a readable `[inline image: <name>]` placeholder and the images surface in the file-attachments list, so the output stays close to the text size (an email whose 6 KB body carried 30 KB of signature-image base64 now ships at ~6 KB). Pass `--inline-images true` to embed inline images (`isInline:true` + `image/*` content-type, size ≤ 2 MB) as base64 `data:` URIs for self-contained output (non-image inline attachments are never embedded; oversize inline images keep a placeholder note; a cid whose per-image fetch fails degrades to the placeholder too). File attachments are always listed below the body by name + size + id; their bytes are NOT fetched here — call `convert-mail-attachment-to-pdf` or `get-mail-attachment` with the id when you actually need them. Staged-fetch design: one call for the body, one for the attachments-metadata list (only if `hasAttachments:true`), and with `--inline-images true` one per small inline image — replaces the old `?$expand=attachments` which timed out / truncated on messages with multi-MB attachments.",
+  summary: "Render a single Outlook email as markdown — headers (`**Subject:**`, `**From:**`, `**To:**`, `**Cc:**` only when present, `**Date:**`), followed by the body run through turndown. By default NO image bytes are fetched: every inline `cid:` image renders as a readable `[inline image: <name>]` placeholder and the images surface in the file-attachments list, so the output stays close to the text size (an email whose 6 KB body carried 30 KB of signature-image base64 now ships at ~6 KB). Pass `--inline-images true` to embed inline images (`isInline:true` + `image/*` content-type, size ≤ 2 MB) as base64 `data:` URIs for self-contained output (non-image inline attachments are never embedded; oversize inline images keep a placeholder note; a cid whose per-image fetch fails degrades to the placeholder too). File attachments are always listed below the body by name + size + id; their bytes are NOT fetched here — call `convert-mail-attachment-to-pdf` or `get-mail-attachment` with the id when you actually need them. Staged-fetch design: one call for the body, one for the attachments-metadata list (when `hasAttachments` is true or the body references a `cid:` image, since Graph reports false for inline-only mail), and with `--inline-images true` one per small inline image — replaces the old `?$expand=attachments` which timed out / truncated on messages with multi-MB attachments.",
   category: "mail",
   graphMethod: "GET",
   graphPathTemplate: "/me/messages/{message-id}",
@@ -19655,7 +19671,7 @@ var inlineSignatureImages = async (graph, messageId, block) => {
   if (!parsed.success)
     return { html: block, count: 0, note: "the inline-image list came back in an unreadable shape, so any cid: references are unresolved" };
   const referenced = (parsed.data.value ?? []).filter(isInlineImage).filter((a) => block.includes(`cid:${a.contentId}`));
-  const fetched = await Promise.all(referenced.map((meta21) => fetchInlineImageBytes(graph, messageId, meta21)));
+  const fetched = await Promise.all(referenced.map((meta21) => fetchInlineImageBytes(graph, `/me/messages/${messageId}`, meta21)));
   const embeddable = fetched.flatMap((f) => f.inline === undefined ? [] : [f.inline]);
   const skipped = fetched.filter((f) => f.inline === undefined);
   const html = embeddable.length > 0 ? embedInlineImages(block, embeddable) : block;
@@ -19664,7 +19680,7 @@ var inlineSignatureImages = async (graph, messageId, block) => {
   const named = skipped.map((f) => `${f.meta.name ?? "image"} (${formatBytes(f.meta.size ?? 0)})`).join(", ");
   return { html, count: embeddable.length, note: `${skipped.length} inline image${skipped.length === 1 ? "" : "s"} left as a cid: reference: ${named}` };
 };
-var referencesCidImage = (block) => /\bsrc\s*=\s*["']cid:/i.test(block);
+var referencesCidImage2 = (block) => /\bsrc\s*=\s*["']cid:/i.test(block);
 var noSignatureFound = (messageId, scanned) => {
   const plural = scanned === 1 ? "" : "s";
   const scanMessage = `No OWA signature block (\`<div id="Signature">\`) was found in the last ${scanned} sent message${plural}. Mail composed in Outlook desktop does not carry the marker, so a signature may exist without being findable this way - pass --message-id to pin a message you know was sent from Outlook on the web.`;
@@ -19714,7 +19730,7 @@ var execute19 = async (graph, params) => {
     const block = extractSignatureBlock(message.data.body.content);
     if (block === undefined)
       continue;
-    const inlined = referencesCidImage(block) ? await inlineSignatureImages(graph, id, block) : { html: block, count: 0 };
+    const inlined = referencesCidImage2(block) ? await inlineSignatureImages(graph, id, block) : { html: block, count: 0 };
     return ok(buildEnvelope(id, block, message.data.sentDateTime, inlined));
   }
   return err(noSignatureFound(messageId, candidates.value.length));
@@ -22287,6 +22303,7 @@ var meta87 = {
 // src/use-cases/commands/convert-mail-attachment-to-markdown.ts
 var exports_convert_mail_attachment_to_markdown = {};
 __export(exports_convert_mail_attachment_to_markdown, {
+  MAIL_HINTS: () => MAIL_HINTS,
   convertAttachmentToMarkdown: () => convertAttachmentToMarkdown,
   convertFetchedAttachment: () => convertFetchedAttachment,
   execute: () => execute86,
@@ -22421,7 +22438,7 @@ var MAIL_HINTS = {
   image: (ext) => `${ext} attachment is an image and cannot be converted to markdown. Use \`get-mail-attachment --message-id <id> --attachment-id <id>\` to fetch the bytes (returned base64-encoded) and feed them into a vision-capable model directly — that's the right shape for image content. (\`convert-mail-attachment-to-pdf\` is NOT a workaround: Graph's format=pdf rejects images with InputFormatNotSupported.)`,
   generic: (ext) => `${ext} attachment not supported by \`convert-mail-attachment-to-markdown\`. Use \`convert-mail-attachment-to-pdf\` — Graph \`?format=pdf\` accepts 38 input extensions.`
 };
-var convertFileAttachment = (attachment, opts) => bytesToMarkdown(base64ToBytes(attachment.contentBytes ?? ""), attachment.name ?? "unnamed", opts, MAIL_HINTS);
+var convertFileAttachment = (attachment, opts, hints) => bytesToMarkdown(base64ToBytes(attachment.contentBytes ?? ""), attachment.name ?? "unnamed", opts, hints);
 var convertReferenceAttachment = async (graph, attachment, opts) => {
   const sourceUrl = attachment.sourceUrl;
   if (typeof sourceUrl !== "string" || sourceUrl === "") {
@@ -22472,14 +22489,14 @@ var convertItemAttachment = (attachment) => {
       return err({ type: "api_error", status: 400, message: `unsupported embedded item type: ${innerType}` });
   }
 };
-var convertFetchedAttachment = (graph, a, opts) => {
+var convertFetchedAttachment = (graph, a, opts, hints) => {
   const odataType = a["@odata.type"];
   if (typeof odataType !== "string") {
     return err({ type: "api_error", status: 400, message: "attachment response missing @odata.type discriminator" });
   }
   switch (odataType) {
     case "#microsoft.graph.fileAttachment":
-      return convertFileAttachment(a, opts);
+      return convertFileAttachment(a, opts, hints);
     case "#microsoft.graph.referenceAttachment":
       return convertReferenceAttachment(graph, a, opts);
     case "#microsoft.graph.itemAttachment":
@@ -22488,21 +22505,18 @@ var convertFetchedAttachment = (graph, a, opts) => {
       return err({ type: "api_error", status: 400, message: `unsupported attachment type: ${odataType}` });
   }
 };
-var convertAttachmentToMarkdown = async (graph, attachmentPath, opts) => {
+var convertAttachmentToMarkdown = async (graph, attachmentPath, opts, hints) => {
   const fetched = await graph.get(attachmentPath);
   if (!fetched.ok)
     return fetched;
-  return convertFetchedAttachment(graph, fetched.value, opts);
+  return convertFetchedAttachment(graph, fetched.value, opts, hints);
 };
 var execute86 = async (graph, params) => {
   const parsed = schema86.safeParse(params);
   if (!parsed.success)
     return err({ type: "validation_error", message: formatZodError(parsed.error) });
   const { messageId, attachmentId } = parsed.data;
-  return convertAttachmentToMarkdown(graph, `/me/messages/${messageId}/attachments/${attachmentId}`, {
-    includeMetadata: parsed.data.includeMetadata === "true",
-    keepQuoted: parsed.data.keepQuoted === "true"
-  });
+  return convertAttachmentToMarkdown(graph, `/me/messages/${messageId}/attachments/${attachmentId}`, { includeMetadata: parsed.data.includeMetadata === "true", keepQuoted: parsed.data.keepQuoted === "true" }, MAIL_HINTS);
 };
 var meta88 = {
   summary: "Convert an Outlook mail attachment to markdown. Polymorphic on the attachment’s `@odata.type`: fileAttachment decodes the inline bytes and runs them through the local conversion pipeline (docx via mammoth, xlsx via sheetjs, csv as markdown table, odt/ods/odp via content.xml, pptx as per-slide text (titles + bullets + speaker notes inline), pdf via text-layer extraction (unpdf → text/plain), legacy .xls via sheetjs and legacy .doc via word-extractor (text only), an Outlook .msg attachment rendered to markdown — headers + body (quoted reply chain stripped unless `--keep-quoted true`; inline `cid:` images shown as placeholders) with its own attachments converted recursively — plus plain-text passthrough); referenceAttachment resolves via /shares/{token}/driveItem and routes through the same dispatcher; itemAttachment (embedded mail / event / contact) is rendered locally via dedicated renderers. For pptx layout / images, `convert-mail-attachment-to-pdf` + a vision model reads the rendered deck better. A scanned / image-only PDF (no text layer), legacy .ppt, and rtf/etc. point to the PDF sibling. Loop/Fluid/Whiteboard reference-attachments use Graph `?format=html` (the four inputs Microsoft documents).",
@@ -22621,11 +22635,7 @@ var nameByContentType = (a) => {
   const ext = Object.hasOwn(CONTENT_TYPE_EXTENSIONS, contentType) ? CONTENT_TYPE_EXTENSIONS[contentType] : undefined;
   if (ext === undefined)
     return a;
-  const name = typeof a["name"] === "string" ? a["name"] : "";
-  const dot = name.lastIndexOf(".");
-  if ((dot === -1 ? "" : name.slice(dot + 1).toLowerCase()) === ext)
-    return a;
-  return { ...a, name: `${dot === -1 ? name || "attachment" : name.slice(0, dot)}.${ext}` };
+  return { ...a, name: `attachment.${ext}` };
 };
 var execute87 = async (graph, params) => {
   const parsed = schema87.safeParse(params);
@@ -22645,7 +22655,7 @@ var execute87 = async (graph, params) => {
     }
     return convertZipArchive(base64ToBytes(contentBytes), { includeMetadata, keepQuoted });
   }
-  return convertFetchedAttachment(graph, nameByContentType(a), { includeMetadata, keepQuoted });
+  return convertFetchedAttachment(graph, nameByContentType(a), { includeMetadata, keepQuoted }, MAIL_HINTS);
 };
 var meta89 = {
   summary: "Read an Outlook mail attachment whatever it is — one command that auto-routes by file type, preferring the content-type when the filename extension is misleading (a real `.jpg` that is actually a spreadsheet still converts), so a caller never has to choose between the convert-mail-attachment-* siblings. A `.zip` fileAttachment is unpacked and every entry converted (mirrors `convert-mail-attachment-zip-to-markdown`, returning the `{ count, files }` envelope; legacy GBK/CP437 names decoded). Any other attachment — docx/xlsx/pptx/odt/ods/odp + macro/template variants → markdown, csv → table, pdf → text layer (with `pageCount`), legacy .xls/.doc extracted, an inner Outlook .msg rendered recursively (quoted chain stripped unless `--keep-quoted true`), plain text passed through, referenceAttachment resolved via `/shares`, and itemAttachment (embedded mail/event/contact) rendered — goes through the same dispatch as `convert-mail-attachment-to-markdown` (returning its `{ contentType, size, text }` envelope). Images, scanned/image-only PDFs, and legacy .ppt return an actionable 415 pointing at `convert-mail-attachment-to-pdf` + a vision model or `get-mail-attachment` for the raw bytes. Pass `--include-metadata true` to append Office side-channel metadata. Use the explicit `convert-mail-attachment-to-markdown` / `-to-pdf` / `-zip` siblings only when you need to force a specific output format.",
@@ -22944,6 +22954,12 @@ __export(exports_convert_calendar_event_attachment_to_markdown, {
   meta: () => meta93,
   schema: () => schema91
 });
+var CALENDAR_HINTS = {
+  pdfNoText: "pdf attachment has no extractable text layer — it looks scanned / image-only (only page images, no embedded text). Use `convert-calendar-event-attachment-to-pdf --output-path /tmp/file.pdf` to land the bytes on disk, then read the PDF with a vision-capable model, or run OCR.",
+  legacyPpt: "ppt (legacy PowerPoint 97-2003, OLE binary) cannot be converted to markdown — there is no pure-JS parser for the format. Use `convert-calendar-event-attachment-to-pdf --output-path /tmp/file.pdf` to render it, then read the PDF with a vision-capable model.",
+  image: (ext) => `${ext} attachment is an image and cannot be converted to markdown. Fetch the bytes with \`get-calendar-event --event-id <id> --expand attachments\`, which returns each attachment's base64 \`contentBytes\` inline, and feed them into a vision-capable model. (\`convert-calendar-event-attachment-to-pdf\` is NOT a workaround: Graph's format=pdf rejects images with InputFormatNotSupported.)`,
+  generic: (ext) => `${ext} attachment not supported by \`convert-calendar-event-attachment-to-markdown\`. Use \`convert-calendar-event-attachment-to-pdf\` — Graph \`?format=pdf\` accepts 38 input extensions.`
+};
 var schema91 = exports_external.object({
   eventId: exports_external.string().min(1),
   attachmentId: exports_external.string().min(1),
@@ -22955,10 +22971,7 @@ var execute91 = async (graph, params) => {
   if (!parsed.success)
     return err({ type: "validation_error", message: formatZodError(parsed.error) });
   const { eventId, attachmentId } = parsed.data;
-  return convertAttachmentToMarkdown(graph, `/me/events/${eventId}/attachments/${attachmentId}`, {
-    includeMetadata: parsed.data.includeMetadata === "true",
-    keepQuoted: parsed.data.keepQuoted === "true"
-  });
+  return convertAttachmentToMarkdown(graph, `/me/events/${eventId}/attachments/${attachmentId}`, { includeMetadata: parsed.data.includeMetadata === "true", keepQuoted: parsed.data.keepQuoted === "true" }, CALENDAR_HINTS);
 };
 var meta93 = {
   summary: "Convert an attachment on an Outlook calendar event to markdown. Polymorphic on the attachment’s `@odata.type` (shares the mail-attachment pipeline): fileAttachment decodes the inline bytes and runs them through the local conversion pipeline (docx via mammoth, xlsx via sheetjs, csv as markdown table, odt/ods/odp via content.xml, plus plain-text passthrough); referenceAttachment resolves via /shares/{token}/driveItem and routes through the same dispatcher; itemAttachment (embedded mail / event / contact) is rendered locally. For pptx decks attached to a meeting, `convert-calendar-event-attachment-to-pdf` preserves slide layout (a pptx here yields only its speaker notes / titles / comments via `## PPTX metadata` with `--include-metadata true`). For pdf/rtf/etc. also use the PDF sibling.",
@@ -26407,10 +26420,11 @@ __export(exports_list_group_conversations, {
   meta: () => meta164,
   schema: () => schema162
 });
+var HONOURED = ["top", "skip", "select", "orderby", "expand"];
 var baseSchema85 = exports_external.object({ groupId: exports_external.string().min(1) });
-var { execute: execute162, schema: schema162 } = buildListCommand((p) => `/groups/${p.groupId}/conversations`, baseSchema85);
+var { execute: execute162, schema: schema162 } = buildPickODataListCommand((p) => `/groups/${p.groupId}/conversations`, baseSchema85, HONOURED);
 var meta164 = {
-  summary: "List conversations in a unified (Microsoft 365) group inbox. Each conversation aggregates one or more threads. Only Microsoft 365 groups have a mailbox — security and distribution groups return `MailboxNotEnabledForRESTAPI`. Verify the group is unified before calling.",
+  summary: "List conversations in a unified (Microsoft 365) group inbox. Each conversation aggregates one or more threads. Only Microsoft 365 groups have a mailbox — security and distribution groups return `MailboxNotEnabledForRESTAPI`. Verify the group is unified before calling. Bodies live two levels down: `list-group-threads` then `list-group-thread-posts`, or `--expand 'threads($expand=posts)'` here to fetch conversations, threads and posts in one call.",
   category: "mail",
   graphMethod: "GET",
   graphPathTemplate: "/groups/{group-id}/conversations",
@@ -26422,7 +26436,7 @@ var meta164 = {
       required: true,
       description: "Azure AD group object ID for a unified (Microsoft 365) group."
     },
-    ...odataQueryOptions
+    ...pickODataOptions(HONOURED)
   ],
   example: "ask-marcel-office list-group-conversations --group-id 'a1b2c3d4-...'",
   responseShape: "collection of Microsoft Graph `conversation` resources under `value[]`",
@@ -26436,10 +26450,11 @@ __export(exports_list_group_threads, {
   meta: () => meta165,
   schema: () => schema163
 });
+var HONOURED2 = ["top", "skip", "select", "orderby", "expand"];
 var baseSchema86 = exports_external.object({ groupId: exports_external.string().min(1) });
-var { execute: execute163, schema: schema163 } = buildListCommand((p) => `/groups/${p.groupId}/threads`, baseSchema86);
+var { execute: execute163, schema: schema163 } = buildPickODataListCommand((p) => `/groups/${p.groupId}/threads`, baseSchema86, HONOURED2);
 var meta165 = {
-  summary: "List threads in a unified (Microsoft 365) group inbox. Threads are flatter than conversations — one per topic, useful when conversation-level grouping isn't needed. Only Microsoft 365 groups have a mailbox — security and distribution groups return `MailboxNotEnabledForRESTAPI`.",
+  summary: "List threads in a unified (Microsoft 365) group inbox. Threads are flatter than conversations — one per topic, useful when conversation-level grouping isn't needed. Only Microsoft 365 groups have a mailbox — security and distribution groups return `MailboxNotEnabledForRESTAPI`. Each thread carries only a truncated `preview` of its latest post: read the full posts with `list-group-thread-posts`, or pass `--expand posts` here to inline them.",
   category: "mail",
   graphMethod: "GET",
   graphPathTemplate: "/groups/{group-id}/threads",
@@ -26451,28 +26466,363 @@ var meta165 = {
       required: true,
       description: "Azure AD group object ID for a unified (Microsoft 365) group."
     },
-    ...odataQueryOptions
+    ...pickODataOptions(HONOURED2)
   ],
   example: "ask-marcel-office list-group-threads --group-id 'a1b2c3d4-...'",
   responseShape: "collection of Microsoft Graph `conversationThread` resources under `value[]`",
   pagination: true
 };
 
-// src/use-cases/commands/get-mail-message-mime.ts
-var exports_get_mail_message_mime = {};
-__export(exports_get_mail_message_mime, {
+// src/use-cases/commands/list-group-thread-posts.ts
+var exports_list_group_thread_posts = {};
+__export(exports_list_group_thread_posts, {
   execute: () => execute164,
   meta: () => meta166,
   schema: () => schema164
 });
-var schema164 = exports_external.object({ messageId: exports_external.string().min(1) });
-var execute164 = async (graph, params) => {
-  const parsed = schema164.safeParse(params);
+var baseSchema87 = exports_external.object({ groupId: exports_external.string().min(1), threadId: exports_external.string().min(1) });
+var { execute: execute164, schema: schema164 } = buildPickODataListCommand((p) => `/groups/${p.groupId}/threads/${p.threadId}/posts`, baseSchema87, ["select", "expand"]);
+var meta166 = {
+  summary: "List every post in one thread of a unified (Microsoft 365) group inbox: the full `post` resources with the HTML `body.content`, `from`, `sender`, `receivedDateTime` and `hasAttachments`, where `list-group-threads` stops at a truncated `preview`. Graph returns the whole thread in one call with no page cursor, and it silently ignores `$top`, `$skip` and `$orderby` while rejecting `$filter` (probed live 2026-09-03), so only `--select` and `--expand` are exposed; sort on `receivedDateTime` client-side if order matters. `sender` is the person who wrote the post and `from` is normally the group's own address. Render one post as markdown with `convert-group-post-to-markdown`. Access is membership-gated, not scope-gated: a group the signed-in user does not belong to answers `ErrorAccessDenied` even though `list-groups` lists it.",
+  category: "mail",
+  graphMethod: "GET",
+  graphPathTemplate: "/groups/{group-id}/threads/{thread-id}/posts",
+  graphDocsUrl: "https://learn.microsoft.com/en-us/graph/api/conversationthread-list-posts",
+  options: [
+    {
+      name: "group-id",
+      key: "groupId",
+      required: true,
+      description: "Azure AD group object ID for a unified (Microsoft 365) group the signed-in user belongs to."
+    },
+    {
+      name: "thread-id",
+      key: "threadId",
+      required: true,
+      description: "Conversation thread ID, the `id` of a `list-group-threads` entry (also inlined by `list-group-conversations --expand threads`)."
+    },
+    ...selectExpandOptions
+  ],
+  example: "ask-marcel-office list-group-thread-posts --group-id 'a1b2c3d4-...' --thread-id 'AAQkAD...'",
+  responseShape: "collection of Microsoft Graph `post` resources under `value[]`: `id`, `createdDateTime`, `lastModifiedDateTime`, `changeKey`, `categories`, `receivedDateTime`, `hasAttachments`, `body { contentType, content }`, `from`, `sender`. No `nextLink` is ever emitted. `hasAttachments` is false for a post whose only attachments are inline images. `--expand attachments` inlines every attachment of every post with its base64 `contentBytes`, so use it sparingly."
+};
+
+// src/use-cases/commands/get-group-post.ts
+var exports_get_group_post = {};
+__export(exports_get_group_post, {
+  execute: () => execute165,
+  meta: () => meta167,
+  schema: () => schema165
+});
+var baseSchema88 = exports_external.object({ groupId: exports_external.string().min(1), threadId: exports_external.string().min(1), postId: exports_external.string().min(1) });
+var { execute: execute165, schema: schema165 } = buildSelectableCommand((p) => `/groups/${p.groupId}/threads/${p.threadId}/posts/${p.postId}`, baseSchema88);
+var meta167 = {
+  summary: "Get a single post of a unified (Microsoft 365) group thread by ID, the sibling of `get-mail-message` for a group inbox: the full `post` resource including the HTML `body`. `--select` trims the projection. `--expand attachments` returns every attachment inline with its base64 `contentBytes`, which is convenient for a small post and the wrong shape for one carrying a multi-MB file: list them with `list-group-post-attachments` and fetch one with `get-group-post-attachment` instead. Post IDs come from `list-group-thread-posts`; use `convert-group-post-to-markdown` for a readable rendering.",
+  category: "mail",
+  graphMethod: "GET",
+  graphPathTemplate: "/groups/{group-id}/threads/{thread-id}/posts/{post-id}",
+  graphDocsUrl: "https://learn.microsoft.com/en-us/graph/api/post-get",
+  options: [
+    {
+      name: "group-id",
+      key: "groupId",
+      required: true,
+      description: "Azure AD group object ID for a unified (Microsoft 365) group the signed-in user belongs to."
+    },
+    {
+      name: "thread-id",
+      key: "threadId",
+      required: true,
+      description: "Conversation thread ID, the `id` of a `list-group-threads` entry."
+    },
+    {
+      name: "post-id",
+      key: "postId",
+      required: true,
+      description: "Post ID inside that thread. Returned by `list-group-thread-posts`."
+    },
+    ...selectExpandOptions
+  ],
+  example: "ask-marcel-office get-group-post --group-id 'a1b2c3d4-...' --thread-id 'AAQkAD...' --post-id 'AQMkAD...'",
+  responseShape: "single Microsoft Graph `post` resource: `id`, `createdDateTime`, `lastModifiedDateTime`, `changeKey`, `categories`, `receivedDateTime`, `hasAttachments`, `body { contentType, content }`, `from` (normally the group address), `sender` (the person who wrote it). With `--expand attachments`, an `attachments[]` array of `fileAttachment` / `itemAttachment` / `referenceAttachment` entries, file attachments carrying `contentBytes` inline."
+};
+
+// src/use-cases/commands/convert-group-post-to-markdown.ts
+var exports_convert_group_post_to_markdown = {};
+__export(exports_convert_group_post_to_markdown, {
+  execute: () => execute166,
+  meta: () => meta168,
+  schema: () => schema166
+});
+var schema166 = exports_external.object({
+  groupId: exports_external.string().min(1),
+  threadId: exports_external.string().min(1),
+  postId: exports_external.string().min(1),
+  inlineImages: exports_external.enum(["true", "false"]).optional(),
+  keepQuoted: exports_external.enum(["true", "false"]).optional()
+});
+var renderPostHeaders = (m) => {
+  const lines = [];
+  const from = formatAddress2(m.from?.emailAddress);
+  const author = formatAddress2(m.sender?.emailAddress) ?? from;
+  if (author !== undefined)
+    lines.push(from === undefined || from === author ? `**From:** ${author}` : `**From:** ${author} on behalf of ${from}`);
+  if (nonEmpty(m.receivedDateTime))
+    lines.push(`**Date:** ${m.receivedDateTime}`);
+  return lines.join(`
+`);
+};
+var POST_ATTACHMENT_HINT = "_Use `convert-group-post-attachment-to-markdown` or `get-group-post-attachment` with the attachment id to fetch._";
+var execute166 = async (graph, params) => {
+  const parsed = schema166.safeParse(params);
+  if (!parsed.success)
+    return err({ type: "validation_error", message: formatZodError(parsed.error) });
+  const { groupId, threadId, postId } = parsed.data;
+  return renderMessageAsMarkdown(graph, `/groups/${groupId}/threads/${threadId}/posts/${postId}`, {
+    inlineImages: parsed.data.inlineImages === "true",
+    keepQuoted: parsed.data.keepQuoted === "true",
+    attachmentHint: POST_ATTACHMENT_HINT,
+    renderHeaders: renderPostHeaders
+  });
+};
+var meta168 = {
+  summary: "Render one post of a unified (Microsoft 365) group thread as markdown, the way `convert-mail-to-markdown` renders an Outlook message: a `**From:**` line, a `**Date:**` line, then the HTML body through turndown with quoted reply chains stripped. A post arrives from the group's own address with the writer in `sender`, so the author line reads `Robin Chen <robin.chen@contoso.com> on behalf of Support <support@contoso.com>`. There is no subject line: the thread `topic` is the subject and lives on `list-group-threads`. By default no image bytes are fetched; inline `cid:` images render as `[inline image: <name>]` placeholders unless `--inline-images true`. File attachments are listed below the body by name, size and id and their bytes are never fetched here; read one with `convert-group-post-attachment-to-markdown` or fetch it with `get-group-post-attachment`. Same staged-fetch design as the mail command: one call for the post, one for the attachment list when `hasAttachments` is true or the body references a `cid:` image (Graph reports false for a post whose only attachments are inline), and with `--inline-images true` one per small inline image.",
+  category: "mail",
+  graphMethod: "GET",
+  graphPathTemplate: "/groups/{group-id}/threads/{thread-id}/posts/{post-id}",
+  graphDocsUrl: "https://learn.microsoft.com/en-us/graph/api/post-get",
+  options: [
+    {
+      name: "group-id",
+      key: "groupId",
+      required: true,
+      description: "Azure AD group object ID for a unified (Microsoft 365) group the signed-in user belongs to."
+    },
+    {
+      name: "thread-id",
+      key: "threadId",
+      required: true,
+      description: "Conversation thread ID, the `id` of a `list-group-threads` entry."
+    },
+    {
+      name: "post-id",
+      key: "postId",
+      required: true,
+      description: "Post ID inside that thread. Returned by `list-group-thread-posts`."
+    },
+    {
+      name: "inline-images",
+      key: "inlineImages",
+      required: false,
+      description: "Pass `--inline-images true` to fetch small inline images (≤ 2 MB, `image/*` only) and embed them as base64 `data:` URIs. Default is `false`: no per-image bytes fetch, and every inline `cid:` image renders as a `[inline image: <name>]` placeholder while still appearing in the attachments list. Same rule as `convert-mail-to-markdown`.",
+      argumentHint: { kind: "magicValue", values: ["true", "false"] }
+    },
+    {
+      name: "keep-quoted",
+      key: "keepQuoted",
+      required: false,
+      description: "Quoted reply chains and forwarded-message blocks are stripped by default and replaced with a single visible marker naming this flag; the `note` reports the share of the body text that went with them. Pass `--keep-quoted true` to preserve the full body. The markers recognised are the ones `convert-mail-to-markdown` documents.",
+      argumentHint: { kind: "magicValue", values: ["true", "false"] }
+    }
+  ],
+  example: "ask-marcel-office convert-group-post-to-markdown --group-id 'a1b2c3d4-...' --thread-id 'AAQkAD...' --post-id 'AQMkAD...'",
+  responseShape: '`{ contentType: "text/markdown", size, text, note? }`, the same envelope as `convert-mail-to-markdown`: headers, the turndown-rendered body and, when present, an attachments list. The optional `note` carries the attachments-list failure hint and/or the quoted-chain notice with the share of the body text it removed.',
+  producesBytes: true
+};
+
+// src/use-cases/commands/list-group-post-attachments.ts
+var exports_list_group_post_attachments = {};
+__export(exports_list_group_post_attachments, {
+  execute: () => execute167,
+  meta: () => meta169,
+  schema: () => schema167
+});
+var baseSchema89 = exports_external.object({ groupId: exports_external.string().min(1), threadId: exports_external.string().min(1), postId: exports_external.string().min(1) });
+var DEFAULT_SELECT7 = "id,name,contentType,size,isInline";
+var { execute: execute167, schema: schema167 } = buildPickODataListCommand((p) => `/groups/${p.groupId}/threads/${p.threadId}/posts/${p.postId}/attachments`, baseSchema89, ["select", "expand"], {
+  defaultSelect: DEFAULT_SELECT7
+});
+var meta169 = {
+  summary: "List the attachments (file, item, reference) on one post of a unified (Microsoft 365) group thread. Ships the slim default `--select=id,name,contentType,size,isInline` the mail and calendar siblings use, so a caller sees what is attached without pulling any bytes — the staged alternative to `get-group-post --expand attachments`, which inlines EVERY attachment at once and times out on a post carrying a multi-MB file. Graph returns the whole collection in one response and silently ignores `$top`, `$skip`, `$orderby` and `$filter` (probed live 2026-09-03), so only `--select` and `--expand` are exposed. A post whose only attachments are inline images reports `hasAttachments: false`, so call this whenever the body shows `cid:` references. Read one with `convert-group-post-attachment-to-markdown`, or fetch its bytes with `get-group-post-attachment`.",
+  category: "mail",
+  graphMethod: "GET",
+  graphPathTemplate: "/groups/{group-id}/threads/{thread-id}/posts/{post-id}/attachments",
+  graphDocsUrl: "https://learn.microsoft.com/en-us/graph/api/post-list-attachments",
+  options: [
+    {
+      name: "group-id",
+      key: "groupId",
+      required: true,
+      description: "Azure AD group object ID for a unified (Microsoft 365) group you belong to."
+    },
+    {
+      name: "thread-id",
+      key: "threadId",
+      required: true,
+      description: "Conversation thread ID, the `id` of a `list-group-threads` entry."
+    },
+    {
+      name: "post-id",
+      key: "postId",
+      required: true,
+      description: "Post ID inside that thread. Returned by `list-group-thread-posts`."
+    },
+    ...selectExpandOptions
+  ],
+  example: "ask-marcel-office list-group-post-attachments --group-id 'a1b2c3d4-...' --thread-id 'AAQkAD...' --post-id 'AQMkAD...'",
+  responseShape: "collection of Microsoft Graph `attachment` resources under `value[]` (slim metadata by default — see summary), with no page cursor. Graph always includes `@odata.type` and `@odata.mediaContentType` on every entry regardless of `--select`; that discriminator is what the converting sibling branches on. An inline image carries `isInline: true` and a `contentId` matching a `cid:` reference in the post body."
+};
+
+// src/use-cases/commands/get-group-post-attachment.ts
+var exports_get_group_post_attachment = {};
+__export(exports_get_group_post_attachment, {
+  execute: () => execute168,
+  meta: () => meta170,
+  schema: () => schema168
+});
+var schema168 = exports_external.object({ groupId: exports_external.string().min(1), threadId: exports_external.string().min(1), postId: exports_external.string().min(1), attachmentId: exports_external.string().min(1) }).extend(selectExpandSchema.shape);
+var execute168 = async (graph, params) => {
+  const parsed = schema168.safeParse(params);
+  if (!parsed.success)
+    return err({ type: "validation_error", message: formatZodError(parsed.error) });
+  const { groupId, threadId, postId, attachmentId } = parsed.data;
+  const path = appendOData(`/groups/${groupId}/threads/${threadId}/posts/${postId}/attachments/${attachmentId}`, parsed.data);
+  const result = await graph.get(path);
+  if (!result.ok)
+    return result;
+  const value = result.value;
+  const contentBytes = value["contentBytes"];
+  if (value["@odata.type"] === "#microsoft.graph.fileAttachment" && typeof contentBytes === "string") {
+    return ok({ ...value, base64: contentBytes });
+  }
+  return ok(value);
+};
+var meta170 = {
+  summary: "Get a single attachment on one post of a unified (Microsoft 365) group thread, the `get-mail-attachment` sibling for a group inbox. Prefer it over `get-group-post --expand attachments`, which expands every attachment at once. fileAttachments carry a `base64` mirror of `contentBytes` so the global output-path flag lands the bytes on disk in one call; with an output-path set both byte fields are stripped from stdout in favour of `savedTo`. Pass `--select id,name,contentType,size` for metadata only. This is also the route to an image attached to a post: fetch the bytes and feed them to a vision-capable model.",
+  category: "mail",
+  graphMethod: "GET",
+  graphPathTemplate: "/groups/{group-id}/threads/{thread-id}/posts/{post-id}/attachments/{attachment-id}",
+  graphDocsUrl: "https://learn.microsoft.com/en-us/graph/api/attachment-get",
+  options: [
+    {
+      name: "group-id",
+      key: "groupId",
+      required: true,
+      description: "Azure AD group object ID for a unified (Microsoft 365) group the signed-in user belongs to."
+    },
+    {
+      name: "thread-id",
+      key: "threadId",
+      required: true,
+      description: "Conversation thread ID, the `id` of a `list-group-threads` entry."
+    },
+    {
+      name: "post-id",
+      key: "postId",
+      required: true,
+      description: "Post ID inside that thread. Returned by `list-group-thread-posts`."
+    },
+    {
+      name: "attachment-id",
+      key: "attachmentId",
+      required: true,
+      description: "Attachment ID inside that post. Returned by `list-group-post-attachments`."
+    },
+    ...selectExpandOptions
+  ],
+  example: "ask-marcel-office get-group-post-attachment --group-id 'a1b2c3d4-...' --thread-id 'AAQkAD...' --post-id 'AQMkAD...' --attachment-id 'AAMkAD...'",
+  responseShape: "single Microsoft Graph `attachment` resource. fileAttachments include `contentBytes` (Graph) AND `base64` (CLI mirror) so `--output-path` works; with `--output-path` set, both byte fields are stripped from stdout and replaced by `savedTo`. itemAttachments and referenceAttachments are returned unchanged.",
+  producesBytes: true
+};
+
+// src/use-cases/commands/convert-group-post-attachment-to-markdown.ts
+var exports_convert_group_post_attachment_to_markdown = {};
+__export(exports_convert_group_post_attachment_to_markdown, {
+  execute: () => execute169,
+  meta: () => meta171,
+  schema: () => schema169
+});
+var POST_HINTS = {
+  pdfNoText: "pdf attachment has no extractable text layer — it looks scanned / image-only (only page images, no embedded text). Fetch the bytes with `get-group-post-attachment --output-path /tmp/file.pdf`, then read the PDF with a vision-capable model, or run OCR.",
+  legacyPpt: "ppt (legacy PowerPoint 97-2003, OLE binary) cannot be converted to markdown — there is no pure-JS parser for the format. Fetch the bytes with `get-group-post-attachment --output-path /tmp/deck.ppt` and convert them outside the CLI, or open the post in Outlook.",
+  image: (ext) => `${ext} attachment is an image and cannot be converted to markdown. Use \`get-group-post-attachment\` to fetch the bytes (returned base64-encoded) and feed them into a vision-capable model directly — that's the right shape for image content.`,
+  generic: (ext) => `${ext} attachment not supported by \`convert-group-post-attachment-to-markdown\`. Fetch the raw bytes with \`get-group-post-attachment\` (add \`--output-path\` to land them on disk) and handle the format outside the CLI.`
+};
+var schema169 = exports_external.object({
+  groupId: exports_external.string().min(1),
+  threadId: exports_external.string().min(1),
+  postId: exports_external.string().min(1),
+  attachmentId: exports_external.string().min(1),
+  includeMetadata: exports_external.enum(["true", "false"]).optional(),
+  keepQuoted: keepQuotedSchemaField
+});
+var execute169 = async (graph, params) => {
+  const parsed = schema169.safeParse(params);
+  if (!parsed.success)
+    return err({ type: "validation_error", message: formatZodError(parsed.error) });
+  const { groupId, threadId, postId, attachmentId } = parsed.data;
+  return convertAttachmentToMarkdown(graph, `/groups/${groupId}/threads/${threadId}/posts/${postId}/attachments/${attachmentId}`, { includeMetadata: parsed.data.includeMetadata === "true", keepQuoted: parsed.data.keepQuoted === "true" }, POST_HINTS);
+};
+var meta171 = {
+  summary: "Convert an attachment on one post of a unified (Microsoft 365) group thread to markdown, the `convert-mail-attachment-to-markdown` sibling for a group inbox. Polymorphic on the attachment’s `@odata.type` and sharing the mail pipeline: fileAttachment decodes the inline bytes and converts them locally (docx, xlsx, csv, odt/ods/odp, pptx as per-slide text, pdf text layer, legacy .xls/.doc, an Outlook `.msg` rendered recursively with its quoted chain stripped unless `--keep-quoted true`, plain text passed through); referenceAttachment resolves via `/shares/{token}/driveItem`; an embedded mail, event or contact is rendered locally. There is no PDF sibling here, so an image, a scanned PDF, a legacy `.ppt` and any other unsupported format return a 415 pointing at `get-group-post-attachment` for the raw bytes.",
+  category: "mail",
+  graphMethod: "GET",
+  graphPathTemplate: "/groups/{group-id}/threads/{thread-id}/posts/{post-id}/attachments/{attachment-id}",
+  graphDocsUrl: "https://learn.microsoft.com/en-us/graph/api/attachment-get",
+  options: [
+    {
+      name: "group-id",
+      key: "groupId",
+      required: true,
+      description: "Azure AD group object ID for a unified (Microsoft 365) group the signed-in user belongs to."
+    },
+    {
+      name: "thread-id",
+      key: "threadId",
+      required: true,
+      description: "Conversation thread ID, the `id` of a `list-group-threads` entry."
+    },
+    {
+      name: "post-id",
+      key: "postId",
+      required: true,
+      description: "Post ID inside that thread. Returned by `list-group-thread-posts`."
+    },
+    {
+      name: "attachment-id",
+      key: "attachmentId",
+      required: true,
+      description: "Attachment ID inside that post. Returned by `list-group-post-attachments`."
+    },
+    {
+      name: "include-metadata",
+      key: "includeMetadata",
+      required: false,
+      description: "Pass `--include-metadata true` to append the Office side-channel metadata block, exactly as `convert-mail-attachment-to-markdown` documents it. No-op on other attachment types.",
+      argumentHint: { kind: "magicValue", values: ["true", "false"] }
+    },
+    keepQuotedOption
+  ],
+  example: "ask-marcel-office convert-group-post-attachment-to-markdown --group-id 'a1b2c3d4-...' --thread-id 'AAQkAD...' --post-id 'AQMkAD...' --attachment-id 'AAMkAD...'",
+  responseShape: '`{ contentType: "text/markdown", size, text }` on success (file and reference attachments run through the conversion dispatch; an embedded item is rendered locally). Plain-text sources return the raw-bytes envelope, and a PDF source carries `pageCount`. Unsupported types return an api_error with status 415 naming `get-group-post-attachment` as the way to the bytes.',
+  producesBytes: true
+};
+
+// src/use-cases/commands/get-mail-message-mime.ts
+var exports_get_mail_message_mime = {};
+__export(exports_get_mail_message_mime, {
+  execute: () => execute170,
+  meta: () => meta172,
+  schema: () => schema170
+});
+var schema170 = exports_external.object({ messageId: exports_external.string().min(1) });
+var execute170 = async (graph, params) => {
+  const parsed = schema170.safeParse(params);
   if (!parsed.success)
     return err({ type: "validation_error", message: formatZodError(parsed.error) });
   return inlineBinary(graph, `/me/messages/${parsed.data.messageId}/$value`);
 };
-var meta166 = {
+var meta172 = {
   summary: "Return the raw RFC 5322 MIME source of a single Outlook message — full headers, every attachment encoded inline. Useful for archiving, full-fidelity forensic inspection, or feeding into a tool that reads MIME directly. For human-readable content prefer `get-mail-message` or `convert-mail-to-markdown`.",
   category: "mail",
   graphMethod: "GET",
@@ -26494,13 +26844,13 @@ var meta166 = {
 // src/use-cases/commands/list-mail-folder-messages-delta.ts
 var exports_list_mail_folder_messages_delta = {};
 __export(exports_list_mail_folder_messages_delta, {
-  execute: () => execute165,
-  meta: () => meta167,
-  schema: () => schema165
+  execute: () => execute171,
+  meta: () => meta173,
+  schema: () => schema171
 });
-var schema165 = exports_external.object({ mailFolderId: exports_external.string().min(1) }).extend(pickODataShape(["top", "select", "filter", "expand"]));
-var execute165 = async (graph, params) => {
-  const parsed = schema165.safeParse(params);
+var schema171 = exports_external.object({ mailFolderId: exports_external.string().min(1) }).extend(pickODataShape(["top", "select", "filter", "expand"]));
+var execute171 = async (graph, params) => {
+  const parsed = schema171.safeParse(params);
   if (!parsed.success)
     return err({ type: "validation_error", message: formatZodError(parsed.error) });
   const { mailFolderId, top, ...odata } = parsed.data;
@@ -26509,7 +26859,7 @@ var execute165 = async (graph, params) => {
     headers["Prefer"] = `odata.maxpagesize=${top}`;
   return graph.get(appendOData(`/me/mailFolders/${mailFolderId}/messages/delta()`, odata), headers);
 };
-var meta167 = {
+var meta173 = {
   summary: 'Track incremental changes (added / updated / deleted messages) within a single mail folder using Microsoft Graph delta tokens. The first call returns the current snapshot plus a `@odata.deltaLink`; subsequent calls with that link return only what has changed since. `--top` is translated into the `Prefer: odata.maxpagesize=N` header: as a `$top` query parameter Graph reads a satisfied count as "sync complete" and hands back a deltaLink after N items, silently abandoning the rest of the folder. `$skip` and `$orderby` are NOT exposed — Graph ignores the former on this endpoint and rejects the latter unless it merely restates the default `receivedDateTime desc`.',
   category: "mail",
   graphMethod: "GET",
@@ -26533,14 +26883,14 @@ var meta167 = {
 // src/use-cases/commands/list-shared-mailbox-messages.ts
 var exports_list_shared_mailbox_messages = {};
 __export(exports_list_shared_mailbox_messages, {
-  execute: () => execute166,
-  meta: () => meta168,
-  schema: () => schema166
+  execute: () => execute172,
+  meta: () => meta174,
+  schema: () => schema172
 });
-var baseSchema87 = exports_external.object({ userId: exports_external.string().min(1) });
-var { execute: execute166, schema: schema166 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/messages`, baseSchema87);
-var meta168 = {
-  summary: "List messages from a shared or delegated mailbox the signed-in user has read access to. Same shape as `list-mail-messages` but scoped to a specific mailbox owner. 403 if the signed-in user does not have shared access to that mailbox.",
+var baseSchema90 = exports_external.object({ userId: exports_external.string().min(1) });
+var { execute: execute172, schema: schema172 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/messages`, baseSchema90);
+var meta174 = {
+  summary: "List messages from a shared or delegated mailbox the signed-in user has read access to. Same shape as `list-mail-messages` but scoped to a specific mailbox owner. Requires the delegated `Mail.Read.Shared` scope, which neither token this CLI can mint carries (verified live on two tenants, 2026-08-30), so any mailbox other than the signed-in user's own is expected to answer `ErrorAccessDenied` whatever delegation Exchange holds. Your own UPN works; a Microsoft 365 group's mailbox is the shared-mail path that does (`list-group-conversations`, `list-group-thread-posts`).",
   category: "mail",
   graphMethod: "GET",
   graphPathTemplate: "/users/{user-id}/messages",
@@ -26562,14 +26912,14 @@ var meta168 = {
 // src/use-cases/commands/list-shared-mailbox-folder-messages.ts
 var exports_list_shared_mailbox_folder_messages = {};
 __export(exports_list_shared_mailbox_folder_messages, {
-  execute: () => execute167,
-  meta: () => meta169,
-  schema: () => schema167
+  execute: () => execute173,
+  meta: () => meta175,
+  schema: () => schema173
 });
-var baseSchema88 = exports_external.object({ userId: exports_external.string().min(1), mailFolderId: exports_external.string().min(1) });
-var { execute: execute167, schema: schema167 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/mailFolders/${p.mailFolderId}/messages`, baseSchema88);
-var meta169 = {
-  summary: "List messages in a single folder of a shared / delegated mailbox.",
+var baseSchema91 = exports_external.object({ userId: exports_external.string().min(1), mailFolderId: exports_external.string().min(1) });
+var { execute: execute173, schema: schema173 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/mailFolders/${p.mailFolderId}/messages`, baseSchema91);
+var meta175 = {
+  summary: "List messages in a single folder of a shared / delegated mailbox. Requires the delegated `Mail.Read.Shared` scope, which neither token this CLI can mint carries (verified live on two tenants, 2026-08-30), so any mailbox other than the signed-in user's own is expected to answer `ErrorAccessDenied` whatever delegation Exchange holds. Your own UPN works; a Microsoft 365 group's mailbox is the shared-mail path that does (`list-group-conversations`, `list-group-thread-posts`).",
   category: "mail",
   graphMethod: "GET",
   graphPathTemplate: "/users/{user-id}/mailFolders/{mail-folder-id}/messages",
@@ -26597,14 +26947,14 @@ var meta169 = {
 // src/use-cases/commands/list-shared-mailbox-folders.ts
 var exports_list_shared_mailbox_folders = {};
 __export(exports_list_shared_mailbox_folders, {
-  execute: () => execute168,
-  meta: () => meta170,
-  schema: () => schema168
+  execute: () => execute174,
+  meta: () => meta176,
+  schema: () => schema174
 });
-var baseSchema89 = exports_external.object({ userId: exports_external.string().min(1), includeHiddenFolders: exports_external.enum(["true", "false"]).optional() });
-var { execute: execute168, schema: schema168 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/mailFolders${p.includeHiddenFolders === "true" ? "?includeHiddenFolders=true" : ""}`, baseSchema89);
-var meta170 = {
-  summary: "List the top-level mail folders of a shared or delegated mailbox. The `/me` sibling is `list-mail-folders`. Use it to discover the folder IDs that `list-shared-mailbox-folder-messages` needs: without it only the well-known names (`inbox`, `sentitems`, `drafts`, …) are reachable, so custom folders are invisible. 403 if the signed-in user does not have shared access to that mailbox.",
+var baseSchema92 = exports_external.object({ userId: exports_external.string().min(1), includeHiddenFolders: exports_external.enum(["true", "false"]).optional() });
+var { execute: execute174, schema: schema174 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/mailFolders${p.includeHiddenFolders === "true" ? "?includeHiddenFolders=true" : ""}`, baseSchema92);
+var meta176 = {
+  summary: "List the top-level mail folders of a shared or delegated mailbox. The `/me` sibling is `list-mail-folders`. Use it to discover the folder IDs that `list-shared-mailbox-folder-messages` needs: without it only the well-known names (`inbox`, `sentitems`, `drafts`, …) are reachable, so custom folders are invisible. Requires the delegated `Mail.Read.Shared` scope, which neither token this CLI can mint carries (verified live on two tenants, 2026-08-30), so any mailbox other than the signed-in user's own is expected to answer `ErrorAccessDenied` whatever delegation Exchange holds. Your own UPN works; a Microsoft 365 group's mailbox is the shared-mail path that does (`list-group-conversations`, `list-group-thread-posts`).",
   category: "mail",
   graphMethod: "GET",
   graphPathTemplate: "/users/{user-id}/mailFolders",
@@ -26627,14 +26977,14 @@ var meta170 = {
 // src/use-cases/commands/list-shared-mailbox-child-folders.ts
 var exports_list_shared_mailbox_child_folders = {};
 __export(exports_list_shared_mailbox_child_folders, {
-  execute: () => execute169,
-  meta: () => meta171,
-  schema: () => schema169
+  execute: () => execute175,
+  meta: () => meta177,
+  schema: () => schema175
 });
-var baseSchema90 = exports_external.object({ userId: exports_external.string().min(1), mailFolderId: exports_external.string().min(1), includeHiddenFolders: exports_external.enum(["true", "false"]).optional() });
-var { execute: execute169, schema: schema169 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/mailFolders/${p.mailFolderId}/childFolders${p.includeHiddenFolders === "true" ? "?includeHiddenFolders=true" : ""}`, baseSchema90);
-var meta171 = {
-  summary: "List the subfolders of one mail folder in a shared or delegated mailbox. The `/me` sibling is `list-mail-child-folders`. Walk it from the folder IDs `list-shared-mailbox-folders` returns to reach nested custom folders. 403 if the signed-in user does not have shared access to that mailbox.",
+var baseSchema93 = exports_external.object({ userId: exports_external.string().min(1), mailFolderId: exports_external.string().min(1), includeHiddenFolders: exports_external.enum(["true", "false"]).optional() });
+var { execute: execute175, schema: schema175 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/mailFolders/${p.mailFolderId}/childFolders${p.includeHiddenFolders === "true" ? "?includeHiddenFolders=true" : ""}`, baseSchema93);
+var meta177 = {
+  summary: "List the subfolders of one mail folder in a shared or delegated mailbox. The `/me` sibling is `list-mail-child-folders`. Walk it from the folder IDs `list-shared-mailbox-folders` returns to reach nested custom folders. Requires the delegated `Mail.Read.Shared` scope, which neither token this CLI can mint carries (verified live on two tenants, 2026-08-30), so any mailbox other than the signed-in user's own is expected to answer `ErrorAccessDenied` whatever delegation Exchange holds. Your own UPN works; a Microsoft 365 group's mailbox is the shared-mail path that does (`list-group-conversations`, `list-group-thread-posts`).",
   category: "mail",
   graphMethod: "GET",
   graphPathTemplate: "/users/{user-id}/mailFolders/{mail-folder-id}/childFolders",
@@ -26663,14 +27013,14 @@ var meta171 = {
 // src/use-cases/commands/get-shared-mailbox-message.ts
 var exports_get_shared_mailbox_message = {};
 __export(exports_get_shared_mailbox_message, {
-  execute: () => execute170,
-  meta: () => meta172,
-  schema: () => schema170
+  execute: () => execute176,
+  meta: () => meta178,
+  schema: () => schema176
 });
-var baseSchema91 = exports_external.object({ userId: exports_external.string().min(1), messageId: exports_external.string().min(1) });
-var { execute: execute170, schema: schema170 } = buildSelectableCommand((p) => `/users/${encodeURIComponent(p.userId)}/messages/${p.messageId}`, baseSchema91);
-var meta172 = {
-  summary: "Return a single message from a shared / delegated mailbox. Use `--select` to fetch only specific fields (e.g. `--select id,subject,from,receivedDateTime`) — sibling to `get-mail-message` for /me.",
+var baseSchema94 = exports_external.object({ userId: exports_external.string().min(1), messageId: exports_external.string().min(1) });
+var { execute: execute176, schema: schema176 } = buildSelectableCommand((p) => `/users/${encodeURIComponent(p.userId)}/messages/${p.messageId}`, baseSchema94);
+var meta178 = {
+  summary: "Return a single message from a shared / delegated mailbox. Use `--select` to fetch only specific fields (e.g. `--select id,subject,from,receivedDateTime`) — sibling to `get-mail-message` for /me. Requires the delegated `Mail.Read.Shared` scope, which neither token this CLI can mint carries (verified live on two tenants, 2026-08-30), so any mailbox other than the signed-in user's own is expected to answer `ErrorAccessDenied` whatever delegation Exchange holds. Your own UPN works; a Microsoft 365 group's mailbox is the shared-mail path that does (`list-group-conversations`, `list-group-thread-posts`).",
   category: "mail",
   graphMethod: "GET",
   graphPathTemplate: "/users/{user-id}/messages/{message-id}",
@@ -26697,21 +27047,21 @@ var meta172 = {
 // src/use-cases/commands/list-conversation-messages.ts
 var exports_list_conversation_messages = {};
 __export(exports_list_conversation_messages, {
-  execute: () => execute171,
-  meta: () => meta173,
-  schema: () => schema171
+  execute: () => execute177,
+  meta: () => meta179,
+  schema: () => schema177
 });
 var allowedShape = Object.fromEntries(Object.entries(odataQuerySchema.shape).filter(([key]) => key !== "filter" && key !== "orderby"));
 var allowedOptions = odataQueryOptions.filter((o) => o.name !== "filter" && o.name !== "orderby");
-var schema171 = exports_external.object({ conversationId: exports_external.string().min(1) }).extend(allowedShape);
-var execute171 = async (graph, params) => {
-  const parsed = schema171.safeParse(params);
+var schema177 = exports_external.object({ conversationId: exports_external.string().min(1) }).extend(allowedShape);
+var execute177 = async (graph, params) => {
+  const parsed = schema177.safeParse(params);
   if (!parsed.success)
     return err({ type: "validation_error", message: formatZodError(parsed.error) });
   const path = appendOData(`/me/messages?$filter=conversationId eq '${odataStringLiteral(parsed.data.conversationId)}'`, parsed.data);
   return graph.get(path);
 };
-var meta173 = {
+var meta179 = {
   summary: "List every message in a single Outlook conversation (thread) using `$filter=conversationId eq '...'`. Reconstructs a complete thread regardless of which subject lines or folders the replies landed in. Accepts the OData passthrough flags top/skip/select/expand — the filter and orderby passthroughs are intentionally omitted (the path already pins a `$filter`, and Graph rejects this filter combined with `$orderby` as `InefficientFilter` since `conversationId` is not a sortable index). The caller can sort by `receivedDateTime` client-side. KQL `$search` does not index `conversationId`, so `$filter` is the only documented Graph idiom for whole-thread retrieval.",
   category: "mail",
   graphMethod: "GET",
@@ -26734,13 +27084,13 @@ var meta173 = {
 // src/use-cases/commands/list-focused-inbox-overrides.ts
 var exports_list_focused_inbox_overrides = {};
 __export(exports_list_focused_inbox_overrides, {
-  execute: () => execute172,
-  meta: () => meta174,
-  schema: () => schema172
+  execute: () => execute178,
+  meta: () => meta180,
+  schema: () => schema178
 });
-var baseSchema92 = exports_external.object({}).strict();
-var { execute: execute172, schema: schema172 } = buildListCommand(() => "/me/inferenceClassification/overrides", baseSchema92);
-var meta174 = {
+var baseSchema95 = exports_external.object({}).strict();
+var { execute: execute178, schema: schema178 } = buildListCommand(() => "/me/inferenceClassification/overrides", baseSchema95);
+var meta180 = {
   summary: "List the signed-in user's Focused Inbox classification overrides — sender addresses they've manually moved to Focused or Other, which override Microsoft's automatic classifier.",
   category: "mail",
   graphMethod: "GET",
@@ -26755,13 +27105,13 @@ var meta174 = {
 // src/use-cases/commands/list-outlook-categories.ts
 var exports_list_outlook_categories = {};
 __export(exports_list_outlook_categories, {
-  execute: () => execute173,
-  meta: () => meta175,
-  schema: () => schema173
+  execute: () => execute179,
+  meta: () => meta181,
+  schema: () => schema179
 });
-var schema173 = exports_external.object({}).strict();
-var { execute: execute173 } = buildCommand(() => "/me/outlook/masterCategories", schema173);
-var meta175 = {
+var schema179 = exports_external.object({}).strict();
+var { execute: execute179 } = buildCommand(() => "/me/outlook/masterCategories", schema179);
+var meta181 = {
   summary: "List the signed-in user's Outlook color categories — the named tags that can be applied to mail, calendar items, and contacts. Each entry has `displayName` and a `color` from Outlook's preset palette. Note: Graph silently ignores every OData passthrough on this endpoint (`$top`, `$skip`, `$select`, `$filter`, `$orderby`, `$expand`), so the CLI does not expose any of those flags — the full collection is always returned. Slice client-side.",
   category: "mail",
   graphMethod: "GET",
@@ -26775,13 +27125,13 @@ var meta175 = {
 // src/use-cases/commands/list-shared-calendar-events.ts
 var exports_list_shared_calendar_events = {};
 __export(exports_list_shared_calendar_events, {
-  execute: () => execute174,
-  meta: () => meta176,
-  schema: () => schema174
+  execute: () => execute180,
+  meta: () => meta182,
+  schema: () => schema180
 });
-var baseSchema93 = exports_external.object({ userId: exports_external.string().min(1) });
-var { execute: execute174, schema: schema174 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/calendar/events`, baseSchema93);
-var meta176 = {
+var baseSchema96 = exports_external.object({ userId: exports_external.string().min(1) });
+var { execute: execute180, schema: schema180 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/calendar/events`, baseSchema96);
+var meta182 = {
   summary: "List events from another user's primary calendar (shared / delegated access). 403 without `Calendars.Read.Shared`.",
   category: "calendar",
   graphMethod: "GET",
@@ -26804,13 +27154,13 @@ var meta176 = {
 // src/use-cases/commands/get-shared-calendar-view.ts
 var exports_get_shared_calendar_view = {};
 __export(exports_get_shared_calendar_view, {
-  execute: () => execute175,
-  meta: () => meta177,
-  schema: () => schema175
+  execute: () => execute181,
+  meta: () => meta183,
+  schema: () => schema181
 });
-var baseSchema94 = exports_external.object({ userId: exports_external.string().min(1), startDateTime: isoDateTimeField, endDateTime: isoDateTimeField });
-var { execute: execute175, schema: schema175 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/calendarView?startDateTime=${encodeURIComponent(p.startDateTime)}&endDateTime=${encodeURIComponent(p.endDateTime)}`, baseSchema94);
-var meta177 = {
+var baseSchema97 = exports_external.object({ userId: exports_external.string().min(1), startDateTime: isoDateTimeField, endDateTime: isoDateTimeField });
+var { execute: execute181, schema: schema181 } = buildListCommand((p) => `/users/${encodeURIComponent(p.userId)}/calendarView?startDateTime=${encodeURIComponent(p.startDateTime)}&endDateTime=${encodeURIComponent(p.endDateTime)}`, baseSchema97);
+var meta183 = {
   summary: "Return a date-windowed calendar view from another user's primary calendar (shared / delegated access). Recurrences expanded into individual occurrences.",
   category: "calendar",
   graphMethod: "GET",
@@ -26835,13 +27185,13 @@ var meta177 = {
 // src/use-cases/commands/list-sharepoint-list-columns.ts
 var exports_list_sharepoint_list_columns = {};
 __export(exports_list_sharepoint_list_columns, {
-  execute: () => execute176,
-  meta: () => meta178,
-  schema: () => schema176
+  execute: () => execute182,
+  meta: () => meta184,
+  schema: () => schema182
 });
-var baseSchema95 = exports_external.object({ siteId: exports_external.string().min(1), listId: exports_external.string().min(1) });
-var { execute: execute176, schema: schema176 } = buildSelectableCommand((p) => `/sites/${p.siteId}/lists/${p.listId}/columns`, baseSchema95);
-var meta178 = {
+var baseSchema98 = exports_external.object({ siteId: exports_external.string().min(1), listId: exports_external.string().min(1) });
+var { execute: execute182, schema: schema182 } = buildSelectableCommand((p) => `/sites/${p.siteId}/lists/${p.listId}/columns`, baseSchema98);
+var meta184 = {
   summary: "List the column definitions (schema) of a SharePoint list. Useful before reading list items so you know which fields exist and their types. Note: Graph silently ignores `$top` and `$skip` on this endpoint, so the CLI exposes only `--select` and `--expand`.",
   category: "sharepoint",
   graphMethod: "GET",
@@ -26869,13 +27219,13 @@ var meta178 = {
 // src/use-cases/commands/get-sharepoint-list-column.ts
 var exports_get_sharepoint_list_column = {};
 __export(exports_get_sharepoint_list_column, {
-  execute: () => execute177,
-  meta: () => meta179,
-  schema: () => schema177
+  execute: () => execute183,
+  meta: () => meta185,
+  schema: () => schema183
 });
-var baseSchema96 = exports_external.object({ siteId: exports_external.string().min(1), listId: exports_external.string().min(1), columnId: exports_external.string().min(1) });
-var { execute: execute177, schema: schema177 } = buildSelectableCommand((p) => `/sites/${p.siteId}/lists/${p.listId}/columns/${p.columnId}`, baseSchema96);
-var meta179 = {
+var baseSchema99 = exports_external.object({ siteId: exports_external.string().min(1), listId: exports_external.string().min(1), columnId: exports_external.string().min(1) });
+var { execute: execute183, schema: schema183 } = buildSelectableCommand((p) => `/sites/${p.siteId}/lists/${p.listId}/columns/${p.columnId}`, baseSchema99);
+var meta185 = {
   summary: "Return a single column definition from a SharePoint list.",
   category: "sharepoint",
   graphMethod: "GET",
@@ -26910,9 +27260,9 @@ var meta179 = {
 // src/use-cases/commands/list-sharepoint-site-onenote-notebooks.ts
 var exports_list_sharepoint_site_onenote_notebooks = {};
 __export(exports_list_sharepoint_site_onenote_notebooks, {
-  execute: () => execute178,
-  meta: () => meta180,
-  schema: () => schema178
+  execute: () => execute184,
+  meta: () => meta186,
+  schema: () => schema184
 });
 
 // src/use-cases/commands/onenote-5k-limit.ts
@@ -26933,11 +27283,11 @@ var wrapOnenote5kLimit = (inner14) => async (graph, params) => {
 };
 
 // src/use-cases/commands/list-sharepoint-site-onenote-notebooks.ts
-var baseSchema97 = exports_external.object({ siteId: exports_external.string().min(1) });
-var inner14 = buildListCommand((p) => `/sites/${p.siteId}/onenote/notebooks`, baseSchema97);
-var execute178 = wrapOnenote5kLimit(inner14.execute);
-var { schema: schema178 } = inner14;
-var meta180 = {
+var baseSchema100 = exports_external.object({ siteId: exports_external.string().min(1) });
+var inner14 = buildListCommand((p) => `/sites/${p.siteId}/onenote/notebooks`, baseSchema100);
+var execute184 = wrapOnenote5kLimit(inner14.execute);
+var { schema: schema184 } = inner14;
+var meta186 = {
   summary: "List OneNote notebooks attached to a SharePoint site (separate from the personal `list-onenote-notebooks` which targets `/me`).",
   category: "notes",
   graphMethod: "GET",
@@ -26960,15 +27310,15 @@ var meta180 = {
 // src/use-cases/commands/list-sharepoint-site-onenote-notebook-sections.ts
 var exports_list_sharepoint_site_onenote_notebook_sections = {};
 __export(exports_list_sharepoint_site_onenote_notebook_sections, {
-  execute: () => execute179,
-  meta: () => meta181,
-  schema: () => schema179
+  execute: () => execute185,
+  meta: () => meta187,
+  schema: () => schema185
 });
-var baseSchema98 = exports_external.object({ siteId: exports_external.string().min(1), notebookId: exports_external.string().min(1) });
-var inner15 = buildListCommand((p) => `/sites/${p.siteId}/onenote/notebooks/${p.notebookId}/sections`, baseSchema98);
-var execute179 = wrapOnenote5kLimit(inner15.execute);
-var { schema: schema179 } = inner15;
-var meta181 = {
+var baseSchema101 = exports_external.object({ siteId: exports_external.string().min(1), notebookId: exports_external.string().min(1) });
+var inner15 = buildListCommand((p) => `/sites/${p.siteId}/onenote/notebooks/${p.notebookId}/sections`, baseSchema101);
+var execute185 = wrapOnenote5kLimit(inner15.execute);
+var { schema: schema185 } = inner15;
+var meta187 = {
   summary: "List sections inside one OneNote notebook attached to a SharePoint site.",
   category: "notes",
   graphMethod: "GET",
@@ -26997,15 +27347,15 @@ var meta181 = {
 // src/use-cases/commands/list-sharepoint-site-onenote-section-pages.ts
 var exports_list_sharepoint_site_onenote_section_pages = {};
 __export(exports_list_sharepoint_site_onenote_section_pages, {
-  execute: () => execute180,
-  meta: () => meta182,
-  schema: () => schema180
+  execute: () => execute186,
+  meta: () => meta188,
+  schema: () => schema186
 });
-var baseSchema99 = exports_external.object({ siteId: exports_external.string().min(1), onenoteSectionId: exports_external.string().min(1) });
-var inner16 = buildListCommand((p) => `/sites/${p.siteId}/onenote/sections/${p.onenoteSectionId}/pages`, baseSchema99);
-var execute180 = wrapOnenote5kLimit(inner16.execute);
-var { schema: schema180 } = inner16;
-var meta182 = {
+var baseSchema102 = exports_external.object({ siteId: exports_external.string().min(1), onenoteSectionId: exports_external.string().min(1) });
+var inner16 = buildListCommand((p) => `/sites/${p.siteId}/onenote/sections/${p.onenoteSectionId}/pages`, baseSchema102);
+var execute186 = wrapOnenote5kLimit(inner16.execute);
+var { schema: schema186 } = inner16;
+var meta188 = {
   summary: "List pages inside one section of a SharePoint-site OneNote notebook.",
   category: "notes",
   graphMethod: "GET",
@@ -27034,19 +27384,19 @@ var meta182 = {
 // src/use-cases/commands/get-sharepoint-site-onenote-page-content.ts
 var exports_get_sharepoint_site_onenote_page_content = {};
 __export(exports_get_sharepoint_site_onenote_page_content, {
-  execute: () => execute181,
-  meta: () => meta183,
-  schema: () => schema181
+  execute: () => execute187,
+  meta: () => meta189,
+  schema: () => schema187
 });
-var schema181 = exports_external.object({ siteId: exports_external.string().min(1), onenotePageId: exports_external.string().min(1) });
+var schema187 = exports_external.object({ siteId: exports_external.string().min(1), onenotePageId: exports_external.string().min(1) });
 var innerExecute = async (graph, params) => {
-  const parsed = schema181.safeParse(params);
+  const parsed = schema187.safeParse(params);
   if (!parsed.success)
     return err({ type: "validation_error", message: formatZodError(parsed.error) });
   return graph.getBinary(`/sites/${parsed.data.siteId}/onenote/pages/${parsed.data.onenotePageId}/content`);
 };
-var execute181 = wrapOnenote5kLimit(innerExecute);
-var meta183 = {
+var execute187 = wrapOnenote5kLimit(innerExecute);
+var meta189 = {
   summary: "Return the HTML content of a single OneNote page from a SharePoint site (parallel to `get-onenote-page-content` for `/me`). The response carries the standard `{contentType: text/html, size, text}` shape so the HTML body is available verbatim under either output format.",
   category: "notes",
   graphMethod: "GET",
@@ -27074,13 +27424,13 @@ var meta183 = {
 // src/use-cases/commands/list-drive-item-thumbnails.ts
 var exports_list_drive_item_thumbnails = {};
 __export(exports_list_drive_item_thumbnails, {
-  execute: () => execute182,
-  meta: () => meta184,
-  schema: () => schema182
+  execute: () => execute188,
+  meta: () => meta190,
+  schema: () => schema188
 });
-var baseSchema100 = exports_external.object({ driveId: exports_external.string().min(1), itemId: exports_external.string().min(1), ...tenantIdShape });
-var { execute: execute182, schema: schema182 } = buildNoSkipListCommand((p) => `/drives/${p.driveId}/items/${p.itemId}/thumbnails`, baseSchema100);
-var meta184 = {
+var baseSchema103 = exports_external.object({ driveId: exports_external.string().min(1), itemId: exports_external.string().min(1), ...tenantIdShape });
+var { execute: execute188, schema: schema188 } = buildNoSkipListCommand((p) => `/drives/${p.driveId}/items/${p.itemId}/thumbnails`, baseSchema103);
+var meta190 = {
   summary: "List thumbnail URLs (small / medium / large) for a OneDrive / SharePoint file. Each thumbnail set has pre-signed CDN URLs you can render in a UI without further auth.",
   category: "drive",
   graphMethod: "GET",
@@ -27111,20 +27461,20 @@ var meta184 = {
 // src/use-cases/commands/get-excel-used-range.ts
 var exports_get_excel_used_range = {};
 __export(exports_get_excel_used_range, {
-  execute: () => execute183,
-  meta: () => meta185,
-  schema: () => schema183
+  execute: () => execute189,
+  meta: () => meta191,
+  schema: () => schema189
 });
 var DEFAULT_MAX_CELLS2 = 50000;
-var schema183 = exports_external.object({
+var schema189 = exports_external.object({
   driveId: exports_external.string().min(1),
   itemId: exports_external.string().min(1),
   worksheetId: exports_external.string().min(1),
   full: exports_external.enum(["true", "false"]).optional(),
   maxCells: exports_external.string().regex(/^[1-9]\d*$/, "must be a positive integer").optional()
 });
-var execute183 = async (graph, params) => {
-  const parsed = schema183.safeParse(params);
+var execute189 = async (graph, params) => {
+  const parsed = schema189.safeParse(params);
   if (!parsed.success)
     return err({ type: "validation_error", message: formatZodError(parsed.error) });
   const { driveId, itemId, worksheetId } = parsed.data;
@@ -27159,7 +27509,7 @@ var execute183 = async (graph, params) => {
     projection: "slim"
   });
 };
-var meta185 = {
+var meta191 = {
   summary: 'Return the worksheet\'s used range — the bounding box of every non-empty cell — as a single Excel range. The CLI ships a slim default that strips the redundant `text` / `numberFormat` / `formulas` 2D arrays Graph returns (mostly `"General"` repeated cell-by-cell), keeping `address` / `rowCount` / `columnCount` / `values`. Pass `--full true` to return the raw four-array Graph shape. `--max-cells` (default 50 000) caps the size of the projected `values[]`; oversize ranges drop `values` and surface a hint pointing at `get-excel-range` for band-by-band reads. Avoids fetching the entire 1M × 16K-cell sheet when only a small data island is populated.',
   category: "excel",
   graphMethod: "GET",
@@ -27205,13 +27555,13 @@ var meta185 = {
 // src/use-cases/commands/list-rooms.ts
 var exports_list_rooms = {};
 __export(exports_list_rooms, {
-  execute: () => execute184,
-  meta: () => meta186,
-  schema: () => schema184
+  execute: () => execute190,
+  meta: () => meta192,
+  schema: () => schema190
 });
-var baseSchema101 = exports_external.object({}).strict();
-var { execute: execute184, schema: schema184 } = buildListCommand(() => "/places/microsoft.graph.room", baseSchema101);
-var meta186 = {
+var baseSchema104 = exports_external.object({}).strict();
+var { execute: execute190, schema: schema190 } = buildListCommand(() => "/places/microsoft.graph.room", baseSchema104);
+var meta192 = {
   summary: "List bookable meeting rooms in the tenant. Each `room` has `displayName`, `emailAddress`, `capacity`, `building`, `floorNumber`, and `isWheelChairAccessible`. Use the `emailAddress` as a meeting `attendee` for room booking. Pass `--top 5` to limit the response — large tenants return tens of KB by default.",
   category: "calendar",
   graphMethod: "GET",
@@ -27226,13 +27576,13 @@ var meta186 = {
 // src/use-cases/commands/list-room-lists.ts
 var exports_list_room_lists = {};
 __export(exports_list_room_lists, {
-  execute: () => execute185,
-  meta: () => meta187,
-  schema: () => schema185
+  execute: () => execute191,
+  meta: () => meta193,
+  schema: () => schema191
 });
-var baseSchema102 = exports_external.object({}).strict();
-var { execute: execute185, schema: schema185 } = buildListCommand(() => "/places/microsoft.graph.roomList", baseSchema102);
-var meta187 = {
+var baseSchema105 = exports_external.object({}).strict();
+var { execute: execute191, schema: schema191 } = buildListCommand(() => "/places/microsoft.graph.roomList", baseSchema105);
+var meta193 = {
   summary: "List room lists — usually one per building. Use these to scope a room search by location: a roomList groups the rooms in one office, then `/places/{roomList}/rooms` lists just those rooms. Pass `--top N` to limit the response on large tenants.",
   category: "calendar",
   graphMethod: "GET",
@@ -27247,13 +27597,13 @@ var meta187 = {
 // src/use-cases/commands/list-trending-insights.ts
 var exports_list_trending_insights = {};
 __export(exports_list_trending_insights, {
-  execute: () => execute186,
-  meta: () => meta188,
-  schema: () => schema186
+  execute: () => execute192,
+  meta: () => meta194,
+  schema: () => schema192
 });
-var baseSchema103 = exports_external.object({}).strict();
-var { execute: execute186, schema: schema186 } = buildListCommand(() => "/me/insights/trending", baseSchema103);
-var meta188 = {
+var baseSchema106 = exports_external.object({}).strict();
+var { execute: execute192, schema: schema192 } = buildListCommand(() => "/me/insights/trending", baseSchema106);
+var meta194 = {
   summary: "List documents trending around the signed-in user — files popular in their working network (colleagues' recent edits, shares, opens). Microsoft's relevance ranking, useful for surfacing unfamiliar but related work.",
   category: "drive",
   graphMethod: "GET",
@@ -27394,6 +27744,12 @@ var modules = {
   "list-group-calendar-view": exports_get_group_calendar_view,
   "list-group-conversations": exports_list_group_conversations,
   "list-group-threads": exports_list_group_threads,
+  "list-group-thread-posts": exports_list_group_thread_posts,
+  "get-group-post": exports_get_group_post,
+  "convert-group-post-to-markdown": exports_convert_group_post_to_markdown,
+  "list-group-post-attachments": exports_list_group_post_attachments,
+  "get-group-post-attachment": exports_get_group_post_attachment,
+  "convert-group-post-attachment-to-markdown": exports_convert_group_post_attachment_to_markdown,
   "get-mail-message-mime": exports_get_mail_message_mime,
   "list-mail-folder-messages-delta": exports_list_mail_folder_messages_delta,
   "list-shared-mailbox-messages": exports_list_shared_mailbox_messages,
@@ -27460,9 +27816,9 @@ import { join as join2 } from "node:path";
 var defaultCachePath = (home) => join2(home, ".ask-marcel", "token-cache.json");
 var commandNamesWhere = (matches) => Object.entries(commands).filter(([, cmd]) => matches(cmd.meta)).map(([name]) => name).toSorted((a, b) => a.localeCompare(b));
 var secondaryTokenCommands = {
-  elevated: commandNamesWhere((meta189) => meta189.needsElevatedToken === true),
-  chatsvcagg: commandNamesWhere((meta189) => meta189.needsSubstrateToken === "chatsvcagg"),
-  ic3: commandNamesWhere((meta189) => meta189.needsSubstrateToken === "ic3")
+  elevated: commandNamesWhere((meta195) => meta195.needsElevatedToken === true),
+  chatsvcagg: commandNamesWhere((meta195) => meta195.needsSubstrateToken === "chatsvcagg"),
+  ic3: commandNamesWhere((meta195) => meta195.needsSubstrateToken === "ic3")
 };
 var defaultFileSystem3 = () => typeof globalThis.Bun !== "undefined" ? createBunFileSystem() : createNodeFileSystem();
 var defaultProcessRunner = () => typeof globalThis.Bun !== "undefined" ? createBunProcessRunner() : createNodeProcessRunner();