@dench.com/cli 3.6.3-staging.372 → 3.6.5-staging.384

package/README.md

@@ -465,3 +465,19 @@ Commands that need to impersonate a specific agent (`dench memory`,
 (`dench signin`) — the unified API key is org-scoped and cannot speak
 as a single agent. Those commands return a clear "agent session
 required" error in API-key mode.
+
+### Focused workspace context
+
+`dench context --instructions` reads explicit IDENTITY, RULES and TOOLS notes,
+plus document availability/revisions. It does not load business profiles,
+personal profiles or aggregate memory. Fetch only what the task needs:
+
+```sh
+dench context --sections organisation,user,memory --json
+```
+
+Section names are `identity`, `organisation`, `user`, `memory`, `rules`, and
+`tools`. Multiple names use one query. The existing `organisation show`,
+`user show`, and `mem show` commands use the same saved documents; reading never
+fills profiles or writes memory. Personal USER context is unavailable to shared
+channel sessions. `dench context --json` keeps its existing workspace overview.

package/agent-config.ts

@@ -215,22 +215,16 @@ async function handleSimpleMagicFile(
 ): Promise<void> {
   const sub = args[0];
   if (!sub || sub === "show") {
-    const config = await loadAgentConfig(ctx);
-    const value =
-      opts.field === "memoryAggregate"
-        ? config.agentConfig.memoryAggregate
-        : opts.field === "toolsNotes"
-          ? config.agentConfig.toolsNotes
-          : opts.field === "identity"
-            ? config.agentConfig.identity
-            : opts.field === "organisation"
-              ? config.agentConfig.organisation
-              : null;
-    if (opts.perMember) {
-      out(ctx, config.userProfile?.content ?? "(empty)");
-      return;
-    }
-    out(ctx, value?.content ?? "(empty)");
+    const context = (await runQuery(
+      ctx,
+      makeFunctionReference<"query">("functions/agentConfig:workspaceContext"),
+      { sections: [opts.label] },
+    )) as { documents: Array<{ name: string; content?: string }> };
+    out(
+      ctx,
+      context.documents.find((document) => document.name === opts.label)
+        ?.content || "(empty)",
+    );
     return;
   }
   if (sub === "edit" || sub === "set") {

package/app-sdk.d.ts

@@ -497,10 +497,17 @@ export interface ApiRequests {
     organizationId?: string;
     newOrganizationName?: string;
   };
+  /** Read selected scoped workspace documents and a compact context index without writes. — `dench context --sections` — GET /api/v1/context/sections */
+  "workspace.context.sections": {
+    organizationId?: string;
+    sections?: Array<"identity" | "organisation" | "user" | "memory" | "rules" | "tools">;
+  };
   /** Return the current Dench workspace context for the bearer. — `dench context` — GET /api/v1/context */
   "workspace.context": Record<string, unknown>;
   /** Return the current workspace's standing instructions for external agents. — `dench context --instructions` — GET /api/v1/context/instructions */
-  "workspace.instructions": Record<string, unknown>;
+  "workspace.instructions": {
+    organizationId?: string;
+  };
   /** Return workspace and agent status. — `dench status` — GET /api/v1/status */
   "workspace.status": Record<string, unknown>;
   /** List agents visible in the workspace status payload. — `dench agents` — GET /api/v1/agents */
@@ -2172,6 +2179,116 @@ export interface ApiRequests {
     /** Identity id, sender email, or domain (deletes every sender on the domain). Permanent: re-adding requires re-verification. */
     identity: string;
   };
+  /** Create an editable Dench email draft and synchronize its selected native mailbox asynchronously. Use a stable requestId for retries. — `dench email draft create` — POST /api/v1/email/drafts */
+  "email.drafts.create": {
+    organizationId?: string;
+    threadId?: string;
+    mailbox?: string;
+    requestId: string;
+    to?: {
+      email: string;
+      name?: string;
+    }[];
+    cc?: {
+      email: string;
+      name?: string;
+    }[];
+    bcc?: {
+      email: string;
+      name?: string;
+    }[];
+    subject?: string;
+    htmlBody?: string;
+    textBody?: string;
+    attachments?: {
+      storageId: string;
+      name: string;
+      contentType: string;
+      size: number;
+    }[];
+  };
+  /** Read an email draft, eligible senders and provider sync status. — `dench email draft show` — GET /api/v1/email/drafts/{draftId} */
+  "email.drafts.get": {
+    draftId: string;
+  };
+  /** List native mailboxes this caller may use. — `dench email draft senders` — GET /api/v1/email/drafts/senders */
+  "email.drafts.senders": {
+    organizationId?: string;
+  };
+  /** Save draft content using expectedRevision; sender changes require a new draft after provider binding. — `dench email draft update` — PATCH /api/v1/email/drafts/{draftId} */
+  "email.drafts.update": {
+    draftId: string;
+    expectedRevision: number;
+    patch: {
+      mailboxAccountId?: string;
+      to?: {
+        email: string;
+        name?: string;
+      }[];
+      cc?: {
+        email: string;
+        name?: string;
+      }[];
+      bcc?: {
+        email: string;
+        name?: string;
+      }[];
+      subject?: string;
+      htmlBody?: string;
+      textBody?: string;
+      attachments?: {
+        storageId: string;
+        name: string;
+        contentType: string;
+        size: number;
+      }[];
+    };
+  };
+  /** Send the current Dench draft revision through its native mailbox. Repeated requests share a durable receipt. — `dench email draft send` — POST /api/v1/email/drafts/{draftId}/send */
+  "email.drafts.send": {
+    draftId: string;
+    expectedRevision: number;
+    requestId?: string;
+  };
+  /** Upload attachment bytes authorized against this draft before adding its storage reference. — `dench email draft attach` — POST /api/v1/email/drafts/{draftId}/attachments */
+  "email.drafts.upload": {
+    draftId: string;
+    name: string;
+    contentType: string;
+    contentBase64: string;
+  };
+  /** Load the selected mailbox signature for explicit visible insertion. — `dench email draft signature` — GET /api/v1/email/drafts/{draftId}/signature */
+  "email.drafts.signature": {
+    draftId: string;
+  };
+  /** Send through a native Gmail or Outlook mailbox with a durable request receipt. Only use for an explicit send request. — `dench email send --mailbox` — POST /api/v1/email/native/send */
+  "email.native.send": {
+    organizationId?: string;
+    threadId?: string;
+    mailbox?: string;
+    requestId: string;
+    to?: {
+      email: string;
+      name?: string;
+    }[];
+    cc?: {
+      email: string;
+      name?: string;
+    }[];
+    bcc?: {
+      email: string;
+      name?: string;
+    }[];
+    subject?: string;
+    htmlBody?: string;
+    textBody?: string;
+    attachments?: {
+      storageId: string;
+      name: string;
+      contentType: string;
+      size: number;
+    }[];
+  };
   /** Send one raw email (no campaign): to/cc/bcc, custom from-name and reply-to, optional reply threading via replyToMessageId. — `dench email send` — POST /api/v1/email/send */
   "email.send": {
     /** Verified sender mailbox. */
@@ -3017,17 +3134,25 @@ export interface ApiRequests {
   /** Create a tool OAuth connection link. Slack is in-house, never a third-party connection: for toolkit slack the CLI prints the first-party install URL (/api/slack/install?slug=<workspace>, org admin) instead of calling this endpoint. — `dench tool connect` — POST /api/v1/tools/connections */
   "tool.connect": {
     /** Toolkit slug, e.g. github, gmail, stripe. */
-    toolkit: string;
+    toolkit?: string;
+    toolkit_slug?: string;
     /** Optional OAuth callback URL. */
     callback_url?: string;
+    /** Native OAuth return path within the workspace. */
+    returnTo?: string;
   };
   /** Search for external tool actions. — `dench tool search` — POST /api/v1/tools/search */
   "tool.search": {
-    queries: {
+    queries?: {
       /** Natural-language use case. */
       use_case: string;
       known_fields?: string;
     }[];
+    query?: string;
+    toolkit?: string;
+    toolkit_slug?: string;
+    limit?: number;
+    important?: boolean;
     session?: {
       id?: string;
       generate_id?: boolean;
@@ -3045,6 +3170,8 @@ export interface ApiRequests {
     /** Tool arguments object. */
     arguments?: Record<string, unknown>;
     account?: string;
+    connected_account_id?: string;
+    approvalId?: string;
   };
   /** Disconnect an external tool account. — `dench tool disconnect` — DELETE /api/v1/tools/connections/{connectionId} */
   "tool.disconnect": {
@@ -3374,6 +3501,7 @@ export interface ApiResponses {
       sessionExpiresAt?: number;
     };
   };
+  "workspace.context.sections": Record<string, unknown>;
   "workspace.context": {
     workspace: {
       id: string;
@@ -5319,6 +5447,54 @@ export interface ApiResponses {
       disabled: boolean;
     }[];
   };
+  "email.drafts.create": {
+    ok: boolean;
+    kind: "email";
+    draftId: string;
+    syncStatus: string;
+    revision: number;
+    [key: string]: unknown;
+  };
+  "email.drafts.get": {
+    ok: boolean;
+    kind: "email";
+    draftId: string;
+    syncStatus: string;
+    revision: number;
+    [key: string]: unknown;
+  };
+  "email.drafts.senders": Record<string, unknown>[];
+  "email.drafts.update": {
+    ok: boolean;
+    kind: "email";
+    draftId: string;
+    syncStatus: string;
+    revision: number;
+    [key: string]: unknown;
+  };
+  "email.drafts.send": {
+    ok: boolean;
+    kind: "email";
+    draftId: string;
+    syncStatus: string;
+    revision: number;
+    [key: string]: unknown;
+  };
+  "email.drafts.upload": {
+    storageId: string;
+    name: string;
+    contentType: string;
+    size: number;
+  };
+  "email.drafts.signature": Record<string, unknown>;
+  "email.native.send": {
+    ok: boolean;
+    kind: "email";
+    draftId: string;
+    syncStatus: string;
+    revision: number;
+    [key: string]: unknown;
+  };
   "email.send": {
     ok: boolean;
     /** Dench message id for `dench email message status`. */
@@ -6567,6 +6743,14 @@ export interface ApiResponses {
     /** OAuth URL the user opens to finish connecting. */
     redirect_url?: string;
     connection_id?: string;
+    redirectUrl?: string;
+    link?: string;
+    artifact?: {
+      kind: "connect";
+      data: {
+        toolkit: string;
+      };
+    };
     [key: string]: unknown;
   };
   "tool.search": {
@@ -6592,10 +6776,13 @@ export interface ApiResponses {
     /** Tool slug -> schema with gateway-added execution_ref for tool.run. */
     tool_schemas?: Record<string, Record<string, unknown>>;
     /** Tool-router session; reuse session.id for follow-up calls. */
-    session: {
+    session?: {
       id: string;
       [key: string]: unknown;
     };
+    items?: Record<string, unknown>[];
+    nativeAvailable?: boolean;
+    available?: boolean;
     execution_ref_version?: number;
     [key: string]: unknown;
   };
@@ -7810,6 +7997,22 @@ export type DenchApiTree = {
       /** Submit a campaign for approval or sending. (`dench email campaign submit`) */
       submit(args: Req<"email.campaign.submit">): Promise<Res<"email.campaign.submit">>;
     };
+    drafts: {
+      /** Create an editable Dench email draft and synchronize its selected native mailbox asynchronously. Use a stable requestId for retries. (`dench email draft create`) */
+      create(args: Req<"email.drafts.create">): Promise<Res<"email.drafts.create">>;
+      /** Read an email draft, eligible senders and provider sync status. (`dench email draft show`) */
+      get(args: Req<"email.drafts.get">): Promise<Res<"email.drafts.get">>;
+      /** Send the current Dench draft revision through its native mailbox. Repeated requests share a durable receipt. (`dench email draft send`) */
+      send(args: Req<"email.drafts.send">): Promise<Res<"email.drafts.send">>;
+      /** List native mailboxes this caller may use. (`dench email draft senders`) */
+      senders(args?: Req<"email.drafts.senders">): Promise<Res<"email.drafts.senders">>;
+      /** Load the selected mailbox signature for explicit visible insertion. (`dench email draft signature`) */
+      signature(args: Req<"email.drafts.signature">): Promise<Res<"email.drafts.signature">>;
+      /** Save draft content using expectedRevision; sender changes require a new draft after provider binding. (`dench email draft update`) */
+      update(args: Req<"email.drafts.update">): Promise<Res<"email.drafts.update">>;
+      /** Upload attachment bytes authorized against this draft before adding its storage reference. (`dench email draft attach`) */
+      upload(args: Req<"email.drafts.upload">): Promise<Res<"email.drafts.upload">>;
+    };
     identity: {
       /** Begin the full Dench sender verification flow for a sending identity. (`dench email identity verify`) */
       beginVerification(args: Req<"email.identity.beginVerification">): Promise<Res<"email.identity.beginVerification">>;
@@ -7838,6 +8041,10 @@ export type DenchApiTree = {
       /** List recent raw email messages for the workspace. (`dench email message list`) */
       list(args?: Req<"email.message.list">): Promise<Res<"email.message.list">>;
     };
+    native: {
+      /** Send through a native Gmail or Outlook mailbox with a durable request receipt. Only use for an explicit send request. (`dench email send --mailbox`) */
+      send(args: Req<"email.native.send">): Promise<Res<"email.native.send">>;
+    };
     /** Send one raw email (no campaign): to/cc/bcc, custom from-name and reply-to, optional reply threading via replyToMessageId. (`dench email send`) */
     send(args: Req<"email.send">): Promise<Res<"email.send">>;
     sequence: {
@@ -8126,8 +8333,13 @@ export type DenchApiTree = {
       /** List artifacts for the authenticated workspace. (`dench artifacts`) */
       list(args?: Req<"workspace.artifacts.list">): Promise<Res<"workspace.artifacts.list">>;
     };
-    /** Return the current Dench workspace context for the bearer. (`dench context`) */
-    context(args?: Req<"workspace.context">): Promise<Res<"workspace.context">>;
+    context: {
+      /** Return the current Dench workspace context for the bearer. (`dench context`) */
+      (args?: Req<"workspace.context">): Promise<Res<"workspace.context">>;
+      $call(args?: Req<"workspace.context">): Promise<Res<"workspace.context">>;
+      /** Read selected scoped workspace documents and a compact context index without writes. (`dench context --sections`) */
+      sections(args?: Req<"workspace.context.sections">): Promise<Res<"workspace.context.sections">>;
+    };
     /** Return the current workspace's standing instructions for external agents. (`dench context --instructions`) */
     instructions(args?: Req<"workspace.instructions">): Promise<Res<"workspace.instructions">>;
     /** Return workspace and agent status. (`dench status`) */
@@ -8555,6 +8767,22 @@ export interface DenchCampaigns {
 }
 
 export interface DenchEmail {
+  /** Create a native mailbox draft with a stable request receipt. Permission: `email:write`. Wraps `email.drafts.create`. */
+  createDraft(draft: Req<"email.drafts.create">): Promise<Res<"email.drafts.create">>;
+  /** Read a native email draft and sync status. Permission: `email:read`. Wraps `email.drafts.get`. */
+  draft(draftId: string): Promise<Res<"email.drafts.get">>;
+  /** Save the next email draft revision. Permission: `email:write`. Wraps `email.drafts.update`. */
+  updateDraft(input: Req<"email.drafts.update">): Promise<Res<"email.drafts.update">>;
+  /** Send the frozen native email draft revision. Permission: `email:write`. Wraps `email.drafts.send`. */
+  sendDraft(input: Req<"email.drafts.send">): Promise<Res<"email.drafts.send">>;
+  /** List eligible native mailboxes. Permission: `email:read`. Wraps `email.drafts.senders`. */
+  senders(opts?: Req<"email.drafts.senders">): Promise<Res<"email.drafts.senders">>;
+  /** Upload attachment bytes for a native draft. Permission: `email:write`. Wraps `email.drafts.upload`. */
+  uploadAttachment(input: Req<"email.drafts.upload">): Promise<Res<"email.drafts.upload">>;
+  /** Load the selected mailbox signature for visible insertion. Permission: `email:read`. Wraps `email.drafts.signature`. */
+  signature(draftId: string): Promise<Res<"email.drafts.signature">>;
+  /** Explicitly send through a native Gmail or Outlook mailbox. Permission: `email:write`. Wraps `email.native.send`. */
+  sendFromMailbox(message: Req<"email.native.send">): Promise<Res<"email.native.send">>;
   /** Send one email from a verified identity. Permission: `email:write`. Wraps `email.send`. */
   send(message: Req<"email.send">): Promise<Res<"email.send">>;
   /** Sent messages. Permission: `email:read`. Wraps `email.message.list`. */

package/crm.ts

@@ -450,6 +450,13 @@ function parseCreateManyRows(items: unknown[]): JsonRecord[] {
   );
 }
 
+function parseDedupeFieldFlag(raw: string | undefined): string | undefined {
+  if (raw !== undefined && !raw.trim()) {
+    throw new CrmCliError("--dedupe-key must name a non-empty CRM field");
+  }
+  return raw;
+}
+
 /**
  * Stable per-row dedupe key derived from a named column. Values are
  * normalized (String → trim → lowercase) so `" Jane@X.com"` and
@@ -464,6 +471,16 @@ function dedupeKeyFromColumn(opts: {
   command: string;
 }): string {
   const raw = opts.row[opts.column];
+  if (
+    raw !== null &&
+    raw !== undefined &&
+    typeof raw !== "string" &&
+    (typeof raw !== "number" || !Number.isFinite(raw))
+  ) {
+    throw new CrmCliError(
+      `${opts.command}: row ${opts.rowIndex + 1} must have a string or finite number for --dedupe-key column "${opts.column}"`,
+    );
+  }
   const normalized =
     raw === null || raw === undefined ? "" : String(raw).trim().toLowerCase();
   if (!normalized) {
@@ -571,6 +588,8 @@ export type CrmBatchOp =
       data: JsonRecord;
       /** Stable per-row dedupe key (server upserts on conflict). */
       seedKey?: string;
+      /** Match existing CRM entries by this scalar field before writing. */
+      matchField?: string;
       /** 1-based source row for server-side error messages. */
       rowIndex?: number;
     }
@@ -2638,10 +2657,18 @@ async function runEntriesCommand(ctx: CrmCliContext): Promise<void> {
       const objectName = shift(ctx.args, "object name");
       const dataRaw = getDataFlag(ctx.args);
       const idempotencyKey = getFlag(ctx.args, "--idempotency-key");
-      // Per-row idempotency: derive a stable seedKey from this column so
-      // re-running the same create-many cannot duplicate rows. Rows whose
-      // key already exists are skipped (`status: "already_existed"`).
-      const dedupeColumn = getFlag(ctx.args, "--dedupe-key");
+      // Match ordinary existing records by this field, retaining the
+      // stable seedKey for retry compatibility with earlier CLI versions.
+      const dedupeColumn = parseDedupeFieldFlag(
+        getFlag(ctx.args, "--dedupe-key"),
+      );
+      const onConflictFlag = getFlag(ctx.args, "--on-conflict");
+      const onConflict = parseOnConflictFlag(onConflictFlag);
+      if (onConflictFlag !== undefined && !dedupeColumn) {
+        throw new CrmCliError(
+          "crm entries create-many: --on-conflict requires --dedupe-key <field>",
+        );
+      }
       const allowUnknown = hasFlag(ctx.args, "--allow-unknown");
       const rows = parseCreateManyRows(
         await readJsonArrayInput({
@@ -2670,12 +2697,16 @@ async function runEntriesCommand(ctx: CrmCliContext): Promise<void> {
           objectName,
           data,
           ...(seedKeys
-            ? { seedKey: seedKeys[index], rowIndex: index + 1 }
+            ? {
+                seedKey: seedKeys[index],
+                matchField: dedupeColumn,
+                rowIndex: index + 1,
+              }
             : {}),
         })),
         idempotencyKey,
         allowUnknown,
-        seedKeys ? "skip" : undefined,
+        seedKeys ? onConflict : undefined,
       );
       // Only claim per-row links when we actually got a result per row. A
       // silently-empty `results` is indistinguishable from "this object has
@@ -2687,7 +2718,10 @@ async function runEntriesCommand(ctx: CrmCliContext): Promise<void> {
       out(ctx, {
         created: statusCounts ? statusCounts.created : rows.length,
         ...(statusCounts
-          ? { alreadyExisted: statusCounts.alreadyExisted }
+          ? {
+              alreadyExisted: statusCounts.alreadyExisted,
+              updated: statusCounts.updated,
+            }
           : {}),
         chunks,
         ...(linked > 0
@@ -2788,6 +2822,11 @@ async function runEntriesCommand(ctx: CrmCliContext): Promise<void> {
       const _objectName = shift(ctx.args, "object name");
       const entryId = shift(ctx.args, "entry id");
       assertNoUnknownFlags(ctx.args, "crm entries delete");
+      if (ctx.args.length > 0) {
+        throw new CrmCliError(
+          "crm entries delete accepts exactly one entry ID. For multiple entries, use dench crm entries bulk-delete <object> --ids id1,id2,... or crm batch with entries.delete operations.",
+        );
+      }
       out(
         ctx,
         await callMutation(ctx, api.entries.remove, {
@@ -3519,7 +3558,7 @@ async function runImportCommand(ctx: CrmCliContext): Promise<void> {
   const csvPath = getFlag(ctx.args, "--csv");
   const jsonlPath = getFlag(ctx.args, "--jsonl");
   const mapJson = getFlag(ctx.args, "--map");
-  const dedupeColumn = getFlag(ctx.args, "--dedupe-key");
+  const dedupeColumn = parseDedupeFieldFlag(getFlag(ctx.args, "--dedupe-key"));
   const onConflict = parseOnConflictFlag(getFlag(ctx.args, "--on-conflict"));
   assertNoUnknownFlags(ctx.args, "crm import");
   if (!csvPath && !jsonlPath) {
@@ -3557,10 +3596,11 @@ async function runImportCommand(ctx: CrmCliContext): Promise<void> {
       dedupeColumn,
       sha256,
     }),
+    ...(dedupeColumn ? { matchField: dedupeColumn } : {}),
     rowIndex: index + 1,
   }));
-  // batch.apply enforces the on-conflict policy per row against the
-  // (objectId, seedKey) index; chunking is handled by the shared helper.
+  // batch.apply matches the selected CRM field when supplied; otherwise
+  // seedKey protects exact reruns. The shared helper handles chunking.
   const { results } = await applyBatchOpsInChunks(
     ctx,
     ops,
@@ -4840,9 +4880,10 @@ Tasks (shortcuts over the protected 'task' object):
   dench crm entries create <object> --data '{"Field":"Value",...}'    (alias: --fields) [--allow-unknown] [--idempotency-key <key>]
       --idempotency-key upserts on (object, key): a retried create returns
       the existing row with alreadyExisted: true instead of duplicating it.
-  dench crm entries create-many <object> --data '[{"Field":"Value",...}]' [--file rows.json] [--idempotency-key <key>] [--dedupe-key <column>] [--allow-unknown]
-      --dedupe-key <column> makes each row idempotent by that column's
-      value; rows that already exist are skipped (status: already_existed).
+  dench crm entries create-many <object> --data '[{"Field":"Value",...}]' [--file rows.json] [--idempotency-key <key>] [--dedupe-key <field>] [--on-conflict skip|update|error] [--allow-unknown]
+      --dedupe-key <field> matches existing CRM rows by field value,
+      including rows created outside imports. --on-conflict requires it;
+      default skip leaves matches untouched, update merges, error aborts.
   dench crm entries update <object> <entryId> --data '{...}'           (alias: --fields) [--allow-unknown]
   dench crm entries update-many <object> --updates '[{"id":"...","data":{...}}]' [--file updates.json] [--idempotency-key <key>] [--allow-unknown]
   dench crm entries delete <object> <entryId>
@@ -4934,9 +4975,14 @@ Batch:
 Import / export:
   dench crm import <object> --csv leads.csv [--map '{"Email":"Email Address"}'] [--on-conflict skip|update|error] [--dedupe-key <column>]
   dench crm import <object> --jsonl rows.jsonl
-      Imports are idempotent: every row gets a stable dedupe key (content
-      hash, or --dedupe-key <column>), so re-running the same file skips /
-      updates / errors per --on-conflict instead of duplicating rows.
+      --dedupe-key names the CRM field AFTER --map. Values match existing
+      rows after trim + lowercase; supported fields are text, email, phone,
+      URL, single-select enum, or number. Blank/non-scalar values fail.
+      Number fields compare numeric values ("01" matches 1).
+      Multiple matches or an incomplete bounded lookup abort the current
+      batch without writes; earlier batches may already have committed.
+      Without --dedupe-key, a content-hash key protects exact reimports
+      only; it does not match ordinary existing records by field value.
   dench crm export <object> --format csv|jsonl [--limit N]
       Pages with a real cursor and verifies no duplicate ids before
       emitting; a summary (exportedCount/uniqueIds) is printed to stderr.