ask-marcel-office-cli 1.4.0 → 1.5.1

package/dist/use-cases/commands/convert-local-file.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import type { Result } from '../../domain/result.js';
+import type { GraphClient, GraphError } from '../../infra/graph-client.js';
+import type { FileSystem } from '../ports/filesystem.js';
+import type { CommandMeta } from './command-types.js';
+/**
+ * Convert a file ON DISK to markdown through the same `bytesToMarkdown`
+ * dispatch every Graph-backed markdown command uses — the only command whose
+ * input never touches Microsoft Graph (works offline, no login). The fetch
+ * step was always the Graph-bound part; conversion is pure bytes-in/markdown-out.
+ *
+ * A `.zip` routes through the shared archive core (each entry converted, GBK
+ * entry names decoded); everything else goes through the single-file dispatch.
+ * What it can NOT do locally: `format=pdf` conversions (Graph renders those
+ * server-side) and Loop/Fluid/Whiteboard (`format=html`, same reason).
+ *
+ * This is the one registry command executed via `executeLocal(fs, params)` —
+ * the CLI wires its FileSystem in automatically (see `cli.ts`). The Graph-shaped
+ * `execute` exists because the public `commands` registry type requires it; it
+ * redirects library consumers to `executeLocal`.
+ */
+declare const schema: z.ZodObject<{
+    path: z.ZodString;
+    includeMetadata: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
+    inlineImages: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
+    maxCells: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const executeLocal: (fs: FileSystem, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
+declare const execute: (_graph: GraphClient, _params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
+declare const meta: CommandMeta;
+export { execute, executeLocal, meta, schema };

package/dist/use-cases/commands/convert-mail-attachment-to-markdown.d.ts

@@ -5,7 +5,13 @@ import type { CommandMeta } from './command-types.js';
 declare const schema: z.ZodObject<{
     messageId: z.ZodString;
     attachmentId: z.ZodString;
+    includeMetadata: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
 }, z.core.$strip>;
+declare const convertFetchedAttachment: (graph: GraphClient, a: Record<string, unknown>, includeMetadata: boolean) => Promise<Result<unknown, GraphError>> | Result<unknown, GraphError>;
+declare const convertAttachmentToMarkdown: (graph: GraphClient, attachmentPath: string, includeMetadata: boolean) => Promise<Result<unknown, GraphError>>;
 declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
 declare const meta: CommandMeta;
-export { execute, meta, schema };
+export { convertAttachmentToMarkdown, convertFetchedAttachment, execute, meta, schema };

package/dist/use-cases/commands/convert-mail-attachment-to-pdf.d.ts

@@ -6,6 +6,7 @@ declare const schema: z.ZodObject<{
     messageId: z.ZodString;
     attachmentId: z.ZodString;
 }, z.core.$strip>;
+declare const convertAttachmentToPdf: (graph: GraphClient, attachmentPath: string) => Promise<Result<unknown, GraphError>>;
 declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
 declare const meta: CommandMeta;
-export { execute, meta, schema };
+export { convertAttachmentToPdf, execute, meta, schema };

package/dist/use-cases/commands/convert-mail-attachment-zip.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import type { Result } from '../../domain/result.js';
+import type { GraphClient, GraphError } from '../../infra/graph-client.js';
+import type { CommandMeta } from './command-types.js';
+/**
+ * Unzips a `.zip` Outlook mail attachment and converts every contained file in one
+ * call — the mail-side mirror of `convert-drive-item-zip`. Without it, reading a
+ * zipped vendor deck meant: `get-mail-attachment --output-path x.zip` → manual
+ * `unzip` (with `-O GBK` for Chinese names) → convert each file. This collapses all
+ * of that into one command: it pulls the fileAttachment bytes, unzips them (legacy
+ * GBK / CP437 entry names are decoded, not mojibaked, in the shared zip reader), and
+ * runs each entry through the same conversion dispatch the markdown commands use.
+ */
+declare const schema: z.ZodObject<{
+    messageId: z.ZodString;
+    attachmentId: z.ZodString;
+    includeMetadata: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
+}, z.core.$strip>;
+declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/convert-mail-to-markdown.d.ts

@@ -8,6 +8,10 @@ declare const schema: z.ZodObject<{
         true: "true";
         false: "false";
     }>>;
+    keepQuoted: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
 }, z.core.$strip>;
 declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
 declare const meta: CommandMeta;

package/dist/use-cases/commands/create-mail-draft.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import type { Command, CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    subject: z.ZodString;
+    bodyContent: z.ZodString;
+    bodyContentType: z.ZodOptional<z.ZodEnum<{
+        Text: "Text";
+        HTML: "HTML";
+    }>>;
+    toRecipients: z.ZodString;
+    ccRecipients: z.ZodOptional<z.ZodString>;
+    bccRecipients: z.ZodOptional<z.ZodString>;
+    importance: z.ZodOptional<z.ZodEnum<{
+        Low: "Low";
+        Normal: "Normal";
+        High: "High";
+    }>>;
+    mailFolderId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const execute: Command['execute'];
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/doc-to-markdown.d.ts

@@ -0,0 +1,14 @@
+import type { Result } from '../../domain/result.js';
+import type { GraphError } from '../../infra/graph-client.js';
+type DocTextEnvelope = {
+    readonly contentType: 'text/plain';
+    readonly size: number;
+    readonly text: string;
+};
+/**
+ * Convert a legacy Word .doc to a plain-text envelope by extracting its body text
+ * (via word-extractor). Output is text/plain, not markdown — legacy .doc carries
+ * no structure this CLI recovers. A parse failure propagates as the infra api_error.
+ */
+declare const docToMarkdown: (bytes: Uint8Array) => Promise<Result<DocTextEnvelope, GraphError>>;
+export { docToMarkdown };

package/dist/use-cases/commands/docs-render.d.ts

@@ -3,6 +3,7 @@ export type CommandManifestEntry = {
     readonly name: string;
     readonly summary: string;
     readonly category: CommandCategory;
+    readonly commandAliases?: CommandMeta['commandAliases'];
     readonly graphMethod: CommandMeta['graphMethod'];
     readonly graphPathTemplate: string;
     readonly graphDocsUrl: string;
@@ -16,6 +17,8 @@ export type CommandManifestEntry = {
     readonly scopesRequired?: CommandMeta['scopesRequired'];
     readonly needsElevatedToken?: CommandMeta['needsElevatedToken'];
     readonly producesBytes?: CommandMeta['producesBytes'];
+    readonly producesMedia?: CommandMeta['producesMedia'];
+    readonly mutates?: CommandMeta['mutates'];
     readonly stability?: CommandMeta['stability'];
 };
 export declare const paginationHintFor: (strategy: PaginationStrategy | undefined) => string;

package/dist/use-cases/commands/docs.d.ts

@@ -13,7 +13,7 @@ export type DocsError = {
  * `scopesRequired` — everything the LLM only needs once it's already decided
  * to invoke. `stability` is kept (it's a discovery-time concern: LLMs prefer
  * stable siblings when they exist, so they need to see the tag at discovery
- * time, not after a second full-manifest fetch). Audit Hervé-session §B/§6.
+ * time, not after a second full-manifest fetch). Audit Jane-session §B/§6.
  */
 export type TerseManifestEntry = {
     readonly name: string;

package/dist/use-cases/commands/docx-comment-anchors.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Correlates each docx comment to the body text it annotates. In
+ * `word/document.xml` a comment's anchored span is bracketed by empty marker
+ * elements `<w:commentRangeStart w:id="N"/> …runs… <w:commentRangeEnd w:id="N"/>`,
+ * keyed by the same `w:id` the comment in `word/comments.xml` carries. mammoth
+ * strips those markers from its HTML, so to fold the comment's context into the
+ * markdown we read document.xml directly.
+ *
+ * The shared walker (ooxml-xml-walker) groups same-named siblings and loses
+ * cross-element order, which would scramble which runs fall inside a range. So,
+ * like odf-content-to-markdown, this parses with `preserveOrder` and walks the
+ * ordered tree, tracking the set of currently-open comment ids and appending
+ * each `<w:t>` run's text to every open range. Handles overlapping / nested
+ * ranges (more than one open at once). Pure (string → Map); no IO.
+ */
+type Node = Record<string, unknown>;
+declare const tagOf: (node: Node) => string | undefined;
+declare const attr: (node: Node, name: string) => string;
+declare const leafText: (children: ReadonlyArray<Node>) => string;
+declare const clamp: (span: string) => string;
+declare const extractCommentAnchors: (documentXml: string | undefined) => ReadonlyMap<string, string>;
+export { attr, clamp, extractCommentAnchors, leafText, tagOf };

package/dist/use-cases/commands/docx-metadata-to-markdown.d.ts

@@ -0,0 +1,3 @@
+import type { DocxMetadata } from './docx-metadata.js';
+declare const formatDocxMetadata: (meta: DocxMetadata) => string;
+export { formatDocxMetadata };

package/dist/use-cases/commands/docx-metadata.d.ts

@@ -0,0 +1,69 @@
+import type { Result } from '../../domain/result.js';
+import type { GraphError } from '../../infra/graph-client.js';
+import type { CustomProp, ExternalRel } from './ooxml-metadata.js';
+/**
+ * Pulls the side-channel content out of a .docx zip — every text-bearing
+ * surface mammoth drops on the floor: core / app / custom doc properties,
+ * people registry, external hyperlinks, comments, tracked changes (ins + del),
+ * hidden text (w:vanish), text-box / shape text (w:txbxContent), header/footer
+ * body prose, field instructions (MERGEFIELD / HYPERLINK / DOCVARIABLE), bookmarks.
+ *
+ * The package-level parts (docProps/*, every *.rels) come from the shared
+ * ooxml-metadata module; this file owns only the docx-body-specific parts.
+ *
+ * Pure use-case logic — no IO. The zip is opened upstream via the infra
+ * adapter; this module just walks parsed XML trees. Try/catch lives in
+ * the infra adapter, not here.
+ */
+type CoreProps = Readonly<Record<string, string>>;
+type AppProps = Readonly<Record<string, string>>;
+type Person = {
+    readonly author: string;
+    readonly providerId: string;
+    readonly userId: string;
+};
+type Comment = {
+    readonly id: string;
+    readonly author: string;
+    readonly initials: string;
+    readonly date: string;
+    readonly text: string;
+    readonly anchor?: string;
+};
+type TrackedChange = {
+    readonly id: string;
+    readonly author: string;
+    readonly date: string;
+    readonly text: string;
+};
+type Field = {
+    readonly source: string;
+    readonly instruction: string;
+};
+type Bookmark = {
+    readonly id: string;
+    readonly name: string;
+};
+type HeaderFooter = {
+    readonly part: string;
+    readonly text: string;
+};
+type DocxMetadata = {
+    readonly core: CoreProps;
+    readonly app: AppProps;
+    readonly custom: ReadonlyArray<CustomProp>;
+    readonly people: ReadonlyArray<Person>;
+    readonly externalRels: ReadonlyArray<ExternalRel>;
+    readonly comments: ReadonlyArray<Comment>;
+    readonly insertions: ReadonlyArray<TrackedChange>;
+    readonly deletions: ReadonlyArray<TrackedChange>;
+    readonly hiddenText: ReadonlyArray<string>;
+    readonly textBoxes: ReadonlyArray<string>;
+    readonly headersFooters: ReadonlyArray<HeaderFooter>;
+    readonly fields: ReadonlyArray<Field>;
+    readonly bookmarks: ReadonlyArray<Bookmark>;
+    readonly macros: ReadonlyArray<string>;
+};
+declare const extractDocxMetadata: (bytes: Uint8Array) => Promise<Result<DocxMetadata, GraphError>>;
+export { extractDocxMetadata };
+export type { Bookmark, Comment, CustomProp, DocxMetadata, ExternalRel, Field, HeaderFooter, Person, TrackedChange };

package/dist/use-cases/commands/docx-to-markdown.d.ts

@@ -5,7 +5,12 @@ type MarkdownEnvelope = {
     readonly size: number;
     readonly text: string;
 };
+type DocxToMarkdownOptions = {
+    readonly includeMetadata?: boolean;
+    readonly inlineImages?: boolean;
+};
+declare const stripInlineImages: (markdown: string) => string;
 declare const promoteFirstRowToThead: (html: string) => string;
-declare const docxToMarkdown: (bytes: Uint8Array) => Promise<Result<MarkdownEnvelope, GraphError>>;
-export { docxToMarkdown, promoteFirstRowToThead };
-export type { MarkdownEnvelope };
+declare const docxToMarkdown: (bytes: Uint8Array, opts?: DocxToMarkdownOptions) => Promise<Result<MarkdownEnvelope, GraphError>>;
+export { docxToMarkdown, promoteFirstRowToThead, stripInlineImages };
+export type { DocxToMarkdownOptions, MarkdownEnvelope };

package/dist/use-cases/commands/download-drive-item-as-markdown.d.ts

@@ -5,6 +5,15 @@ import type { CommandMeta } from './command-types.js';
 declare const schema: z.ZodObject<{
     driveId: z.ZodString;
     itemId: z.ZodString;
+    includeMetadata: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
+    inlineImages: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
+    maxCells: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
 declare const meta: CommandMeta;

package/dist/use-cases/commands/download-drive-item-version.d.ts

@@ -11,6 +11,10 @@ declare const schema: z.ZodObject<{
         pdf: "pdf";
         original: "original";
     }>>;
+    includeMetadata: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
 }, z.core.$strip>;
 declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
 declare const meta: CommandMeta;

package/dist/use-cases/commands/extract-drive-item-images.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import type { Result } from '../../domain/result.js';
+import type { GraphClient, GraphError } from '../../infra/graph-client.js';
+import type { CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    driveId: z.ZodString;
+    itemId: z.ZodString;
+}, z.core.$strip>;
+declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/extract-local-file-images.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import type { Result } from '../../domain/result.js';
+import type { GraphClient, GraphError } from '../../infra/graph-client.js';
+import type { FileSystem } from '../ports/filesystem.js';
+import type { CommandMeta } from './command-types.js';
+/**
+ * Extract embedded images from a file ON DISK — the local sibling of
+ * `extract-drive-item-images`, sharing its `extractImagesFromBytes` dispatch
+ * (OOXML media parts / unpdf page walk). It completes two flows the drive
+ * command cannot reach: a Graph-rendered PDF saved with the global
+ * output-path flag (the legacy-.ppt route), and Office files unpacked from a
+ * local archive. Like `convert-local-file`, it never touches Graph and is
+ * executed via `executeLocal(fs, params)`.
+ */
+declare const schema: z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strip>;
+declare const executeLocal: (fs: FileSystem, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
+declare const execute: (_graph: GraphClient, _params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
+declare const meta: CommandMeta;
+export { execute, executeLocal, meta, schema };

package/dist/use-cases/commands/extract-mail-attachment-images.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import type { Result } from '../../domain/result.js';
+import type { GraphClient, GraphError } from '../../infra/graph-client.js';
+import type { CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    messageId: z.ZodString;
+    attachmentId: z.ZodString;
+}, z.core.$strip>;
+declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/extract-sharepoint-links-in-documents.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import type { Result } from '../../domain/result.js';
+import type { GraphClient, GraphError } from '../../infra/graph-client.js';
+import type { CommandMeta } from './command-types.js';
+import type { ResolvedLink } from './sharepoint-link-extractor.js';
+/**
+ * The document-side sibling of `extract-sharepoint-links-in-mail`: pulls a
+ * docx/xlsx/pptx from a OneDrive / SharePoint item and finds every
+ * `*.sharepoint.com` URL embedded in it, resolving each to its driveItem so an
+ * agent can follow references out of a document the same way it follows them
+ * out of an email. Read-only — no conversion happens here.
+ *
+ * In OOXML, external hyperlinks live in the `_rels/*.rels` parts as
+ * `<Relationship Target="…" TargetMode="External"/>`. `extractExternalRels`
+ * (shared with the metadata extractors) already surfaces exactly those, so this
+ * command is pure composition: fetch bytes → open the package → collect external
+ * targets → keep the SharePoint ones → resolve via `/shares/{token}/driveItem`.
+ */
+declare const schema: z.ZodObject<{
+    driveId: z.ZodString;
+    itemId: z.ZodString;
+}, z.core.$strip>;
+type DocumentLinkSummary = {
+    readonly driveId: string;
+    readonly itemId: string;
+    readonly links: ReadonlyArray<ResolvedLink>;
+    readonly truncated: boolean;
+    readonly skippedCount: number;
+};
+declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<DocumentLinkSummary, GraphError>>;
+declare const meta: CommandMeta;
+export { execute, meta, schema };
+export type { DocumentLinkSummary };

package/dist/use-cases/commands/extract-sharepoint-links-in-mail.d.ts

@@ -2,14 +2,7 @@ import { z } from 'zod';
 import type { Result } from '../../domain/result.js';
 import type { GraphClient, GraphError } from '../../infra/graph-client.js';
 import type { CommandMeta } from './command-types.js';
-type ResolvedLink = {
-    readonly url: string;
-    readonly driveId?: string;
-    readonly itemId?: string;
-    readonly name?: string;
-    readonly webUrl?: string;
-    readonly error?: string;
-};
+import type { ResolvedLink } from './sharepoint-link-extractor.js';
 type LinkExtractionSummary = {
     readonly messageId: string;
     readonly subject?: string;

package/dist/use-cases/commands/fetch-raw-bytes.d.ts

@@ -34,6 +34,7 @@ export type InlineBinary = {
     readonly size: number;
     readonly base64: string;
 };
+export declare const base64ToBytes: (b64: string) => Uint8Array;
 export declare const fetchRawBytes: (graph: GraphClient, contentPath: string, opts?: FetchOptions) => Promise<Result<Uint8Array, GraphError>>;
 export declare const inlineBinary: (graph: GraphClient, contentPath: string, opts?: FetchOptions) => Promise<Result<InlineBinary, GraphError>>;
 /**

package/dist/use-cases/commands/file-counts.d.ts

@@ -0,0 +1,7 @@
+import type { GraphClient } from '../../infra/graph-client.js';
+type FileCountOptions = {
+    readonly max?: number;
+    readonly chunk?: number;
+};
+declare const addEstimatedFileCounts: (graph: GraphClient, entries: ReadonlyArray<unknown>, webUrlOf: (entry: unknown) => string | undefined, options?: FileCountOptions) => Promise<ReadonlyArray<unknown>>;
+export { addEstimatedFileCounts };

package/dist/use-cases/commands/filter-archived-sites.d.ts

@@ -0,0 +1,17 @@
+import type { GraphClient } from '../../infra/graph-client.js';
+declare const ARCHIVE_PROBE_MAX = 250;
+type FilterOptions = {
+    readonly probeMax?: number;
+    readonly chunkSize?: number;
+};
+type FilterResult = {
+    readonly value: ReadonlyArray<unknown>;
+    readonly archivedExcluded: number;
+    readonly nonNavigableExcluded: number;
+    readonly notFoundExcluded: number;
+    readonly probeErrors: number;
+    readonly probeTruncated: boolean;
+};
+declare const filterOutArchivedSites: (graph: GraphClient, sites: ReadonlyArray<unknown>, options?: FilterOptions) => Promise<FilterResult>;
+export { ARCHIVE_PROBE_MAX, filterOutArchivedSites };
+export type { FilterResult };

package/dist/use-cases/commands/first-sentence.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Compact a multi-sentence summary to its first sentence — everything up to the
+ * first `. ` (period-space) or the first newline, whichever comes first. Returns
+ * the full text untouched when no sensible cut-point exists, so the result is
+ * never less readable than the original. Keeps the trailing period when cutting
+ * on `. ` so the line ends naturally.
+ *
+ * Shared by the top-level `--help` subcommand listing (composition) and the
+ * `help-json --terse` discovery projection (use-cases) so both compact the same
+ * way — the terse manifest in particular must stay token-cheap per category.
+ */
+export declare const firstSentence: (full: string) => string;

package/dist/use-cases/commands/get-excel-chart-image.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import type { Result } from '../../domain/result.js';
+import type { GraphClient, GraphError } from '../../infra/graph-client.js';
+import type { CommandMeta } from './command-types.js';
+/**
+ * Renders an Excel chart to a PNG via Graph's chart `Image()` function. Unlike
+ * the rest of the conversion surface, this endpoint returns the bytes as a
+ * base64 string in the JSON `value` field (NOT a 302 redirect), so a plain
+ * `graph.get` is enough. `width=0,height=0` = the chart's natural size;
+ * `fittingMode='Fit'` preserves aspect ratio.
+ */
+declare const schema: z.ZodObject<{
+    driveId: z.ZodString;
+    itemId: z.ZodString;
+    worksheetId: z.ZodString;
+    chartId: z.ZodString;
+}, z.core.$strip>;
+declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/get-onenote-page-as-markdown.d.ts

@@ -4,6 +4,14 @@ import type { GraphClient, GraphError } from '../../infra/graph-client.js';
 import type { CommandMeta } from './command-types.js';
 declare const schema: z.ZodObject<{
     onenotePageId: z.ZodString;
+    inlineImages: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
+    includeMetadata: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
 }, z.core.$strip>;
 declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
 declare const meta: CommandMeta;

package/dist/use-cases/commands/get-todo-task.d.ts

@@ -1,4 +1,11 @@
-import type { CommandMeta } from './command-types.js';
-declare const execute: import("./command-types.js").CommandExecute, schema: import("./command-types.js").CommandSchema;
+import { z } from 'zod';
+import type { Command, CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    todoTaskListId: z.ZodString;
+    todoTaskId: z.ZodString;
+    select: z.ZodOptional<z.ZodString>;
+    expand: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const execute: Command['execute'];
 declare const meta: CommandMeta;
 export { execute, meta, schema };

package/dist/use-cases/commands/image-extraction.d.ts

@@ -0,0 +1,10 @@
+import type { Result } from '../../domain/result.js';
+import type { GraphError } from '../../infra/graph-client.js';
+/**
+ * Shared by extract-drive-item-images and extract-mail-attachment-images: pick the
+ * extractor for the file's extension and run it, or return a 415 whose tail
+ * (`fetchHint`) names the caller's raw-bytes route. Both commands fetch / decode the
+ * bytes first, then hand them here, so the dispatch + media envelope live in one place.
+ */
+declare const extractImagesFromBytes: (bytes: Uint8Array, name: string, fetchHint: string) => Promise<Result<unknown, GraphError>>;
+export { extractImagesFromBytes };

package/dist/use-cases/commands/iso-datetime-schema.d.ts

@@ -6,7 +6,7 @@ import { z } from 'zod';
  * compose this into their schemas in place of `z.string().min(1)`; the
  * URL-builder sees the already-resolved canonical ISO form.
  *
- * Audit Hervé-session §C: removes the manual ISO arithmetic an LLM had to do
+ * Audit Jane-session §C: removes the manual ISO arithmetic an LLM had to do
  * to ask "what changed this week" against `list-calendar-view`. Type
  * inference is left to Zod so the calendar commands' shape signatures stay
  * compatible with `buildListCommand`'s `ZodRawShape` constraint.

package/dist/use-cases/commands/list-accessible-drives.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import type { Result } from '../../domain/result.js';
+import type { GraphClient, GraphError } from '../../infra/graph-client.js';
+import type { CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    maxGroups: z.ZodOptional<z.ZodString>;
+    countFiles: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
+}, z.core.$strip>;
+declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/list-calendar-event-attachments.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import type { Command, CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    eventId: z.ZodString;
+    top: z.ZodOptional<z.ZodString>;
+    skip: z.ZodOptional<z.ZodString>;
+    select: z.ZodOptional<z.ZodString>;
+    filter: z.ZodOptional<z.ZodString>;
+    orderby: z.ZodOptional<z.ZodString>;
+    expand: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const execute: Command['execute'];
+declare const meta: CommandMeta;
+export { execute, meta, schema };

package/dist/use-cases/commands/mail-quote-stripper.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Strips quoted reply chains / forwarded-message blocks from an Outlook or
+ * Gmail HTML email body so long threads don't duplicate quoted content into the
+ * model's context. Conservative: truncates the body at the EARLIEST well-known
+ * reply/forward boundary marker and replaces the tail with a single visible
+ * placeholder — nothing is removed silently, and `--keep-quoted true` on
+ * `convert-mail-to-markdown` restores the full body. Pure string transform.
+ *
+ * Only structural, vendor-specific markers are matched (never a bare
+ * `<blockquote>`, which legitimate content uses too):
+ *   - Outlook desktop / OWA reply+forward header block: `<div id="divRplyFwdMsg">`
+ *   - Outlook "type above this line" boundary:           `<div id="appendonsend">`
+ *   - Outlook mobile reference container:                `<div id="mail-editor-reference-message-container">`
+ *   - Outlook classic separator:                         `<hr id="stopSpelling">`
+ *   - Gmail quote container:                             `<div class="gmail_quote">` / `<blockquote class="gmail_quote">`
+ */
+declare const stripQuotedReplies: (html: string) => {
+    readonly html: string;
+    readonly stripped: boolean;
+};
+declare const stripQuotedPlainText: (text: string) => {
+    readonly text: string;
+    readonly stripped: boolean;
+};
+export { stripQuotedPlainText, stripQuotedReplies };

package/dist/use-cases/commands/markdown-dispatch.d.ts

@@ -0,0 +1,29 @@
+import type { Result } from '../../domain/result.js';
+import type { GraphError } from '../../infra/graph-client.js';
+declare const IMAGE_EXTENSIONS: ReadonlySet<string>;
+type ConversionHints = {
+    readonly pdfNoText: string;
+    readonly legacyPpt: string;
+    readonly image: (ext: string) => string;
+    readonly generic: (ext: string) => string;
+};
+type BytesToMarkdownOptions = {
+    readonly includeMetadata?: boolean;
+    readonly maxCells?: number;
+    readonly inlineImages?: boolean;
+    readonly depth?: number;
+};
+declare const NESTED_HINTS: ConversionHints;
+/**
+ * The single extension→converter dispatch for every markdown command, operating on
+ * bytes already in hand: download-drive-item-as-markdown fetches them, convert-mail
+ * decodes the attachment, convert-drive-item-zip unpacks the entry. Loop/Fluid/
+ * Whiteboard (`?format=html`) need a Graph round-trip and are handled by the drive
+ * caller BEFORE this — they never reach here. An Outlook `.msg` is rendered to markdown
+ * (headers + body) with each of its own attachments recursed through this dispatch.
+ * `hints` carry the caller-specific messages; a non-text result is an `err` the caller
+ * surfaces (a 415, or a zip note).
+ */
+declare const bytesToMarkdown: (bytes: Uint8Array, filename: string, opts: BytesToMarkdownOptions, hints: ConversionHints) => Promise<Result<unknown, GraphError>>;
+export { bytesToMarkdown, IMAGE_EXTENSIONS, NESTED_HINTS };
+export type { BytesToMarkdownOptions, ConversionHints };

package/dist/use-cases/commands/markdown-pipeline.d.ts

@@ -18,6 +18,10 @@ type MarkdownEnvelope = {
     readonly size: number;
     readonly text: string;
 };
-declare const convertToMarkdown: (graph: GraphClient, contentPath: string, inlineAttachments?: ReadonlyArray<InlineAttachment>) => Promise<Result<MarkdownEnvelope, GraphError>>;
+type ConvertOptions = {
+    readonly inlineAttachments?: ReadonlyArray<InlineAttachment>;
+    readonly htmlTransform?: (html: string) => Promise<string>;
+};
+declare const convertToMarkdown: (graph: GraphClient, contentPath: string, options?: ConvertOptions) => Promise<Result<MarkdownEnvelope, GraphError>>;
 export { convertToMarkdown };
-export type { MarkdownEnvelope };
+export type { ConvertOptions, MarkdownEnvelope };