ask-marcel-office-cli 2.1.0 → 2.2.0

package/dist/infra/auth.d.ts

@@ -1,5 +1,6 @@
 import type { AccessToken } from '../domain/access-token.js';
 import type { Result } from '../domain/result.js';
+import type { TenantId } from '../domain/tenant-id.js';
 import type { FileSystem } from '../use-cases/ports/filesystem.js';
 import type { Logger } from '../use-cases/ports/logger.js';
 import type { BrowserAuth, ElevatedFailureReason } from './browser-auth.js';
@@ -24,6 +25,11 @@ type ElevatedOutcome = {
     captured: false;
     reason: ElevatedFailureReason | 'unknown_error';
 };
+type CachedTierInfo = {
+    readonly available: boolean;
+    readonly expiresInSeconds: number | undefined;
+    readonly scopes: ReadonlyArray<string>;
+};
 type AuthManager = {
     getAccessToken: (options?: {
         force?: boolean;
@@ -34,6 +40,14 @@ type AuthManager = {
      * via headless Playwright. Used by the 3 historical-version commands.
      */
     getElevatedAccessToken: () => Promise<Result<AccessToken, AuthError>>;
+    /**
+     * Returns a Graph token issued by a PARTNER tenant's authority, for a user
+     * who is a guest there. Without it, every call against that tenant's
+     * SharePoint dies at `401 invalidAudienceUri` — home-tenant Graph cannot mint
+     * an SPO token for a foreign tenant. Cache -> headless redemption of the
+     * shared refresh token; never a browser.
+     */
+    getGuestAccessToken: (tenantId: TenantId) => Promise<Result<AccessToken, AuthError>>;
     /**
      * Returns a chatsvcagg-audience token (same Teams web client identity
      * as `getAccessToken`, but issued for the chatsvcagg resource). Falls
@@ -81,26 +95,32 @@ type AuthManager = {
      * Optional: only the real manager implements it; a minimal fake omits it
      * and callers treat that as unavailable. Never captures or refreshes.
      */
-    getCachedElevatedInfo?: () => Promise<{
-        available: boolean;
-        expiresInSeconds: number | undefined;
-    }>;
+    getCachedElevatedInfo?: () => Promise<CachedTierInfo>;
     /**
      * Same decode-only preflight as `getCachedElevatedInfo`, for the chatsvcagg /
      * ic3 Teams-chat substrate tokens. `login`'s four-token status and
      * `scopes-check` read these; a minimal fake omits them and callers treat that
      * as unavailable.
      */
-    getCachedChatsvcaggInfo?: () => Promise<{
-        available: boolean;
-        expiresInSeconds: number | undefined;
-    }>;
-    getCachedIc3Info?: () => Promise<{
-        available: boolean;
-        expiresInSeconds: number | undefined;
-    }>;
+    getCachedChatsvcaggInfo?: () => Promise<CachedTierInfo>;
+    getCachedIc3Info?: () => Promise<CachedTierInfo>;
+};
+/**
+ * Command names quoted in the secondary-token error messages, per token kind.
+ * The composition root derives these from the command registry
+ * (`needsElevatedToken` / `needsSubstrateToken` flags) and injects them; the
+ * defaults below are the corrected registry sets at the time of writing, so
+ * direct `createAuthManagerFromApi` callers still get accurate messages. The
+ * registry sets are pinned in meta.test.ts and the wiring in
+ * build-deps.test.ts, so drift surfaces there, not in a stale user message
+ * (the old hardcoded elevated list omitted `get-user`).
+ */
+type SecondaryTokenCommands = {
+    readonly elevated: ReadonlyArray<string>;
+    readonly chatsvcagg: ReadonlyArray<string>;
+    readonly ic3: ReadonlyArray<string>;
 };
-declare const createAuthManagerFromApi: (browserAuth: BrowserAuth, cachePath: string, browserProfileDir: string, logger: Logger, fs: FileSystem, recaptureSecondaryViaBrowser?: boolean) => AuthManager;
+declare const createAuthManagerFromApi: (browserAuth: BrowserAuth, cachePath: string, browserProfileDir: string, logger: Logger, fs: FileSystem, recaptureSecondaryViaBrowser?: boolean, secondaryTokenCommands?: SecondaryTokenCommands, acquireBasicViaBrowser?: boolean) => AuthManager;
 /**
  * Probe the token cache for a fresh access token. Handed to the browser
  * capture so its poll loop can short-circuit the multi-minute dance
@@ -116,6 +136,8 @@ declare const createAuthManager: (deps: {
     fs?: FileSystem;
     browserProfileDir?: string;
     recaptureSecondaryViaBrowser?: boolean;
+    secondaryTokenCommands?: SecondaryTokenCommands;
+    acquireBasicViaBrowser?: boolean;
 }) => AuthManager;
 export { createAuthManager, createAuthManagerFromApi, createFreshCachedTokenProbe, stderrProgress };
-export type { AuthError, AuthManager, ElevatedOutcome };
+export type { AuthError, AuthManager, CachedTierInfo, ElevatedOutcome, SecondaryTokenCommands };

package/dist/infra/browser-auth.d.ts

@@ -97,8 +97,13 @@ type BrowserAuth = {
      * different Microsoft web app whose first-party app identity is on
      * Microsoft's allow-list for ODSP `logicalPermissions` (the scope our
      * Teams web client token lacks for historical-version stream
-     * content). Reuses the persistent profile cookies — no second
-     * sign-in. Headless by default.
+     * content). Launches a HEADED browser (`launchContext(false)`) and
+     * relies, best-effort, on the persistent profile's cookies to complete
+     * sign-in silently. This is NOT guaranteed: on tenants that do not
+     * persist SSO cookies (or once they lapse) the navigation lands on a
+     * sign-in wall and the capture times out (verified headed AND headless
+     * 2026-07-19). That is why it stays headed and why the caller treats a
+     * miss as non-fatal and points the user at an interactive `login`.
      *
      * Returns a discriminated union so the caller can distinguish the three
      * failure modes (browser-launch hang, navigation failure, silent-SSO

package/dist/infra/graph-client.d.ts

@@ -1,5 +1,6 @@
 import type { Result } from '../domain/result.js';
 import type { AuthManager } from '../infra/auth.js';
+import type { TenantId } from '../domain/tenant-id.js';
 type GraphError = {
     type: 'api_error';
     status: number;
@@ -36,6 +37,34 @@ type GraphClient = {
      * elevated token).
      */
     getElevated: (path: string) => Promise<Result<unknown, GraphError>>;
+    /**
+     * JSON-GET signed with a PARTNER tenant's guest token instead of the home
+     * token. Required for any path that touches a tenant the user is only a guest
+     * in: home-tenant Graph cannot mint a SharePoint token for a foreign tenant,
+     * so those calls die at `401 invalidAudienceUri` no matter which home tier
+     * signs them.
+     *
+     * Get the `tenantId` from `resolve-drive-share-link` (it discovers it from the
+     * sharing URL) or from the caller's `--tenant-id`.
+     */
+    getGuest: (path: string, tenantId: TenantId) => Promise<Result<unknown, GraphError>>;
+    /**
+     * Binary twin of `getGuest`: follows the Graph 302 to the partner tenant's CDN
+     * and returns the bytes. The `fetchUrl` allow-list already admits any
+     * `*.sharepoint.com` / `*.svc.ms` host, so a partner tenant's download URL
+     * needs no special casing.
+     */
+    getBinaryGuest: (path: string, tenantId: TenantId) => Promise<Result<unknown, GraphError>>;
+    /**
+     * Resolves a SharePoint host to the Entra tenant that owns it, via the tenant's
+     * public OIDC discovery document. Unauthenticated: it asks "who owns this
+     * host?", not "what may I read?".
+     *
+     * This is what makes a bare sharing URL enough to cross tenants — the URL
+     * carries the host, the host names the tenant, and the tenant is the one thing
+     * `driveId` + `itemId` do not tell you.
+     */
+    discoverTenantId: (spoHost: string) => Promise<Result<TenantId, GraphError>>;
     /**
      * JSON-GET against the Teams chat substrate (post-2026-05:
      * `teams.microsoft.com/api/csa/<region>/api/v{N}/...` — see
@@ -102,6 +131,23 @@ type GraphClient = {
      */
     getCachedTokenInfo: () => Promise<Result<TokenInfo, GraphError>>;
 };
+/**
+ * Decode-only status for one non-basic token tier: availability, remaining runway,
+ * the scopes granted to that token (decoded from its `scp`), and how it refreshes
+ * (`automatic` = rides the shared refresh token; `interactive` = elevated, needs a login).
+ */
+type TokenTierInfo = {
+    readonly available: boolean;
+    readonly expiresInSeconds: number | undefined;
+    readonly scopes: ReadonlyArray<string>;
+    readonly refresh: 'automatic' | 'interactive';
+    /**
+     * Present ONLY when `available` is `false`: a one-line, jargon-free reason the
+     * tier is absent + how to restore it. Stops the empty `scopes: []` on a missing
+     * token from reading as a bug. Omitted entirely when the token is available.
+     */
+    readonly reason?: string;
+};
 type TokenInfo = {
     readonly scopes: ReadonlyArray<string>;
     readonly audience: string | undefined;
@@ -122,24 +168,14 @@ type TokenInfo = {
      * preflight elevated access in a fresh process instead of turning every
      * version download into a `403`.
      */
-    readonly elevated: {
-        readonly available: boolean;
-        readonly expiresInSeconds: number | undefined;
-    };
+    readonly elevated: TokenTierInfo;
     /**
-     * The two Teams-chat substrate tokens (chatsvcagg / ic3), same decode-only
-     * `{ available, expiresInSeconds }` shape as `elevated`. `login` reports all four
-     * tiers so a warm session can see every token's runway; both self-heal from the
-     * shared refresh token, so they are informational rather than a preflight gate.
+     * The two Teams-chat substrate tokens (chatsvcagg / ic3), same `TokenTierInfo`
+     * shape as `elevated`. Both self-heal from the shared refresh token (refresh:
+     * automatic), so they are informational rather than a preflight gate.
      */
-    readonly chatsvcagg: {
-        readonly available: boolean;
-        readonly expiresInSeconds: number | undefined;
-    };
-    readonly ic3: {
-        readonly available: boolean;
-        readonly expiresInSeconds: number | undefined;
-    };
+    readonly chatsvcagg: TokenTierInfo;
+    readonly ic3: TokenTierInfo;
 };
 type FetchFn = (url: string, init?: RequestInit) => Promise<Response>;
 declare const createGraphClient: (auth: AuthManager, fetchFn?: FetchFn) => GraphClient;

package/dist/presenter/graph-cursor.d.ts

@@ -0,0 +1,2 @@
+declare const canonicalizeGraphCursor: (link: string) => string;
+export { canonicalizeGraphCursor };

package/dist/presenter/output.d.ts

@@ -1,6 +1,6 @@
 import type { Logger } from '../use-cases/ports/logger.js';
 import type { ErrorSource } from './error-hints.js';
-type OutputFormat = 'text' | 'json';
+import type { OutputFormat } from './render-to-string.js';
 declare const render: (data: unknown, logger: Logger, format: OutputFormat) => void;
 declare const renderError: (message: string, format: OutputFormat, errorCode?: string, explicitSource?: ErrorSource, retryAfterSeconds?: number) => void;
 export { render, renderError };

package/dist/presenter/render-to-string.d.ts

@@ -0,0 +1,15 @@
+import type { ErrorSource } from './error-hints.js';
+type OutputFormat = 'text' | 'json';
+/**
+ * Render a use-case success value to its final string, newline included.
+ * `output.ts` writes this to stdout; `mcp.ts` returns it as tool content.
+ */
+declare const renderToString: (data: unknown, format: OutputFormat) => string;
+/**
+ * Render an error to its final string, newline included. The `hint` / `source`
+ * lookup is shared with the CLI so an MCP consumer sees the same curated
+ * remedies (`error-hints.ts`) the terminal does.
+ */
+declare const renderErrorToString: (message: string, format: OutputFormat, errorCode?: string, explicitSource?: ErrorSource, retryAfterSeconds?: number) => string;
+export { renderErrorToString, renderToString };
+export type { OutputFormat };

package/dist/use-cases/commands/build-command.d.ts

@@ -14,9 +14,26 @@ import { type ODataKey } from './odata-query.js';
 type SelectDefaults = {
     readonly defaultSelect?: string;
 };
+/**
+ * `defaultTop`, when set and the user did NOT pass `--top`, injects a `$top`
+ * into the OData query string. Its purpose is NOT payload-slimming (that is
+ * `defaultSelect`) but cursor correctness: a handful of `$skip`-offset-paged
+ * Graph endpoints (`/me/people` is the canonical one) only emit a
+ * self-advancing `@odata.nextLink` when `$top` is present. Without it Graph
+ * echoes back the SAME `$skip` on every page (`?$skip=0` → `?$skip=0` → …), so
+ * following the cursor loops forever on page 1. Forcing a default `$top` makes
+ * Graph increment `$skip` by the page size. Only meaningful on list builders
+ * whose OData shape carries `top`. User-supplied `--top` always wins.
+ */
+type ListDefaults = SelectDefaults & {
+    readonly defaultTop?: string;
+};
+declare const withDefaultSelect: <T extends {
+    readonly select?: string;
+}>(data: T, defaultSelect: string | undefined) => T;
 declare const buildCommand: (pathFn: (params: Record<string, string>) => string, schema: z.ZodType) => Pick<Command, "schema" | "execute">;
 declare const buildElevatedCommand: (pathFn: (params: Record<string, string>) => string, schema: z.ZodType) => Pick<Command, "schema" | "execute">;
-declare const buildListCommand: <Shape extends z.ZodRawShape>(pathFn: (params: z.infer<z.ZodObject<Shape>>) => string, schema: z.ZodObject<Shape>, options?: SelectDefaults) => Pick<Command, "schema" | "execute">;
+declare const buildListCommand: <Shape extends z.ZodRawShape>(pathFn: (params: z.infer<z.ZodObject<Shape>>) => string, schema: z.ZodObject<Shape>, options?: ListDefaults) => Pick<Command, "schema" | "execute">;
 declare const buildElevatedListCommand: <Shape extends z.ZodRawShape>(pathFn: (params: z.infer<z.ZodObject<Shape>>) => string, schema: z.ZodObject<Shape>, options?: SelectDefaults) => Pick<Command, "schema" | "execute">;
 /**
  * Single-resource GET that supports the OData `$select` and `$expand` query
@@ -67,4 +84,4 @@ declare const buildPickODataListCommand: <Shape extends z.ZodRawShape, K extends
  * `$orderby` / `$expand` with `BadRequest`, so the picker is the right tool.
  */
 declare const buildElevatedPickODataListCommand: <Shape extends z.ZodRawShape, K extends ODataKey>(pathFn: (params: z.infer<z.ZodObject<Shape>>) => string, schema: z.ZodObject<Shape>, keys: ReadonlyArray<K>, options?: SelectDefaults) => Pick<Command, "schema" | "execute">;
-export { buildCommand, buildElevatedCommand, buildElevatedListCommand, buildElevatedPickODataListCommand, buildElevatedSelectableCommand, buildFilterSelectListCommand, buildListCommand, buildNoSkipListCommand, buildPickODataListCommand, buildSelectableCommand, };
+export { buildCommand, buildElevatedCommand, buildElevatedListCommand, buildElevatedPickODataListCommand, buildElevatedSelectableCommand, buildFilterSelectListCommand, buildListCommand, buildNoSkipListCommand, buildPickODataListCommand, buildSelectableCommand, withDefaultSelect, };

package/dist/use-cases/commands/command-types.d.ts

@@ -109,20 +109,25 @@ type CommandMeta = {
     readonly scopesRequired?: ReadonlyArray<string>;
     /**
      * `true` if the command needs the M365ChatClient elevated token (captured
-     * at login from `m365.cloud.microsoft`, ODSP allow-list). Only 3 commands
-     * today — the historical-version downloads. An LLM should check this
-     * field before invoking; if the elevated capture failed at login, these
-     * commands will time out.
+     * at login from `m365.cloud.microsoft`, ODSP allow-list). The exact set is
+     * pinned in meta.test.ts, and the composition root derives the auth
+     * fail-fast message's command list from this flag — a new elevated command
+     * MUST carry it or the remedy message will omit the command. An LLM should
+     * check this field before invoking; if the elevated capture failed at
+     * login, these commands fail fast with `secondary_token_unavailable`.
      */
     readonly needsElevatedToken?: true;
     /**
-     * `true` if the command needs a Teams substrate token (chatsvcagg or ic3,
-     * captured at login from `teams.microsoft.com`) — the Teams chat-content
-     * commands. Like `needsElevatedToken`, an LLM should check this before
-     * invoking and warm up an interactive `login`; a headless or stale session
-     * times out on these (the non-interactive silent-SSO limitation, ).
+     * Which Teams substrate token the command needs: `'chatsvcagg'`
+     * (teams.microsoft.com/api/csa) or `'ic3'` (chat history), both captured
+     * at login from `teams.microsoft.com`. Truthy = "needs a substrate token"
+     * (the historical boolean semantics); the service value additionally
+     * routes the command into the right auth fail-fast list, derived by the
+     * composition root. Like `needsElevatedToken`, an LLM should check this
+     * before invoking and warm up an interactive `login`; a headless or stale
+     * session times out on these (the non-interactive silent-SSO limitation).
      */
-    readonly needsSubstrateToken?: true;
+    readonly needsSubstrateToken?: 'chatsvcagg' | 'ic3';
     /**
      * `true` if the command returns inlined bytes (`{contentType, size, base64}`
      * or `{contentType, size, text}`) and is therefore a valid target for the
@@ -167,7 +172,7 @@ type Command = {
     readonly meta: CommandMeta;
     /**
      * Present on the rare command whose input is the LOCAL filesystem instead of
-     * Graph (`convert-local-file`). The CLI routes execution here, passing its
+     * Graph (`convert-local-file-to-markdown`). The CLI routes execution here, passing its
      * composition-selected FileSystem; `execute` stays as the registry-typed
      * fallback that redirects library consumers to this variant.
      */

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

@@ -9,6 +9,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/{convert-drive-item-zip.d.ts → convert-drive-item-zip-to-markdown.d.ts}

@@ -14,12 +14,17 @@ import type { CommandMeta } from './command-types.js';
  * rather than failing the whole archive.
  */
 declare const schema: z.ZodObject<{
+    tenantId: z.ZodOptional<z.ZodString>;
     driveId: z.ZodString;
     itemId: z.ZodString;
     includeMetadata: z.ZodOptional<z.ZodEnum<{
         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/{convert-local-file.d.ts → convert-local-file-to-markdown.d.ts}

@@ -29,6 +29,10 @@ declare const schema: z.ZodObject<{
         true: "true";
         false: "false";
     }>>;
+    keepQuoted: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
     includeImages: z.ZodOptional<z.ZodEnum<{
         true: "true";
         false: "false";

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

@@ -9,9 +9,17 @@ declare const schema: z.ZodObject<{
         true: "true";
         false: "false";
     }>>;
+    keepQuoted: 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>>;
+type ConvertOptions = {
+    readonly includeMetadata: boolean;
+    readonly keepQuoted: boolean;
+};
+declare const convertFetchedAttachment: (graph: GraphClient, a: Record<string, unknown>, opts: ConvertOptions) => Promise<Result<unknown, GraphError>> | Result<unknown, GraphError>;
+declare const convertAttachmentToMarkdown: (graph: GraphClient, attachmentPath: string, opts: ConvertOptions) => Promise<Result<unknown, GraphError>>;
 declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
 declare const meta: CommandMeta;
 export { convertAttachmentToMarkdown, convertFetchedAttachment, execute, meta, schema };

package/dist/use-cases/commands/{convert-mail-attachment-zip.d.ts → convert-mail-attachment-zip-to-markdown.d.ts}

@@ -4,7 +4,7 @@ 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
+ * call — the mail-side mirror of `convert-drive-item-zip-to-markdown`. 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
@@ -18,6 +18,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/convert-mail-to-markdown.d.ts

@@ -2,6 +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';
+import { type InlineAttachment } from './inline-image-embedder.js';
 declare const schema: z.ZodObject<{
     messageId: z.ZodString;
     inlineImages: z.ZodOptional<z.ZodEnum<{
@@ -13,6 +14,39 @@ declare const schema: z.ZodObject<{
         false: "false";
     }>>;
 }, z.core.$strip>;
+declare const ATTACHMENT_METADATA_SELECT = "$select=id,name,contentType,size,isInline,microsoft.graph.fileAttachment/contentId";
+declare const attachmentMetaSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    contentType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    size: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    isInline: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    contentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+declare const attachmentsListSchema: z.ZodObject<{
+    value: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        contentType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        size: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        isInline: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        contentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type AttachmentMeta = z.infer<typeof attachmentMetaSchema>;
+declare const formatBytes: (n: number) => string;
+type InlineImageCandidate = AttachmentMeta & {
+    readonly contentType: string;
+    readonly contentId: string;
+};
+declare const isInlineImage: (a: AttachmentMeta) => a is InlineImageCandidate;
+type EmbedFetchResult = {
+    readonly meta: InlineImageCandidate;
+    readonly inline?: InlineAttachment;
+    readonly oversize: boolean;
+};
+declare const fetchInlineImageBytes: (graph: GraphClient, messageId: string, meta: InlineImageCandidate) => Promise<EmbedFetchResult>;
 declare const execute: (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, GraphError>>;
 declare const meta: CommandMeta;
-export { execute, meta, schema };
+export { ATTACHMENT_METADATA_SELECT, attachmentsListSchema, execute, fetchInlineImageBytes, formatBytes, isInlineImage, meta, schema };
+export type { AttachmentMeta, InlineImageCandidate };

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

@@ -6,6 +6,10 @@ declare const schema: z.ZodObject<{
     ccRecipients: z.ZodOptional<z.ZodString>;
     bodyContent: z.ZodString;
     subject: z.ZodOptional<z.ZodString>;
+    bodyContentType: z.ZodOptional<z.ZodEnum<{
+        Text: "Text";
+        HTML: "HTML";
+    }>>;
 }, z.core.$strip>;
 declare const execute: Command['execute'];
 declare const meta: CommandMeta;

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

@@ -4,6 +4,14 @@ declare const schema: z.ZodObject<{
     replyToMessageId: z.ZodString;
     bodyContent: z.ZodString;
     subject: z.ZodOptional<z.ZodString>;
+    replyAll: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
+    bodyContentType: z.ZodOptional<z.ZodEnum<{
+        Text: "Text";
+        HTML: "HTML";
+    }>>;
 }, z.core.$strip>;
 declare const execute: Command['execute'];
 declare const meta: CommandMeta;

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

@@ -3,8 +3,6 @@ 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;
     includeMetadata: z.ZodOptional<z.ZodEnum<{
         true: "true";
         false: "false";
@@ -13,7 +11,14 @@ declare const schema: z.ZodObject<{
         true: "true";
         false: "false";
     }>>;
+    keepQuoted: z.ZodOptional<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>;
     maxCells: z.ZodOptional<z.ZodString>;
+    tenantId: z.ZodOptional<z.ZodString>;
+    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;

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

@@ -3,6 +3,7 @@ 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<{
+    tenantId: z.ZodOptional<z.ZodString>;
     driveId: z.ZodString;
     itemId: z.ZodString;
 }, z.core.$strip>;

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

@@ -3,6 +3,7 @@ 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<{
+    tenantId: z.ZodOptional<z.ZodString>;
     driveId: z.ZodString;
     itemId: z.ZodString;
 }, z.core.$strip>;

package/dist/use-cases/commands/draft-comment-splicer.d.ts

@@ -0,0 +1,29 @@
+type SpliceResult = {
+    readonly html: string;
+    readonly boundaryFound: boolean;
+};
+type PlainTextSpliceResult = {
+    readonly text: string;
+    readonly boundaryFound: boolean;
+};
+/**
+ * Renders an author's plain text as HTML: markup they typed shows as characters
+ * rather than taking effect, and their newlines survive as breaks. No wrapper
+ * element, so the caller decides the block context.
+ */
+declare const escapeTextAsHtml: (text: string) => string;
+/** Index just past the `<body>` open tag, or 0 for a fragment that has none. */
+declare const findBodyInsertStart: (html: string) => number;
+/**
+ * True when the author's own markup carries a quote boundary marker, e.g. they
+ * pasted a reply chain into it. Such a comment must be refused: the splice would
+ * keep the marker verbatim, and the NEXT revision would cut the draft AT it,
+ * silently dropping the real quoted history below.
+ */
+declare const commentCarriesQuoteBoundary: (commentHtml: string) => boolean;
+/** The refusal copy for `commentCarriesQuoteBoundary`, named for the flag that carried it. */
+declare const boundaryMarkerRefusal: (flagName: string) => string;
+declare const insertCommentAboveQuote: (html: string, commentHtml: string) => SpliceResult;
+declare const replaceCommentAboveQuote: (html: string, commentHtml: string) => SpliceResult;
+declare const replacePlainTextCommentAboveQuote: (text: string, comment: string) => PlainTextSpliceResult;
+export { boundaryMarkerRefusal, commentCarriesQuoteBoundary, escapeTextAsHtml, findBodyInsertStart, insertCommentAboveQuote, replaceCommentAboveQuote, replacePlainTextCommentAboveQuote, };

package/dist/use-cases/commands/draft-dedup.d.ts

@@ -0,0 +1,18 @@
+declare const normalizeThreadSubject: (subject: string) => string;
+type DraftRecipient = {
+    readonly emailAddress?: {
+        readonly address?: string;
+    };
+};
+type DraftForMatch = {
+    readonly subject?: string;
+    readonly toRecipients?: ReadonlyArray<DraftRecipient>;
+    readonly ccRecipients?: ReadonlyArray<DraftRecipient>;
+};
+type DraftMatchCriteria = {
+    readonly subject: string;
+    readonly recipients?: ReadonlyArray<string>;
+};
+declare const matchExistingDrafts: <T extends DraftForMatch>(drafts: ReadonlyArray<T>, criteria: DraftMatchCriteria) => ReadonlyArray<T>;
+export { matchExistingDrafts, normalizeThreadSubject };
+export type { DraftForMatch, DraftMatchCriteria };

package/dist/use-cases/commands/draft-response.d.ts

@@ -0,0 +1,4 @@
+import { type Result } from '../../domain/result.js';
+import type { GraphError } from '../../infra/graph-client.js';
+declare const slimDraftResult: (result: Result<unknown, GraphError>) => Result<unknown, GraphError>;
+export { slimDraftResult };

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

@@ -3,6 +3,7 @@ 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<{
+    tenantId: z.ZodOptional<z.ZodString>;
     driveId: z.ZodString;
     itemId: z.ZodString;
 }, z.core.$strip>;

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

@@ -9,7 +9,7 @@ import type { CommandMeta } from './command-types.js';
  * (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
+ * local archive. Like `convert-local-file-to-markdown`, it never touches Graph and is
  * executed via `executeLocal(fs, params)`.
  */
 declare const schema: z.ZodObject<{

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

@@ -1,4 +1,5 @@
 import type { Result } from '../../domain/result.js';
+import type { TenantId } from '../../domain/tenant-id.js';
 import type { GraphClient, GraphError } from '../../infra/graph-client.js';
 /**
  * Helpers that consolidate the "Graph hands you a 302, follow the CDN
@@ -26,8 +27,20 @@ import type { GraphClient, GraphError } from '../../infra/graph-client.js';
  * redirects to a streamContent URL whose embedded tempauth is signed
  * by Teams web client identity and rejected by SharePoint with 403.
  */
+/**
+ * `elevated` picks the ODSP-allow-listed home identity (M365ChatClient).
+ * `tenantId` picks a PARTNER tenant's guest identity — for a file in a tenant the
+ * user is only a guest in, which no home-tier token can read (Graph answers `401
+ * invalidAudienceUri`).
+ *
+ * They are mutually exclusive by nature: elevated is a home-tenant identity, so
+ * "elevated in a partner tenant" does not exist. `tenantId` wins if both arrive,
+ * because a partner-tenant file is unreadable on ANY home token — including the
+ * elevated one — so honouring `elevated` there would guarantee failure.
+ */
 export type FetchOptions = {
     readonly elevated?: boolean;
+    readonly tenantId?: TenantId;
 };
 export type InlineBinary = {
     readonly contentType: string;

package/dist/use-cases/commands/find-mail-drafts.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import type { Command, CommandMeta } from './command-types.js';
+declare const schema: z.ZodObject<{
+    subject: z.ZodString;
+    toRecipients: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const execute: Command['execute'];
+declare const meta: CommandMeta;
+export { execute, meta, schema };