ask-marcel-office-cli 2.1.0 → 2.3.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,7 +1,7 @@
 import type { Logger } from '../use-cases/ports/logger.js';
 import type { ErrorSource } from './error-hints.js';
-type OutputFormat = 'text' | 'json';
-declare const render: (data: unknown, logger: Logger, format: OutputFormat) => void;
+import type { OutputFormat, SizeHintContext } from './render-to-string.js';
+declare const render: (data: unknown, logger: Logger, format: OutputFormat, context?: SizeHintContext) => void;
 declare const renderError: (message: string, format: OutputFormat, errorCode?: string, explicitSource?: ErrorSource, retryAfterSeconds?: number) => void;
 export { render, renderError };
 export type { OutputFormat };

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

@@ -0,0 +1,47 @@
+import type { ErrorSource } from './error-hints.js';
+type OutputFormat = 'text' | 'json';
+/**
+ * Which front end the caller is on. It changes what a remedy can even BE: a
+ * terminal caller can redirect stdout to a file, an MCP client cannot (it has
+ * no shell), and the `--output-path` flag reaches MCP as an `outputPath` tool
+ * param rather than a flag.
+ */
+type RenderSurface = 'cli' | 'mcp';
+/**
+ * What the presenter needs in order to name a remedy the caller can actually
+ * use. Built in composition (which owns the command manifest); omitted by the
+ * renders that have no command behind them at all — the 548 KB `list-commands`
+ * manifest, a login summary, a logout status.
+ *
+ * 2026-07-23: the banner used to call `--output-path` a "universal remedy
+ * (works on every command)". It is not. Plain-JSON commands REFUSE the flag,
+ * and the two commands that trip the banner most often (`search-all-files`,
+ * `microsoft-search-query`) advertise only `--query` — so every remedy the
+ * banner named was a dead end there, and an agentic caller following it burned
+ * a call to find out.
+ */
+type SizeHintContext = {
+    readonly commandName: string;
+    /** `meta.producesBytes` — the manifest flag that decides whether --output-path is accepted. */
+    readonly producesBytes: boolean;
+    readonly supportsSelect: boolean;
+    readonly supportsTop: boolean;
+    readonly surface: RenderSurface;
+};
+/**
+ * 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.
+ *
+ * `context` is what makes the oversized-response banner honest — pass it
+ * whenever a registry command produced the data. Omit it for the renders that
+ * have no command behind them; the banner then claims no flag-level remedy.
+ */
+declare const renderToString: (data: unknown, format: OutputFormat, context?: SizeHintContext) => 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, RenderSurface, SizeHintContext };

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

@@ -5,10 +5,6 @@ type CommandSchema = z.ZodType;
 type CommandExecute = (graph: GraphClient, params: Record<string, string>) => Promise<Result<unknown, import('../../infra/graph-client.js').GraphError>>;
 type CommandCategory = 'drive' | 'excel' | 'sharepoint' | 'tasks' | 'mail' | 'notes' | 'user' | 'calendar' | 'chats' | 'teams' | 'meta' | 'lifecycle';
 type CommandHttpMethod = 'GET' | 'POST' | 'PATCH' | 'DELETE';
-type CommandOptionAlias = {
-    readonly name: string;
-    readonly key: string;
-};
 /**
  * Structured type-hint for a CLI flag value. Surfaces in `help-json` so an
  * LLM can avoid the trial-and-error of "is this an ID or a name?" prose
@@ -38,13 +34,6 @@ type CommandOptionMeta = {
      * commands accept but do not demand.
      */
     readonly required: boolean;
-    /**
-     * Optional secondary spellings of the same flag. Both the canonical
-     * `name` and every alias name are accepted on the command line; values
-     * passed under an alias are normalized to the canonical `key` before
-     * the schema runs. The canonical name is what `--help` shows first.
-     */
-    readonly aliases?: ReadonlyArray<CommandOptionAlias>;
     /**
      * Structured value-type hint for LLM consumers. Optional.
      */
@@ -80,14 +69,6 @@ type PaginationStrategy =
 type CommandMeta = {
     readonly summary: string;
     readonly category: CommandCategory;
-    /**
-     * Deprecated former command names kept working as commander-level aliases for
-     * back-compat after a rename (e.g. `download-onedrive-file-content` →
-     * `download-drive-item-content`). The canonical registry key is what `--help`
-     * and the manifest list first; each alias here is also accepted on the CLI and
-     * surfaced in the manifest so an LLM that learned the old name still resolves.
-     */
-    readonly commandAliases?: ReadonlyArray<string>;
     readonly graphMethod: CommandHttpMethod;
     readonly graphPathTemplate: string;
     readonly graphDocsUrl: string;
@@ -109,20 +90,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,10 +153,10 @@ 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.
      */
     readonly executeLocal?: (fs: import('../ports/filesystem.js').FileSystem, params: Record<string, string>) => Promise<Result<unknown, import('../../infra/graph-client.js').GraphError>>;
 };
-export type { ArgumentHint, Command, CommandCategory, CommandExecute, CommandHttpMethod, CommandMeta, CommandOptionAlias, CommandOptionMeta, CommandPositionalArgumentMeta, CommandSchema, PaginationStrategy, };
+export type { ArgumentHint, Command, CommandCategory, CommandExecute, CommandHttpMethod, CommandMeta, CommandOptionMeta, CommandPositionalArgumentMeta, CommandSchema, PaginationStrategy, };

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

@@ -4,8 +4,12 @@ declare const schema: z.ZodObject<{
     forwardMessageId: z.ZodString;
     toRecipients: z.ZodString;
     ccRecipients: z.ZodOptional<z.ZodString>;
-    bodyContent: z.ZodString;
+    comment: 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

@@ -2,8 +2,16 @@ import { z } from 'zod';
 import type { Command, CommandMeta } from './command-types.js';
 declare const schema: z.ZodObject<{
     replyToMessageId: z.ZodString;
-    bodyContent: z.ZodString;
+    comment: 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/docs-render.d.ts

@@ -3,7 +3,6 @@ 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;

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>;