@open-mercato/core 0.6.1-develop.3291.1.6fad645fd0 → 0.6.1-develop.3306.1.9ad9ff2526

package/src/modules/customers/AGENTS.md

@@ -102,7 +102,12 @@ This module is the reference implementation for the AI framework. Copy `ai-agent
 |----------|------|--------|---------|
 | `customers.account_assistant` | chat | read-only (mutation-capable via per-tenant override that unlocks `customers.update_deal_stage`; see `packages/core/src/modules/customers/ai-agents.ts` for the whitelist and prompt) | Operator-facing assistant that explores people, companies, deals, activities, tasks, addresses, tags, and settings through the customers tool pack. |
 | `customers.update_deal_stage` | tool (mutation) | `destructive-confirm-required` — goes through `prepareMutation` + the approval card | Moves a deal between stages / flips status between open, won, lost. Declared via `defineAiTool` in `ai-tools.ts` and exposed only when the tenant mutation-policy override promotes the agent above read-only. |
+| `customers.deal_analyzer` | chat, `executionEngine: 'stream-text'` | `confirm-required` | Multi-step agentic demo that exercises loop primitives from PRs #1856..#1869. Calls `customers.analyze_deals`, ranks deals by health score, then calls `customers.update_deal_stage` for the highest-value stalled deal — loop stops immediately after (loop.stopWhen). `loop.prepareStep` scopes the active tool set by step without overriding the model. It intentionally leaves `defaultProvider` and `defaultModel` unset so runtime resolution uses `OM_AI_PROVIDER` / `OM_AI_MODEL` or tenant/runtime overrides. |
+| `customers.deal_analyzer_tool_loop` | chat, `executionEngine: 'tool-loop-agent'` | `confirm-required` | Sibling agent identical to `customers.deal_analyzer` but dispatched via `ToolLoopAgent`. Proves the mutation-approval gate holds for both execution engines (TC-AI-AGENT-LOOP-006). |
 
 `<AiChat agent="customers.account_assistant" />` is injected in two places (both live in `widgets/injection/`):
-- People list: `data-table:customers.people.list:header` via the `ai-assistant-trigger` widget.
+- People list: `data-table:customers.people.list:search-trailing` via the `ai-assistant-trigger` widget.
 - Deal detail: `detail:customers.deal:header` via the `ai-deal-detail-trigger` widget.
+
+`<AiChat agent="customers.deal_analyzer" />` is injected on the Deals list page:
+- Deals list: `data-table:customers.deals.list:search-trailing` via the `ai-deal-analyzer-trigger` widget. Selected deal IDs are passed as `pageContext.recordId` (comma-separated UUIDs) so the agent can scope its `customers.analyze_deals` call to the operator's current selection.

package/src/modules/customers/ai-agents.ts

@@ -1,6 +1,10 @@
 /**
  * Module-root AI agent contribution for the customers module.
  *
+ * See /framework/ai-assistant/agents for the structured PromptTemplate
+ * convention and the per-tenant override path that can downgrade
+ * mutationPolicy to read-only.
+ *
  * The generator walks every module root for a top-level `ai-agents.ts` and
  * takes the default/`aiAgents` export as the agent contribution. The
  * `customers.account_assistant` agent explores people / companies / deals /
@@ -15,11 +19,7 @@
  *
  * Prompt is declared as a structured `PromptTemplate` (not a flat string)
  * per spec §8 with the seven named sections: ROLE, SCOPE, DATA, TOOLS,
- * ATTACHMENTS, MUTATION POLICY, RESPONSE STYLE. The composed string is
- * fed into `systemPrompt` so the existing runtime continues to work, and
- * the structured template is additionally exported so downstream Phases
- * (5.3 prompt-override merge, 5.2 resolvePageContext hydration) can
- * address sections by name.
+ * ATTACHMENTS, MUTATION POLICY, RESPONSE STYLE.
  */
 import type {
   AiAgentDefinition,
@@ -303,6 +303,213 @@ const agent: AiAgentDefinition = {
   resolvePageContext,
 }
 
-export const aiAgents: AiAgentDefinition[] = [agent]
+// customers.deal_analyzer — multi-step agentic loop demo.
+// See /framework/ai-assistant/agents → "Deal Analyzer demo" for the loop
+// primitives exercised here; the sibling tool-loop-agent below proves both
+// execution engines honor the mutation gate.
+
+type DealAnalyzerPromptSectionName =
+  | 'role'
+  | 'scope'
+  | 'data'
+  | 'tools'
+  | 'mutationPolicy'
+  | 'responseStyle'
+
+interface DealAnalyzerPromptSection {
+  name: DealAnalyzerPromptSectionName
+  content: string
+  order: number
+}
+
+const DEAL_ANALYZER_PROMPT_SECTIONS: DealAnalyzerPromptSection[] = [
+  {
+    name: 'role',
+    order: 1,
+    content: [
+      'ROLE',
+      'You are the Deal Analyzer inside Open Mercato. You are a multi-step agentic',
+      'assistant that analyzes the health of a tenant\'s open deals, surfaces stalled',
+      'opportunities, and proposes pipeline stage transitions for operator approval.',
+    ].join('\n'),
+  },
+  {
+    name: 'scope',
+    order: 2,
+    content: [
+      'SCOPE',
+      'Stay inside the customers module. Respect tenant and organization isolation.',
+      'ALWAYS call customers.analyze_deals as your FIRST tool call — do not skip this.',
+      'Reason about stalled deals: any deal with no activity for more than 14 days',
+      'is considered stalled. For each stalled deal with a value greater than $5,000',
+      'propose a stage move via customers.update_deal_stage.',
+      'After calling customers.update_deal_stage, finish with a concise conclusion',
+      'summarizing the analysis and the approval action the operator should review.',
+    ].join('\n'),
+  },
+  {
+    name: 'data',
+    order: 3,
+    content: [
+      'DATA',
+      'You can read: customers.deal via customers.analyze_deals (analytical summary)',
+      'and customers.list_deals / customers.get_deal (full detail).',
+      'Use customers.analyze_deals first — it returns a ranked list of deals by',
+      'health score (lowest = most at risk) with last-activity information.',
+      'Use customers.list_activities to get more detail on a specific deal\'s activity.',
+      'Use search.hybrid_search only for free-text queries spanning multiple entity types.',
+      'CRITICAL: Only use IDs returned by a prior tool call. Never invent or guess UUIDs.',
+    ].join('\n'),
+  },
+  {
+    name: 'tools',
+    order: 4,
+    content: [
+      'TOOLS',
+      'Primary tools for this agent (call in this order on each turn):',
+      '1. customers.analyze_deals — analytical overview of deals ranked by health score.',
+      '   Supply dealStageFilter="open" to restrict to open deals.',
+      '2. customers.update_deal_stage — propose a stage move for a stalled high-value deal.',
+      '   The runtime intercepts this via the pending-action gate; do NOT claim the change',
+      '   is saved until the mutation-result-card arrives.',
+      'Secondary read tools (use when you need more detail):',
+      '- customers.list_deals, customers.get_deal, customers.list_activities',
+      '- search.hybrid_search, meta.describe_agent',
+    ].join('\n'),
+  },
+  {
+    name: 'mutationPolicy',
+    order: 5,
+    content: [
+      'MUTATION POLICY',
+      'This agent ships with mutationPolicy: "confirm-required". Every write goes through',
+      'the pending-action approval card and only persists after the operator confirms it.',
+      'After calling customers.update_deal_stage, explain whether a pending approval',
+      'card was created or whether the proposed move could not be prepared.',
+      'Do NOT call update_deal_stage more than once per turn.',
+      'If a per-tenant override has downgraded this agent to read-only, tell the operator',
+      'the write is locked and point to /backend/customers/deals/<id>.',
+    ].join('\n'),
+  },
+  {
+    name: 'responseStyle',
+    order: 6,
+    content: [
+      'RESPONSE STYLE',
+      '',
+      '═══════════════════════════════════════════════════════════════════════',
+      'RULE #1 — DEAL RECORD CARDS ARE MANDATORY',
+      '═══════════════════════════════════════════════════════════════════════',
+      'For every deal you surface in your analysis you MUST emit an open-mercato:deal',
+      'fenced card. Use the deal id, title, value, and stage from the tool output.',
+      'Always populate href with /backend/customers/deals/<id>.',
+      '',
+      'Card schema: { "id", "title", "status"?, "stage"?, "amount"?, "currency"?,',
+      '  "closeDate"?, "ownerName"?, "personName"?, "companyName"?,',
+      '  "description"?, "tags"?, "href" }',
+      '',
+      '═══════════════════════════════════════════════════════════════════════',
+      'RULE #2 — Analysis format',
+      '═══════════════════════════════════════════════════════════════════════',
+      'Lead with a one-paragraph summary of the deal portfolio health, then emit one',
+      'deal card per at-risk deal (sorted by health score ascending). After the cards,',
+      'propose exactly one stage move for the highest-value stalled deal and call',
+      'customers.update_deal_stage. Then finish with a short conclusion naming the',
+      'highest-value stalled deal, the recommended move, and the approval status.',
+    ].join('\n'),
+  },
+]
+
+function compileDealAnalyzerPrompt(): string {
+  return DEAL_ANALYZER_PROMPT_SECTIONS.slice()
+    .sort((a, b) => a.order - b.order)
+    .map((section) => section.content.trim())
+    .join('\n\n')
+}
+
+const DEAL_ANALYZER_ALLOWED_TOOLS: readonly string[] = [
+  'customers.analyze_deals',
+  'customers.update_deal_stage',
+  'customers.list_deals',
+  'customers.get_deal',
+  'customers.list_activities',
+  'search.hybrid_search',
+  'meta.describe_agent',
+]
+
+function buildDealAnalyzerPrepareStep() {
+  return async function dealAnalyzerPrepareStep(state: { stepNumber: number }) {
+    if (state.stepNumber === 0) {
+      return {
+        activeTools: [
+          'customers.analyze_deals',
+          'customers.list_deals',
+          'customers.get_deal',
+          'customers.list_activities',
+          'search.hybrid_search',
+          'meta.describe_agent',
+        ],
+      }
+    }
+    return { activeTools: [...DEAL_ANALYZER_ALLOWED_TOOLS] }
+  }
+}
+
+const dealAnalyzer: AiAgentDefinition = {
+  id: 'customers.deal_analyzer',
+  moduleId: 'customers',
+  label: 'Deal Analyzer',
+  description:
+    'Multi-step CRM agent that analyzes deals, surfaces stalled opportunities, and proposes stage transitions for operator approval.',
+  systemPrompt: compileDealAnalyzerPrompt(),
+  allowedTools: [...DEAL_ANALYZER_ALLOWED_TOOLS],
+  executionMode: 'chat',
+  executionEngine: 'stream-text',
+  allowRuntimeOverride: true,
+  readOnly: false,
+  mutationPolicy: 'confirm-required',
+  requiredFeatures: ['customers.deals.view'],
+  uiParts: ['open-mercato:deal'],
+  keywords: ['deal', 'pipeline', 'stalled', 'crm', 'analysis', 'health'],
+  domain: 'customers',
+  loop: {
+    maxSteps: 12,
+    prepareStep: buildDealAnalyzerPrepareStep() as AiAgentDefinition['loop'] extends undefined
+      ? never
+      : NonNullable<AiAgentDefinition['loop']>['prepareStep'],
+    budget: {
+      maxToolCalls: 12,
+      maxWallClockMs: 60_000,
+    },
+    allowRuntimeOverride: true,
+  },
+  dataCapabilities: {
+    entities: ['customers.deal', 'customers.activity'],
+    operations: ['read', 'search', 'aggregate'],
+  },
+  suggestions: [
+    {
+      label: 'Analyze stalled deals',
+      prompt: 'Analyze stalled deals from the last 30 days and propose a stage move for the highest value one',
+    },
+    {
+      label: 'Show at-risk pipeline',
+      prompt: 'Show me deals with no activity in the last 14 days worth more than $5,000',
+    },
+  ],
+}
+
+// Sibling agent identical to customers.deal_analyzer except for
+// executionEngine: 'tool-loop-agent' (TC-AI-AGENT-LOOP-006).
+const dealAnalyzerToolLoop: AiAgentDefinition = {
+  ...dealAnalyzer,
+  id: 'customers.deal_analyzer_tool_loop',
+  label: 'Deal Analyzer (ToolLoopAgent)',
+  description:
+    'Same as customers.deal_analyzer but dispatched via the ToolLoopAgent engine. Used by TC-AI-AGENT-LOOP-006 mutation-gate proof scenario.',
+  executionEngine: 'tool-loop-agent',
+}
+
+export const aiAgents: AiAgentDefinition[] = [agent, dealAnalyzer, dealAnalyzerToolLoop]
 
 export default aiAgents

package/src/modules/customers/ai-tools/deal-analyzer-pack.ts

@@ -0,0 +1,286 @@
+/**
+ * `customers.analyze_deals` — analytical read-only tool for the deal_analyzer
+ * agent (Step d1 of the deal-analyzer-demo).
+ *
+ * Reads deals scoped to the caller tenant/org, enriches each deal with the
+ * most recent activity timestamp (days-since-last-activity), computes a simple
+ * healthScore, and returns a ranked list. The handler issues two bounded DB
+ * reads (deals + activities) — no N+1.
+ *
+ * `customers.update_deal_stage` already exists in deals-pack.ts and is
+ * imported and re-exported here so the deal_analyzer agent's `allowedTools`
+ * list can reference both under a single pack. The tool itself is NOT
+ * redeclared here.
+ */
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { z } from 'zod'
+import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import {
+  CustomerDeal,
+  CustomerActivity,
+  CustomerDealPersonLink,
+  CustomerEntity,
+} from '../data/entities'
+import {
+  assertTenantScope,
+  type CustomersAiToolDefinition,
+  type CustomersToolContext,
+} from './types'
+
+function refIdOf(ref: unknown): string | undefined {
+  if (!ref) return undefined
+  if (typeof ref === 'string') return ref
+  if (typeof ref === 'object' && typeof (ref as { id?: unknown }).id === 'string') {
+    return (ref as { id: string }).id
+  }
+  return undefined
+}
+
+function resolveEm(ctx: CustomersToolContext): EntityManager {
+  return ctx.container.resolve<EntityManager>('em')
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(Math.max(value, min), max)
+}
+
+/**
+ * Compute a health score for a deal:
+ *   healthScore = clamp((30 - daysSinceLastActivity) / 30 * 100, 0, 100)
+ * A deal with activity within the last 30 days scores > 0. Deals with no
+ * activity default to daysSinceLastActivity = activityWindow so they score 0.
+ * Exported for unit testing.
+ */
+export function computeHealthScore(daysSinceLastActivity: number): number {
+  return clamp(((30 - daysSinceLastActivity) / 30) * 100, 0, 100)
+}
+
+const analyzeDealsInput = z.object({
+  dealStageFilter: z
+    .string()
+    .optional()
+    .describe(
+      'Optional pipeline stage name or status slug to restrict results (e.g. "open", "qualification", "negotiation").',
+    ),
+  daysOfActivityWindow: z
+    .number()
+    .int()
+    .min(1)
+    .max(365)
+    .default(30)
+    .describe(
+      'Number of days to look back for "last activity" calculation. Deals with no activity in this window are flagged as stalled. Default 30.',
+    ),
+  limit: z
+    .number()
+    .int()
+    .min(1)
+    .max(100)
+    .default(25)
+    .describe('Maximum number of deals to return, ranked by healthScore ascending (most at-risk first). Default 25.'),
+})
+
+type AnalyzeDealsInput = z.infer<typeof analyzeDealsInput>
+
+type DealAnalysisItem = {
+  id: string
+  title: string
+  value: number | null
+  valueCurrency: string | null
+  stage: string | null
+  status: string
+  daysSinceLastActivity: number
+  primaryContact: string | null
+  healthScore: number
+}
+
+type AnalyzeDealsOutput = {
+  deals: DealAnalysisItem[]
+  totalAnalyzed: number
+  stalledCount: number
+  windowDays: number
+}
+
+export function msTodays(ms: number): number {
+  return Math.floor(ms / (1000 * 60 * 60 * 24))
+}
+
+const analyzeDealsToolDefinition: CustomersAiToolDefinition<AnalyzeDealsInput, AnalyzeDealsOutput> = {
+  name: 'customers.analyze_deals',
+  displayName: 'Analyze deals',
+  description:
+    'Fetch and analyze open deals for the caller tenant. Returns each deal with its days-since-last-activity and a health score (0–100, lower = more stalled). Results are ranked most-at-risk first.',
+  inputSchema: analyzeDealsInput as z.ZodType<AnalyzeDealsInput>,
+  requiredFeatures: ['customers.deals.view'],
+  tags: ['read', 'customers', 'analytics'],
+  isMutation: false,
+  handler: async (rawInput, ctx): Promise<AnalyzeDealsOutput> => {
+    const { tenantId } = assertTenantScope(ctx)
+    const input = analyzeDealsInput.parse(rawInput)
+    const em = resolveEm(ctx)
+    const scope = { tenantId, organizationId: ctx.organizationId }
+
+    // Build deal filter
+    const dealWhere: Record<string, unknown> = {
+      tenantId,
+      deletedAt: null,
+    }
+    if (ctx.organizationId) dealWhere.organizationId = ctx.organizationId
+    // Apply stage/status filter when provided. `$or` is composed with the
+    // outer `deletedAt: null` filter — both must hold — so the caller-supplied
+    // value matches either the canonical status slug or the stage label.
+    if (input.dealStageFilter) {
+      const filterValue = input.dealStageFilter.trim()
+      if (filterValue.length) {
+        dealWhere.$or = [
+          { status: filterValue },
+          { pipelineStage: filterValue },
+        ]
+      }
+    }
+
+    const deals = await findWithDecryption<CustomerDeal>(
+      em,
+      CustomerDeal,
+      dealWhere as any,
+      {
+        orderBy: { updatedAt: 'desc' },
+        limit: Math.min(input.limit * 4, 400), // Fetch extra so we can rank properly
+      },
+      scope,
+    )
+
+    if (!deals.length) {
+      return { deals: [], totalAnalyzed: 0, stalledCount: 0, windowDays: input.daysOfActivityWindow }
+    }
+
+    const dealIds = deals.map((d) => d.id)
+
+    // Fetch most recent activity per deal within the window in one batch.
+    // CustomerActivity has encrypted columns (subject, body); use the
+    // tenant-aware helper even though this query only reads occurredAt/deal,
+    // so future readers cannot accidentally surface ciphertext.
+    const activityWhere: Record<string, unknown> = {
+      deal: { $in: dealIds },
+      tenantId,
+    }
+    if (ctx.organizationId) activityWhere.organizationId = ctx.organizationId
+    const activities = await findWithDecryption<CustomerActivity>(
+      em,
+      CustomerActivity,
+      activityWhere as any,
+      {
+        orderBy: { occurredAt: 'desc' },
+        limit: 1000,
+      },
+      scope,
+    )
+
+    const lastActivityByDeal = new Map<string, Date>()
+    for (const activity of activities) {
+      const refId = refIdOf((activity as { deal?: unknown }).deal)
+      if (!refId) continue
+      const activityDate = activity.occurredAt ?? activity.createdAt
+      if (!activityDate) continue
+      const existing = lastActivityByDeal.get(refId)
+      if (!existing || activityDate > existing) {
+        lastActivityByDeal.set(refId, activityDate)
+      }
+    }
+
+    // Fetch primary contacts for deals in one batch. CustomerDealPersonLink
+    // has no encrypted columns, but the linked CustomerEntity.display_name is
+    // encrypted, so resolve names via findWithDecryption rather than
+    // populating the relation through raw em.find.
+    const personLinkWhere: Record<string, unknown> = {
+      deal: { $in: dealIds },
+    }
+    const personLinks = await em.find(
+      CustomerDealPersonLink,
+      personLinkWhere as any,
+      { limit: 500 },
+    )
+
+    const linksByDeal = new Map<string, string>() // dealId → personId (first link wins)
+    for (const link of personLinks) {
+      const dealRefId = refIdOf((link as { deal?: unknown }).deal)
+      const personRefId = refIdOf((link as { person?: unknown }).person)
+      if (!dealRefId || !personRefId) continue
+      if (!linksByDeal.has(dealRefId)) linksByDeal.set(dealRefId, personRefId)
+    }
+
+    const primaryContactByDeal = new Map<string, string>()
+    const personIds = Array.from(new Set(linksByDeal.values()))
+    if (personIds.length) {
+      const personWhere: Record<string, unknown> = {
+        id: { $in: personIds },
+        tenantId,
+      }
+      if (ctx.organizationId) personWhere.organizationId = ctx.organizationId
+      const persons = await findWithDecryption<CustomerEntity>(
+        em,
+        CustomerEntity,
+        personWhere as any,
+        undefined,
+        scope,
+      )
+      const nameByPersonId = new Map<string, string>()
+      for (const person of persons) {
+        const name = person.displayName
+        if (typeof name === 'string' && name.length) {
+          nameByPersonId.set(person.id, name)
+        }
+      }
+      for (const [dealId, personId] of linksByDeal) {
+        const name = nameByPersonId.get(personId)
+        if (name) primaryContactByDeal.set(dealId, name)
+      }
+    }
+
+    const now = Date.now()
+    const analyzed: DealAnalysisItem[] = deals.map((deal) => {
+      const lastActivity = lastActivityByDeal.get(deal.id)
+      const daysSinceLastActivity = lastActivity
+        ? msTodays(now - lastActivity.getTime())
+        : input.daysOfActivityWindow // Treat as fully stalled when no activity
+      const value = deal.valueAmount ? parseFloat(String(deal.valueAmount)) : null
+      return {
+        id: deal.id,
+        title: deal.title,
+        value: Number.isFinite(value) ? value : null,
+        valueCurrency: deal.valueCurrency ?? null,
+        stage: deal.pipelineStage ?? deal.status ?? null,
+        status: deal.status ?? 'open',
+        daysSinceLastActivity,
+        primaryContact: primaryContactByDeal.get(deal.id) ?? null,
+        healthScore: Math.round(computeHealthScore(daysSinceLastActivity)),
+      }
+    })
+
+    // Sort most-at-risk first (lowest health score first, then by value desc)
+    analyzed.sort((a, b) => {
+      if (a.healthScore !== b.healthScore) return a.healthScore - b.healthScore
+      const aVal = a.value ?? 0
+      const bVal = b.value ?? 0
+      return bVal - aVal
+    })
+
+    const truncated = analyzed.slice(0, input.limit)
+    const stalledCount = truncated.filter(
+      (d) => d.daysSinceLastActivity >= input.daysOfActivityWindow,
+    ).length
+
+    return {
+      deals: truncated,
+      totalAnalyzed: deals.length,
+      stalledCount,
+      windowDays: input.daysOfActivityWindow,
+    }
+  },
+}
+
+export const dealAnalyzerAiTools: CustomersAiToolDefinition[] = [
+  analyzeDealsToolDefinition as unknown as CustomersAiToolDefinition,
+]
+
+export default dealAnalyzerAiTools

package/src/modules/customers/ai-tools.ts

@@ -20,6 +20,7 @@ import dealsAiTools from './ai-tools/deals-pack'
 import activitiesTasksAiTools from './ai-tools/activities-tasks-pack'
 import addressesTagsAiTools from './ai-tools/addresses-tags-pack'
 import settingsAiTools from './ai-tools/settings-pack'
+import dealAnalyzerAiTools from './ai-tools/deal-analyzer-pack'
 import type { CustomersAiToolDefinition } from './ai-tools/types'
 
 export const aiTools: CustomersAiToolDefinition[] = [
@@ -29,6 +30,7 @@ export const aiTools: CustomersAiToolDefinition[] = [
   ...activitiesTasksAiTools,
   ...addressesTagsAiTools,
   ...settingsAiTools,
+  ...dealAnalyzerAiTools,
 ]
 
 export default aiTools

package/src/modules/customers/backend/customers/companies/page.tsx

@@ -496,6 +496,16 @@ export default function CustomersCompaniesPage() {
           {
             fallbackErrorMessage: t('customers.companies.list.deleteError', 'Failed to delete company.'),
             logTag: 'customers.companies.list',
+            progress: {
+              jobType: 'customers.companies.bulk_delete',
+              name: t('customers.companies.list.bulkDelete.progressName', 'Delete selected companies'),
+              description: t(
+                'customers.companies.list.bulkDelete.progressDescription',
+                '{count} companies selected for deletion',
+                { count: selectedRows.length },
+              ),
+              meta: { source: 'customers.companies.list' },
+            },
           },
         ),
       context: {

package/src/modules/customers/backend/customers/deals/page.tsx

@@ -505,6 +505,16 @@ export default function CustomersDealsPage() {
           {
             fallbackErrorMessage: t('customers.deals.list.deleteError', 'Failed to delete deal.'),
             logTag: 'customers.deals.list',
+            progress: {
+              jobType: 'customers.deals.bulk_delete',
+              name: t('customers.deals.list.bulkDelete.progressName', 'Delete selected deals'),
+              description: t(
+                'customers.deals.list.bulkDelete.progressDescription',
+                '{count} deals selected for deletion',
+                { count: selectedRows.length },
+              ),
+              meta: { source: 'customers.deals.list' },
+            },
           },
         ),
       context: {

package/src/modules/customers/backend/customers/people/page.tsx

@@ -509,6 +509,16 @@ export default function CustomersPeoplePage() {
           {
             fallbackErrorMessage: t('customers.people.list.deleteError', 'Failed to delete person.'),
             logTag: 'customers.people.list',
+            progress: {
+              jobType: 'customers.people.bulk_delete',
+              name: t('customers.people.list.bulkDelete.progressName', 'Delete selected people'),
+              description: t(
+                'customers.people.list.bulkDelete.progressDescription',
+                '{count} people selected for deletion',
+                { count: selectedRows.length },
+              ),
+              meta: { source: 'customers.people.list' },
+            },
           },
         ),
       context: {