@open-mercato/ai-assistant 0.5.1-develop.3036.f02c281f23 → 0.5.1-develop.3045.b4b3320cc2

package/src/modules/ai_assistant/migrations/Migration20260419100521.ts

@@ -0,0 +1,17 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20260419100521_ai_assistant extends Migration {
+
+  override async up(): Promise<void> {
+    this.addSql(`create table "ai_agent_prompt_overrides" ("id" uuid not null default gen_random_uuid(), "tenant_id" uuid not null, "organization_id" uuid null, "agent_id" text not null, "version" int not null, "sections" jsonb not null, "notes" text null, "created_by_user_id" uuid null, "created_at" timestamptz not null, "updated_at" timestamptz not null, constraint "ai_agent_prompt_overrides_pkey" primary key ("id"));`);
+    this.addSql(`create unique index "ai_agent_prompt_overrides_tenant_org_agent_version_uq" on "ai_agent_prompt_overrides" ("tenant_id", "organization_id", "agent_id", "version") where "organization_id" is not null;`);
+    this.addSql(`create unique index "ai_agent_prompt_overrides_tenant_agent_version_null_org_uq" on "ai_agent_prompt_overrides" ("tenant_id", "agent_id", "version") where "organization_id" is null;`);
+    this.addSql(`create index "ai_agent_prompt_overrides_tenant_org_agent_version_idx" on "ai_agent_prompt_overrides" ("tenant_id", "organization_id", "agent_id", "version" desc);`);
+    this.addSql(`create index "ai_agent_prompt_overrides_tenant_agent_idx" on "ai_agent_prompt_overrides" ("tenant_id", "agent_id");`);
+  }
+
+  override async down(): Promise<void> {
+    this.addSql(`drop table if exists "ai_agent_prompt_overrides" cascade;`);
+  }
+
+}

package/src/modules/ai_assistant/migrations/Migration20260419132948.ts

@@ -0,0 +1,16 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20260419132948_ai_assistant extends Migration {
+
+  override async up(): Promise<void> {
+    this.addSql(`create table "ai_agent_mutation_policy_overrides" ("id" uuid not null default gen_random_uuid(), "tenant_id" uuid not null, "organization_id" uuid null, "agent_id" text not null, "mutation_policy" text not null, "notes" text null, "created_by_user_id" uuid null, "created_at" timestamptz not null, "updated_at" timestamptz not null, constraint "ai_agent_mutation_policy_overrides_pkey" primary key ("id"));`);
+    this.addSql(`create unique index "ai_agent_mutation_policy_overrides_tenant_org_agent_uq" on "ai_agent_mutation_policy_overrides" ("tenant_id", "organization_id", "agent_id") where "organization_id" is not null;`);
+    this.addSql(`create unique index "ai_agent_mutation_policy_overrides_tenant_agent_null_org_uq" on "ai_agent_mutation_policy_overrides" ("tenant_id", "agent_id") where "organization_id" is null;`);
+    this.addSql(`create index "ai_agent_mutation_policy_overrides_tenant_agent_idx" on "ai_agent_mutation_policy_overrides" ("tenant_id", "agent_id");`);
+  }
+
+  override async down(): Promise<void> {
+    this.addSql(`drop table if exists "ai_agent_mutation_policy_overrides" cascade;`);
+  }
+
+}

package/src/modules/ai_assistant/migrations/Migration20260419134235.ts

@@ -0,0 +1,17 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20260419134235_ai_assistant extends Migration {
+
+  override async up(): Promise<void> {
+    this.addSql(`create table "ai_pending_actions" ("id" uuid not null default gen_random_uuid(), "tenant_id" uuid not null, "organization_id" uuid null, "agent_id" text not null, "tool_name" text not null, "conversation_id" text null, "target_entity_type" text null, "target_record_id" text null, "normalized_input" jsonb not null, "field_diff" jsonb not null default '[]', "records" jsonb null, "failed_records" jsonb null, "side_effects_summary" text null, "record_version" text null, "attachment_ids" jsonb not null default '[]', "idempotency_key" text not null, "created_by_user_id" uuid not null, "status" text not null, "queue_mode" text not null default 'inline', "execution_result" jsonb null, "created_at" timestamptz not null, "expires_at" timestamptz not null, "resolved_at" timestamptz null, "resolved_by_user_id" uuid null, constraint "ai_pending_actions_pkey" primary key ("id"));`);
+    this.addSql(`create unique index "ai_pending_actions_tenant_org_idempotency_uq" on "ai_pending_actions" ("tenant_id", "organization_id", "idempotency_key") where "organization_id" is not null;`);
+    this.addSql(`create unique index "ai_pending_actions_tenant_idem_null_org_uq" on "ai_pending_actions" ("tenant_id", "idempotency_key") where "organization_id" is null;`);
+    this.addSql(`create index "ai_pending_actions_tenant_org_agent_status_idx" on "ai_pending_actions" ("tenant_id", "organization_id", "agent_id", "status");`);
+    this.addSql(`create index "ai_pending_actions_tenant_org_status_expires_idx" on "ai_pending_actions" ("tenant_id", "organization_id", "status", "expires_at");`);
+  }
+
+  override async down(): Promise<void> {
+    this.addSql(`drop table if exists "ai_pending_actions" cascade;`);
+  }
+
+}

package/src/modules/ai_assistant/setup.ts

@@ -1,5 +1,54 @@
 import type { ModuleSetupConfig } from '@open-mercato/shared/modules/setup'
 
+const PENDING_ACTION_CLEANUP_SCHEDULE_ID = 'ai_assistant:pending-action-cleanup'
+
+/**
+ * System-scoped recurring schedule: every 5 minutes, enqueue a job to the
+ * `ai-pending-action-cleanup` queue so the worker can sweep rows whose TTL
+ * elapsed without any confirm/cancel activity (Step 5.12). The schedule id
+ * is stable and `scheduler.register()` is an upsert, so calling this from
+ * every tenant bootstrap stays idempotent.
+ */
+async function ensurePendingActionCleanupSchedule(
+  container: import('awilix').AwilixContainer | undefined,
+): Promise<void> {
+  if (!container) return
+  let schedulerService:
+    | {
+        register: (registration: Record<string, unknown>) => Promise<void>
+      }
+    | undefined
+  try {
+    schedulerService = container.resolve('schedulerService')
+  } catch {
+    schedulerService = undefined
+  }
+  if (!schedulerService) return
+  try {
+    await schedulerService.register({
+      id: PENDING_ACTION_CLEANUP_SCHEDULE_ID,
+      name: 'AI pending-action cleanup',
+      description:
+        'Sweep pending AI mutation approvals whose TTL elapsed without confirm/cancel and flip them to expired.',
+      scopeType: 'system',
+      scheduleType: 'interval',
+      scheduleValue: '5m',
+      timezone: 'UTC',
+      targetType: 'queue',
+      targetQueue: 'ai-pending-action-cleanup',
+      targetPayload: {},
+      sourceType: 'module',
+      sourceModule: 'ai_assistant',
+      isEnabled: true,
+    })
+  } catch (error) {
+    console.warn(
+      '[ai_assistant] Failed to register pending-action cleanup schedule:',
+      error instanceof Error ? error.message : error,
+    )
+  }
+}
+
 export const setup: ModuleSetupConfig = {
   defaultRoleFeatures: {
     admin: [
@@ -12,6 +61,10 @@ export const setup: ModuleSetupConfig = {
     ],
     employee: ['ai_assistant.view'],
   },
+
+  async seedDefaults({ container }) {
+    await ensurePendingActionCleanupSchedule(container)
+  },
 }
 
 export default setup

package/src/modules/ai_assistant/workers/__tests__/ai-pending-action-cleanup.test.ts

@@ -0,0 +1,333 @@
+import { runPendingActionCleanup } from '../ai-pending-action-cleanup'
+import type { AiPendingAction } from '../../data/entities'
+import {
+  AiPendingActionStateError,
+  type AiPendingActionStatus,
+} from '../../lib/pending-action-types'
+
+type Row = AiPendingAction & Record<string, unknown>
+
+function makeRow(overrides: Partial<Row> = {}): Row {
+  return {
+    id: overrides.id ?? 'pa_1',
+    tenantId: overrides.tenantId ?? 'tenant-alpha',
+    organizationId: (overrides as { organizationId?: string | null }).organizationId ?? 'org-alpha',
+    agentId: overrides.agentId ?? 'catalog.merchandising_assistant',
+    toolName: overrides.toolName ?? 'catalog.update_product',
+    status: (overrides.status ?? 'pending') as AiPendingActionStatus,
+    fieldDiff: [],
+    records: null,
+    failedRecords: null,
+    sideEffectsSummary: null,
+    recordVersion: 'v-1',
+    attachmentIds: [],
+    normalizedInput: {},
+    queueMode: 'inline',
+    executionResult: null,
+    targetEntityType: 'product',
+    targetRecordId: 'p-1',
+    conversationId: null,
+    idempotencyKey: overrides.idempotencyKey ?? 'idem-1',
+    createdByUserId: 'user-1',
+    createdAt: overrides.createdAt ?? new Date('2026-04-18T09:00:00.000Z'),
+    expiresAt:
+      (overrides as { expiresAt?: Date }).expiresAt ?? new Date('2026-04-18T09:15:00.000Z'),
+    resolvedAt: null,
+    resolvedByUserId: null,
+    ...overrides,
+  } as Row
+}
+
+interface RepoStubOptions {
+  seeds: Row[]
+  /** ids that should throw AiPendingActionStateError when setStatus is invoked. */
+  raceIds?: string[]
+  /** ids that should throw a generic error from setStatus. */
+  errorIds?: string[]
+}
+
+function makeRepoStub(options: RepoStubOptions) {
+  const store = new Map<string, Row>()
+  for (const row of options.seeds) {
+    store.set(row.id, { ...row })
+  }
+  const raceIds = new Set(options.raceIds ?? [])
+  const errorIds = new Set(options.errorIds ?? [])
+
+  const listExpired = jest.fn(
+    async (
+      ctx: { tenantId: string; organizationId?: string | null },
+      now: Date,
+      limit: number,
+    ) => {
+      const all = Array.from(store.values()).filter((row) => {
+        if (row.tenantId !== ctx.tenantId) return false
+        const expected = ctx.organizationId ?? null
+        if ((row.organizationId ?? null) !== expected) return false
+        if (row.status !== 'pending') return false
+        return row.expiresAt.getTime() < now.getTime()
+      })
+      all.sort((a, b) => a.expiresAt.getTime() - b.expiresAt.getTime())
+      return all.slice(0, limit)
+    },
+  )
+
+  const setStatus = jest.fn(
+    async (
+      id: string,
+      next: AiPendingActionStatus,
+      _ctx: { tenantId: string; organizationId?: string | null },
+      extra?: { now?: Date; resolvedByUserId?: string | null },
+    ) => {
+      const existing = store.get(id)
+      if (!existing) throw new Error(`row ${id} not found`)
+      if (raceIds.has(id)) {
+        throw new AiPendingActionStateError(existing.status, next)
+      }
+      if (errorIds.has(id)) {
+        throw new Error(`boom-${id}`)
+      }
+      if (existing.status === next) return existing
+      existing.status = next
+      existing.resolvedAt = extra?.now ?? new Date()
+      if (extra && 'resolvedByUserId' in extra) {
+        existing.resolvedByUserId = extra.resolvedByUserId ?? null
+      }
+      return existing
+    },
+  )
+
+  return {
+    repo: { listExpired, setStatus } as unknown as import('../../data/repositories/AiPendingActionRepository').AiPendingActionRepository,
+    listExpired,
+    setStatus,
+    store,
+  }
+}
+
+describe('runPendingActionCleanup', () => {
+  const clock = new Date('2026-04-18T10:00:00.000Z')
+  const em = {} as import('@mikro-orm/postgresql').EntityManager
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('happy path: flips 3 expired rows and emits one ai.action.expired per row', async () => {
+    const seeds = [
+      makeRow({ id: 'pa-1', idempotencyKey: 'k1' }),
+      makeRow({ id: 'pa-2', idempotencyKey: 'k2' }),
+      makeRow({ id: 'pa-3', idempotencyKey: 'k3' }),
+    ]
+    const { repo, setStatus } = makeRepoStub({ seeds })
+    const emitEvent = jest.fn().mockResolvedValue(undefined)
+
+    const summary = await runPendingActionCleanup({
+      em,
+      repo,
+      emitEvent,
+      now: clock,
+      discoverTenants: async () => [
+        { tenantId: 'tenant-alpha', organizationId: 'org-alpha' },
+      ],
+    })
+
+    expect(setStatus).toHaveBeenCalledTimes(3)
+    for (const call of setStatus.mock.calls) {
+      expect(call[1]).toBe('expired')
+      expect(call[3]).toMatchObject({ resolvedByUserId: null })
+    }
+    expect(emitEvent).toHaveBeenCalledTimes(3)
+    for (const [eventId, payload] of emitEvent.mock.calls) {
+      expect(eventId).toBe('ai.action.expired')
+      expect(payload.resolvedByUserId).toBeNull()
+      expect(payload.status).toBe('expired')
+      expect(payload.tenantId).toBe('tenant-alpha')
+      expect(payload.organizationId).toBe('org-alpha')
+    }
+    expect(summary).toEqual({
+      tenantsScanned: 1,
+      rowsProcessed: 3,
+      rowsExpired: 3,
+      rowsSkipped: 0,
+      rowsErrored: 0,
+    })
+  })
+
+  it('race-safe: rows flipped under us are caught, logged, and skipped (no emit)', async () => {
+    const seeds = [
+      makeRow({ id: 'pa-1' }),
+      makeRow({ id: 'pa-raced' }),
+      makeRow({ id: 'pa-3' }),
+    ]
+    const { repo, setStatus } = makeRepoStub({
+      seeds,
+      raceIds: ['pa-raced'],
+    })
+    const emitEvent = jest.fn().mockResolvedValue(undefined)
+
+    const summary = await runPendingActionCleanup({
+      em,
+      repo,
+      emitEvent,
+      now: clock,
+      discoverTenants: async () => [
+        { tenantId: 'tenant-alpha', organizationId: 'org-alpha' },
+      ],
+    })
+
+    expect(setStatus).toHaveBeenCalledTimes(3)
+    // Only successful rows produce events
+    const emittedIds = emitEvent.mock.calls.map(([, payload]) => payload.pendingActionId)
+    expect(emittedIds.sort()).toEqual(['pa-1', 'pa-3'])
+    expect(summary.rowsExpired).toBe(2)
+    expect(summary.rowsSkipped).toBe(1)
+    expect(summary.rowsErrored).toBe(0)
+  })
+
+  it('paginates: more than pageSize expired rows take multiple fetch cycles', async () => {
+    const seeds: Row[] = []
+    for (let i = 0; i < 5; i += 1) {
+      seeds.push(
+        makeRow({
+          id: `pa-${i}`,
+          idempotencyKey: `k-${i}`,
+          expiresAt: new Date(clock.getTime() - (10 - i) * 1000),
+        }),
+      )
+    }
+    const { repo, listExpired, setStatus } = makeRepoStub({ seeds })
+    const emitEvent = jest.fn().mockResolvedValue(undefined)
+
+    const summary = await runPendingActionCleanup({
+      em,
+      repo,
+      emitEvent,
+      now: clock,
+      pageSize: 2,
+      discoverTenants: async () => [
+        { tenantId: 'tenant-alpha', organizationId: 'org-alpha' },
+      ],
+    })
+
+    // 5 rows, pageSize 2 → pages of 2,2,1 → 3 listExpired calls
+    expect(listExpired).toHaveBeenCalledTimes(3)
+    expect(setStatus).toHaveBeenCalledTimes(5)
+    expect(emitEvent).toHaveBeenCalledTimes(5)
+    expect(summary.rowsProcessed).toBe(5)
+    expect(summary.rowsExpired).toBe(5)
+  })
+
+  it('cross-tenant: rows from tenant A and tenant B both get processed', async () => {
+    const seeds = [
+      makeRow({ id: 'pa-a1', tenantId: 'tenant-alpha', organizationId: 'org-a' }),
+      makeRow({ id: 'pa-b1', tenantId: 'tenant-beta', organizationId: 'org-b' }),
+      makeRow({ id: 'pa-b2', tenantId: 'tenant-beta', organizationId: 'org-b' }),
+    ]
+    const { repo, setStatus } = makeRepoStub({ seeds })
+    const emitEvent = jest.fn().mockResolvedValue(undefined)
+
+    const summary = await runPendingActionCleanup({
+      em,
+      repo,
+      emitEvent,
+      now: clock,
+      discoverTenants: async () => [
+        { tenantId: 'tenant-alpha', organizationId: 'org-a' },
+        { tenantId: 'tenant-beta', organizationId: 'org-b' },
+      ],
+    })
+
+    expect(setStatus).toHaveBeenCalledTimes(3)
+    const tenantIds = emitEvent.mock.calls.map(([, payload]) => payload.tenantId)
+    expect(tenantIds.sort()).toEqual(['tenant-alpha', 'tenant-beta', 'tenant-beta'])
+    expect(summary.tenantsScanned).toBe(2)
+    expect(summary.rowsExpired).toBe(3)
+  })
+
+  it('zero-expired: empty tenant list emits no events and completes cleanly', async () => {
+    const { repo, setStatus, listExpired } = makeRepoStub({ seeds: [] })
+    const emitEvent = jest.fn().mockResolvedValue(undefined)
+
+    const summary = await runPendingActionCleanup({
+      em,
+      repo,
+      emitEvent,
+      now: clock,
+      discoverTenants: async () => [],
+    })
+
+    expect(listExpired).not.toHaveBeenCalled()
+    expect(setStatus).not.toHaveBeenCalled()
+    expect(emitEvent).not.toHaveBeenCalled()
+    expect(summary).toEqual({
+      tenantsScanned: 0,
+      rowsProcessed: 0,
+      rowsExpired: 0,
+      rowsSkipped: 0,
+      rowsErrored: 0,
+    })
+  })
+
+  it('single-row error does not abort the batch', async () => {
+    const seeds = [
+      makeRow({ id: 'pa-good-1' }),
+      makeRow({ id: 'pa-boom' }),
+      makeRow({ id: 'pa-good-2' }),
+    ]
+    const { repo, setStatus } = makeRepoStub({
+      seeds,
+      errorIds: ['pa-boom'],
+    })
+    const emitEvent = jest.fn().mockResolvedValue(undefined)
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
+
+    try {
+      const summary = await runPendingActionCleanup({
+        em,
+        repo,
+        emitEvent,
+        now: clock,
+        discoverTenants: async () => [
+          { tenantId: 'tenant-alpha', organizationId: 'org-alpha' },
+        ],
+      })
+
+      expect(setStatus).toHaveBeenCalledTimes(3)
+      // Only the two good rows emit
+      const emittedIds = emitEvent.mock.calls.map(([, payload]) => payload.pendingActionId)
+      expect(emittedIds.sort()).toEqual(['pa-good-1', 'pa-good-2'])
+      expect(summary.rowsExpired).toBe(2)
+      expect(summary.rowsErrored).toBe(1)
+      expect(summary.rowsSkipped).toBe(0)
+    } finally {
+      errorSpy.mockRestore()
+    }
+  })
+
+  it('already-expired row is a no-op on subsequent sweep (idempotency)', async () => {
+    // Two rows, both already expired by status — listExpired filters them out,
+    // so setStatus is never called and no events are emitted.
+    const seeds = [
+      makeRow({ id: 'pa-1', status: 'expired' }),
+      makeRow({ id: 'pa-2', status: 'expired' }),
+    ]
+    const { repo, listExpired, setStatus } = makeRepoStub({ seeds })
+    const emitEvent = jest.fn().mockResolvedValue(undefined)
+
+    const summary = await runPendingActionCleanup({
+      em,
+      repo,
+      emitEvent,
+      now: clock,
+      discoverTenants: async () => [
+        { tenantId: 'tenant-alpha', organizationId: 'org-alpha' },
+      ],
+    })
+
+    expect(listExpired).toHaveBeenCalledTimes(1)
+    expect(setStatus).not.toHaveBeenCalled()
+    expect(emitEvent).not.toHaveBeenCalled()
+    expect(summary.rowsExpired).toBe(0)
+  })
+})