@open-mercato/channel-discord 0.6.8-develop.7090.1.4dbca7b350

package/src/modules/channel_discord/subscribers/__tests__/ai-auto-reply.armed.test.ts

@@ -0,0 +1,149 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+/**
+ * Armed contract for the AI auto-reply subscriber (issue #4778).
+ *
+ * This test replaces the dormancy contract that shipped with #4391. That one
+ * asserted the inverse — that NO product surface could arm the subscriber —
+ * which was the honest statement while the feature was de-scoped. Now that the
+ * feature is real, the property worth pinning is the opposite one, and it is
+ * narrower: the two arming keys have exactly ONE writer, that writer is the
+ * settings command, and the operator surface in front of it is gated on
+ * `channel_discord.configure`.
+ *
+ * Structural assertions are worth having here because the properties they cover
+ * are invisible to a behavioural test: a second writer that skipped the command
+ * (and therefore the optimistic-lock check and the audit entry) would keep every
+ * unit test green, and so would a `features: []` regression in the subscriber —
+ * the exact defect the re-review of #4391 found.
+ */
+const ARMING_KEYS = ['aiAutoReplyEnabled', 'aiAgentId'] as const
+
+/** The only file allowed to WRITE the arming keys. */
+const WRITER = 'commands/update-ai-auto-reply.ts'
+
+/** Files allowed to name the keys at all, and the role each plays. */
+const KEY_NAMERS = [
+  WRITER,
+  'lib/ai-reply.ts', // reads the toggle + agent id for the subscriber
+  'lib/credentials.ts', // declares the channelState schema they live in
+  'lib/channel-state-store.ts', // carries them forward when the gateway writes resume state
+  'api/channels/[id]/ai-auto-reply/route.ts', // GET reads them for the settings form, PUT validates the payload before the command
+  'api/ai-auto-reply/channels/route.ts', // reads them for the integration panel's single-call listing
+  'backend/channel_discord/channels/[id]/ai-auto-reply/page.tsx', // the settings form itself
+  'widgets/injection/ai-auto-reply/widget.client.tsx', // shows the current state per channel
+] as const
+
+/**
+ * Prose describes the very patterns these assertions forbid — the subscriber's
+ * own header explains why it never passes `features: []`. Matching against code
+ * only keeps a doc comment from failing the build it is documenting.
+ */
+function stripComments(source: string): string {
+  return source.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:])\/\/.*$/gm, '$1')
+}
+
+function collectSourceFiles(root: string): string[] {
+  const found: string[] = []
+  const walk = (dir: string) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const absolute = path.join(dir, entry.name)
+      if (entry.isDirectory()) {
+        if (entry.name === '__tests__' || entry.name === '__integration__') continue
+        walk(absolute)
+        continue
+      }
+      if (/\.(ts|tsx)$/.test(entry.name)) found.push(absolute)
+    }
+  }
+  walk(root)
+  return found
+}
+
+describe('channel_discord ai-auto-reply — armed contract', () => {
+  const packageSrc = path.resolve(__dirname, '../../../..')
+  const moduleRoot = path.join(packageSrc, 'modules', 'channel_discord')
+  const files = collectSourceFiles(packageSrc)
+  const relative = (file: string) => path.relative(moduleRoot, file).split(path.sep).join('/')
+  const readSettingsRoute = () =>
+    fs.readFileSync(path.join(moduleRoot, 'api', 'channels', '[id]', 'ai-auto-reply', 'route.ts'), 'utf8')
+
+  it('scans a real, non-empty source tree', () => {
+    expect(files.length).toBeGreaterThan(20)
+    expect(files).toContain(path.join(moduleRoot, 'subscribers', 'ai-auto-reply.ts'))
+  })
+
+  it('names the arming keys only in the files that read, validate, render or write them', () => {
+    const naming = files
+      .filter((file) => {
+        const source = fs.readFileSync(file, 'utf8')
+        return ARMING_KEYS.some((key) => source.includes(key))
+      })
+      .map(relative)
+      .sort()
+
+    expect(naming).toEqual([...KEY_NAMERS].sort())
+  })
+
+  it('writes channelState from exactly two places — the gateway store and the settings command', () => {
+    const assigning = files
+      // `.channelState =` is the entity write; a bare `channelState =` is a local
+      // binding (the gateway worker parses one to read resume state).
+      .filter((file) => /\.channelState\s*=[^=]/.test(stripComments(fs.readFileSync(file, 'utf8'))))
+      .map(relative)
+      .sort()
+
+    // Any third writer is a deliberate addition that has to argue for itself:
+    // the gateway store carries the AI keys forward, and the settings command is
+    // the only thing allowed to change them.
+    expect(assigning).toEqual([WRITER, 'lib/channel-state-store.ts'].sort())
+  })
+
+  it('persists the settings through the command bus, not a direct entity write', () => {
+    const route = stripComments(readSettingsRoute())
+    expect(route).toContain('CHANNEL_DISCORD_UPDATE_AI_AUTO_REPLY_COMMAND_ID')
+    expect(route).not.toMatch(/\.flush\(/)
+    expect(route).not.toMatch(/nativeUpdate/)
+  })
+
+  it('never invokes the agent with an empty feature set', () => {
+    const subscriber = stripComments(
+      fs.readFileSync(path.join(moduleRoot, 'subscribers', 'ai-auto-reply.ts'), 'utf8'),
+    )
+    expect(subscriber).not.toMatch(/features:\s*\[\s*\]/)
+    expect(subscriber).toContain('principal.features')
+    expect(subscriber).toContain('isSuperAdmin: principal.isSuperAdmin')
+  })
+
+  it('refuses to arm a channel against an agent the auto-reply principal cannot invoke', () => {
+    // Structural, because the behavioural half lives in the route test and this
+    // is the property that must not quietly disappear: object-mode eligibility is
+    // a SHAPE check, and on its own it re-opens the dormancy hole — the runtime
+    // also enforces `requiredFeatures` against the principal from
+    // `lib/ai-service-principal.ts`, so the save path has to ask the same
+    // question with the same principal.
+    const route = stripComments(readSettingsRoute())
+    expect(route).toContain('missingAgentFeatures')
+    expect(route).toContain('resolveDiscordAiPrincipal')
+  })
+
+  it('records why an armed channel produced nothing, instead of only logging it', () => {
+    const subscriber = stripComments(
+      fs.readFileSync(path.join(moduleRoot, 'subscribers', 'ai-auto-reply.ts'), 'utf8'),
+    )
+    // The no-op on failure is correct; being silent about it is what made the
+    // feature dormant. The marker write must survive any refactor of the catch.
+    expect(subscriber).toContain('recordDiscordAutoReplyOutcome')
+  })
+
+  it('gates the write route on the configure feature, not merely on being signed in', () => {
+    // The settings route exposes GET and PUT from one file, so assert on the PUT
+    // metadata block specifically: a file-wide `toContain` would still pass if the
+    // configure feature only ever guarded the read half.
+    const putMetadata = readSettingsRoute().match(/\n {2}PUT: \{[\s\S]*?\n {2}\},/)?.[0]
+    expect(putMetadata).toBeDefined()
+    expect(putMetadata).toContain('requireAuth: true')
+    expect(putMetadata).toContain('CHANNEL_DISCORD_CONFIGURE_FEATURE')
+  })
+})

package/src/modules/channel_discord/subscribers/__tests__/ai-auto-reply.failure-marker.test.ts

@@ -0,0 +1,133 @@
+/**
+ * What an armed Discord channel does when the agent call keeps being refused.
+ *
+ * The subscriber degrades to a no-op, and that part is right — a broken model
+ * must never become a send. The part that was wrong is that the no-op was
+ * *silent*: the settings surface still read "Auto-reply on", the channel answered
+ * nothing, and the only trace was a `logger.warn` in a background subscriber. A
+ * save-time feature check narrows the window but cannot close it, because a role
+ * edited after the channel was armed makes that verdict stale.
+ *
+ * So the contract here is: every failure leaves a reason on the channel, the next
+ * success clears it, and neither the marker write nor its failure can turn a
+ * degraded no-op into a thrown handler.
+ */
+const recordDiscordAutoReplyOutcomeMock = jest.fn(async () => 'written' as const)
+
+jest.mock('@open-mercato/shared/lib/encryption/find', () => ({
+  findOneWithDecryption: jest.fn(),
+}))
+jest.mock('@open-mercato/core/modules/communication_channels/lib/system-user', () => ({
+  COMMUNICATION_CHANNELS_SYSTEM_USER_ID: '00000000-0000-0000-0000-000000000000',
+  resolveCommunicationChannelsSystemUserId: jest.fn(async () => 'system-user-id'),
+}))
+jest.mock('@open-mercato/ai-assistant', () => ({ runAiAgentObject: jest.fn() }), { virtual: true })
+jest.mock('../../lib/channel-state-store', () => ({
+  recordDiscordAutoReplyOutcome: (...args: unknown[]) => recordDiscordAutoReplyOutcomeMock(...(args as [])),
+}))
+
+import handler from '../ai-auto-reply'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { CHANNEL_DISCORD_AUTO_REPLY_AGENT_ID } from '../../ai-agents'
+
+const findOne = findOneWithDecryption as unknown as jest.Mock
+const aiMod = jest.requireMock('@open-mercato/ai-assistant') as { runAiAgentObject: jest.Mock }
+
+const payload = {
+  providerKey: 'discord' as const,
+  messageId: 'm-1',
+  channelId: 'c-1',
+  tenantId: 't-1',
+  organizationId: 'o-1',
+  direction: 'inbound' as const,
+}
+
+function makeCtx() {
+  const forked = { findOne: jest.fn(async () => null) }
+  const em = { fork: () => forked }
+  const commandBus = { execute: jest.fn(async () => ({ result: { id: 'reply-msg', threadId: null } })) }
+  const resolve = jest.fn((name: string) => {
+    if (name === 'em') return em
+    if (name === 'mcpToolRegistry') return {}
+    if (name === 'commandBus') return commandBus
+    return {}
+  })
+  return { ctx: { resolve }, commandBus }
+}
+
+function channelRow(channelState: Record<string, unknown>) {
+  return { id: 'c-1', tenantId: 't-1', organizationId: 'o-1', userId: null, channelState }
+}
+
+const armed = { aiAutoReplyEnabled: true, aiAgentId: CHANNEL_DISCORD_AUTO_REPLY_AGENT_ID }
+
+function messageRow() {
+  return { id: 'm-1', threadId: 'thread-1', subject: 'Discord', type: 'channel.discord', body: 'Are you open?' }
+}
+
+beforeEach(() => {
+  jest.clearAllMocks()
+  recordDiscordAutoReplyOutcomeMock.mockResolvedValue('written')
+})
+
+describe('channel_discord ai-auto-reply — failure visibility', () => {
+  it('parks the reason on the channel when the runtime refuses the agent', async () => {
+    findOne.mockResolvedValueOnce(channelRow(armed)).mockResolvedValueOnce(messageRow())
+    aiMod.runAiAgentObject.mockRejectedValue(new Error('agent_features_denied'))
+    const { ctx, commandBus } = makeCtx()
+
+    await expect(handler(payload, ctx)).resolves.toBeUndefined()
+
+    // Still a no-op — nothing was sent and no proposal was filed.
+    expect(commandBus.execute).not.toHaveBeenCalled()
+    expect(recordDiscordAutoReplyOutcomeMock).toHaveBeenCalledTimes(1)
+    const call = recordDiscordAutoReplyOutcomeMock.mock.calls[0][0] as {
+      channelId: string
+      scope: { tenantId: string; organizationId: string | null }
+      failure: string | null
+    }
+    expect(call.channelId).toBe('c-1')
+    expect(call.scope).toEqual({ tenantId: 't-1', organizationId: 'o-1' })
+    // The reason names the agent, because "which agent" is the first thing an
+    // operator staring at a silent channel needs to know.
+    expect(call.failure).toBe(`agent ${CHANNEL_DISCORD_AUTO_REPLY_AGENT_ID}: agent_features_denied`)
+  })
+
+  it('clears a stale marker on the next attempt that gets through', async () => {
+    findOne
+      .mockResolvedValueOnce(channelRow({ ...armed, aiAutoReplyLastError: 'agent x: denied' }))
+      .mockResolvedValueOnce(messageRow())
+    aiMod.runAiAgentObject.mockResolvedValue({
+      mode: 'generate',
+      object: { reply: 'We are open 9-5.', summary: 'Hours.', confidence: 0.9, requiresHuman: false },
+    })
+    const { ctx } = makeCtx()
+
+    await handler(payload, ctx)
+
+    expect(recordDiscordAutoReplyOutcomeMock).toHaveBeenCalledTimes(1)
+    expect((recordDiscordAutoReplyOutcomeMock.mock.calls[0][0] as { failure: string | null }).failure).toBeNull()
+  })
+
+  it('does not pay a write on a healthy channel that has nothing to clear', async () => {
+    findOne.mockResolvedValueOnce(channelRow(armed)).mockResolvedValueOnce(messageRow())
+    aiMod.runAiAgentObject.mockResolvedValue({
+      mode: 'generate',
+      object: { reply: 'We are open 9-5.', summary: 'Hours.', confidence: 0.9, requiresHuman: false },
+    })
+    const { ctx } = makeCtx()
+
+    await handler(payload, ctx)
+
+    expect(recordDiscordAutoReplyOutcomeMock).not.toHaveBeenCalled()
+  })
+
+  it('never lets the marker write itself escalate a no-op into a thrown handler', async () => {
+    findOne.mockResolvedValueOnce(channelRow(armed)).mockResolvedValueOnce(messageRow())
+    aiMod.runAiAgentObject.mockRejectedValue(new Error('boom'))
+    recordDiscordAutoReplyOutcomeMock.mockRejectedValue(new Error('database is down'))
+    const { ctx } = makeCtx()
+
+    await expect(handler(payload, ctx)).resolves.toBeUndefined()
+  })
+})

package/src/modules/channel_discord/subscribers/__tests__/ai-auto-reply.test.ts

@@ -0,0 +1,273 @@
+/**
+ * Unit coverage for the AI auto-reply subscriber's control flow (issue #4778).
+ *
+ * The AI runtime is stubbed here on purpose: `@open-mercato/ai-assistant` is a
+ * soft-optional peer, so a unit test that imported the real runtime would couple
+ * this package to it and break the decoupling property the subscriber exists to
+ * respect. What the stub cannot prove — that the REAL agent policy accepts the
+ * call the subscriber makes — is proven separately, against the real
+ * `agent-policy` / `agent-runtime`, in
+ * `packages/channel-discord/src/modules/channel_discord/__tests__/ai-auto-reply.policy.integration.test.ts`.
+ *
+ * The three tiers this file pins down:
+ *   - easy + the model is confident and asks for no human → auto-send;
+ *   - anything else → a proposal a human approves, never a send;
+ *   - peer absent / channel not armed / malformed output → clean no-op.
+ */
+jest.mock('@open-mercato/shared/lib/encryption/find', () => ({
+  findOneWithDecryption: jest.fn(),
+}))
+jest.mock('@open-mercato/core/modules/communication_channels/lib/system-user', () => ({
+  COMMUNICATION_CHANNELS_SYSTEM_USER_ID: '00000000-0000-0000-0000-000000000000',
+  resolveCommunicationChannelsSystemUserId: jest.fn(async () => 'system-user-id'),
+}))
+jest.mock('@open-mercato/ai-assistant', () => ({ runAiAgentObject: jest.fn() }), { virtual: true })
+
+import handler from '../ai-auto-reply'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { CHANNEL_DISCORD_AUTO_REPLY_AGENT_ID } from '../../ai-agents'
+import { CHANNEL_DISCORD_AI_PROPOSAL_MESSAGE_TYPE } from '../../message-types'
+
+const findOne = findOneWithDecryption as unknown as jest.Mock
+const aiMod = jest.requireMock('@open-mercato/ai-assistant') as { runAiAgentObject: jest.Mock }
+
+type ResolveMap = {
+  commandBus?: { execute: jest.Mock }
+  aiPresent?: boolean
+  threadAssignee?: string | null
+}
+
+function makeCtx(map: ResolveMap) {
+  const forked = {
+    findOne: jest.fn(async () =>
+      map.threadAssignee ? { assignedUserId: map.threadAssignee } : null,
+    ),
+  }
+  const em = { fork: () => forked }
+  const commandBus =
+    map.commandBus ?? { execute: jest.fn(async () => ({ result: { id: 'reply-msg', threadId: null } })) }
+  const resolve = jest.fn((name: string) => {
+    if (name === 'em') return em
+    if (name === 'mcpToolRegistry') {
+      if (map.aiPresent === false) throw new Error('ai_assistant not registered')
+      return {}
+    }
+    if (name === 'commandBus') return commandBus
+    return {}
+  })
+  return { ctx: { resolve }, commandBus, resolve, forked }
+}
+
+const basePayload = {
+  providerKey: 'discord' as const,
+  messageId: 'm-1',
+  channelId: 'c-1',
+  tenantId: 't-1',
+  organizationId: 'o-1',
+  direction: 'inbound' as const,
+}
+
+function channelRow(overrides: Record<string, unknown> = {}) {
+  return {
+    id: 'c-1',
+    tenantId: 't-1',
+    organizationId: 'o-1',
+    userId: null,
+    channelState: { aiAutoReplyEnabled: true, aiAgentId: CHANNEL_DISCORD_AUTO_REPLY_AGENT_ID },
+    ...overrides,
+  }
+}
+
+function messageRow(body: string) {
+  return { id: 'm-1', threadId: 'thread-1', subject: 'Discord', type: 'channel.discord', body }
+}
+
+function agentOutput(overrides: Record<string, unknown> = {}) {
+  return {
+    mode: 'generate',
+    object: {
+      reply: 'We are open 9-5.',
+      summary: 'Asks about opening hours.',
+      confidence: 0.9,
+      requiresHuman: false,
+      ...overrides,
+    },
+  }
+}
+
+describe('channel_discord ai-auto-reply subscriber — cheap early returns', () => {
+  it('no-ops for a non-discord provider without touching the container', async () => {
+    const resolve = jest.fn(() => {
+      throw new Error('resolver should not be called')
+    })
+    await expect(
+      handler({ providerKey: 'gmail', messageId: 'm', channelId: 'c', tenantId: 't', direction: 'inbound' }, { resolve }),
+    ).resolves.toBeUndefined()
+    expect(resolve).not.toHaveBeenCalled()
+  })
+
+  it('no-ops for an outbound message', async () => {
+    const resolve = jest.fn(() => {
+      throw new Error('resolver should not be called')
+    })
+    await expect(
+      handler(
+        { providerKey: 'discord', messageId: 'm', channelId: 'c', tenantId: 't', direction: 'outbound' },
+        { resolve },
+      ),
+    ).resolves.toBeUndefined()
+    expect(resolve).not.toHaveBeenCalled()
+  })
+
+  it('no-ops when required payload fields are missing', async () => {
+    const resolve = jest.fn(() => {
+      throw new Error('resolver should not be called')
+    })
+    await expect(handler({ providerKey: 'discord', direction: 'inbound' }, { resolve })).resolves.toBeUndefined()
+    expect(resolve).not.toHaveBeenCalled()
+  })
+})
+
+describe('channel_discord ai-auto-reply subscriber — routing', () => {
+  beforeEach(() => {
+    findOne.mockReset()
+    aiMod.runAiAgentObject.mockReset()
+    aiMod.runAiAgentObject.mockResolvedValue(agentOutput())
+  })
+
+  it('(easy, confident) sends through the generic hub compose command', async () => {
+    findOne.mockResolvedValueOnce(channelRow()).mockResolvedValueOnce(messageRow('What are your opening hours?'))
+    const { ctx, commandBus } = makeCtx({ aiPresent: true })
+
+    await handler(basePayload, ctx)
+
+    expect(aiMod.runAiAgentObject).toHaveBeenCalledTimes(1)
+    expect(commandBus.execute).toHaveBeenCalledTimes(1)
+    const [commandId, args] = commandBus.execute.mock.calls[0]
+    expect(commandId).toBe('messages.messages.compose')
+    expect(args.input.body).toContain('We are open 9-5.')
+    expect(args.input.parentMessageId).toBe('thread-1')
+    expect(args.input.visibility).toBe('public')
+    expect(args.input.isDraft).toBe(false)
+  })
+
+  it('runs the agent under a real service principal, never features: [] and never super-admin', async () => {
+    findOne.mockResolvedValueOnce(channelRow()).mockResolvedValueOnce(messageRow('What are your opening hours?'))
+    const { ctx } = makeCtx({ aiPresent: true })
+
+    await handler(basePayload, ctx)
+
+    const [call] = aiMod.runAiAgentObject.mock.calls
+    expect(call[0].agentId).toBe(CHANNEL_DISCORD_AUTO_REPLY_AGENT_ID)
+    expect(call[0].authContext.features).toContain('channel_discord.ai_auto_reply.run')
+    expect(call[0].authContext.features.length).toBeGreaterThan(0)
+    expect(call[0].authContext.isSuperAdmin).toBe(false)
+    expect(call[0].authContext.tenantId).toBe('t-1')
+    expect(call[0].authContext.organizationId).toBe('o-1')
+  })
+
+  it('(complex) drafts a proposal for a human and NEVER auto-sends', async () => {
+    findOne
+      .mockResolvedValueOnce(channelRow())
+      .mockResolvedValueOnce(messageRow('I want a refund on my order'))
+      .mockResolvedValueOnce(channelRow())
+    const { ctx, commandBus } = makeCtx({ aiPresent: true, threadAssignee: 'agent-user-1' })
+
+    await handler(basePayload, ctx)
+
+    // The agent still runs — the proposal has to contain a drafted reply.
+    expect(aiMod.runAiAgentObject).toHaveBeenCalledTimes(1)
+    expect(commandBus.execute).toHaveBeenCalledTimes(1)
+    const [, args] = commandBus.execute.mock.calls[0]
+    expect(args.input.type).toBe(CHANNEL_DISCORD_AI_PROPOSAL_MESSAGE_TYPE)
+    expect(args.input.visibility).toBe('internal')
+    expect(args.input.recipients).toEqual([{ userId: 'agent-user-1', type: 'to' }])
+    expect(args.input.sourceEntityId).toBe('m-1')
+    expect(args.input.body).toContain('We are open 9-5.')
+  })
+
+  it('(complex, nobody assigned) stores the proposal as a draft rather than losing it', async () => {
+    findOne
+      .mockResolvedValueOnce(channelRow())
+      .mockResolvedValueOnce(messageRow('I want a refund on my order'))
+      .mockResolvedValueOnce(channelRow())
+    const { ctx, commandBus } = makeCtx({ aiPresent: true, threadAssignee: null })
+
+    await handler(basePayload, ctx)
+
+    const [, args] = commandBus.execute.mock.calls[0]
+    expect(args.input.isDraft).toBe(true)
+    expect(args.input.recipients).toEqual([])
+    expect(args.input.visibility).toBe('internal')
+  })
+
+  it('(easy, model asks for a human) proposes instead of sending', async () => {
+    aiMod.runAiAgentObject.mockResolvedValue(agentOutput({ requiresHuman: true }))
+    findOne
+      .mockResolvedValueOnce(channelRow())
+      .mockResolvedValueOnce(messageRow('What are your opening hours?'))
+      .mockResolvedValueOnce(channelRow())
+    const { ctx, commandBus } = makeCtx({ aiPresent: true, threadAssignee: 'agent-user-1' })
+
+    await handler(basePayload, ctx)
+
+    const [, args] = commandBus.execute.mock.calls[0]
+    expect(args.input.type).toBe(CHANNEL_DISCORD_AI_PROPOSAL_MESSAGE_TYPE)
+  })
+
+  it('(easy, low confidence) proposes instead of sending', async () => {
+    aiMod.runAiAgentObject.mockResolvedValue(agentOutput({ confidence: 0.4 }))
+    findOne
+      .mockResolvedValueOnce(channelRow())
+      .mockResolvedValueOnce(messageRow('What are your opening hours?'))
+      .mockResolvedValueOnce(channelRow())
+    const { ctx, commandBus } = makeCtx({ aiPresent: true, threadAssignee: 'agent-user-1' })
+
+    await handler(basePayload, ctx)
+
+    const [, args] = commandBus.execute.mock.calls[0]
+    expect(args.input.type).toBe(CHANNEL_DISCORD_AI_PROPOSAL_MESSAGE_TYPE)
+  })
+
+  it('(malformed agent output) degrades to a no-op instead of sending something unvalidated', async () => {
+    aiMod.runAiAgentObject.mockResolvedValue({ mode: 'generate', object: { reply: 'hi' } })
+    findOne.mockResolvedValueOnce(channelRow()).mockResolvedValueOnce(messageRow('What are your opening hours?'))
+    const { ctx, commandBus } = makeCtx({ aiPresent: true })
+
+    await expect(handler(basePayload, ctx)).resolves.toBeUndefined()
+    expect(commandBus.execute).not.toHaveBeenCalled()
+  })
+
+  it('(no ai_assistant) is a clean no-op — no message load, no send', async () => {
+    findOne.mockResolvedValueOnce(channelRow())
+    const { ctx, commandBus } = makeCtx({ aiPresent: false })
+
+    await expect(handler(basePayload, ctx)).resolves.toBeUndefined()
+
+    expect(findOne).toHaveBeenCalledTimes(1) // channel only; message never fetched
+    expect(aiMod.runAiAgentObject).not.toHaveBeenCalled()
+    expect(commandBus.execute).not.toHaveBeenCalled()
+  })
+
+  it('(disabled) no-ops when per-channel auto-reply is OFF (default)', async () => {
+    findOne.mockResolvedValueOnce(channelRow({ channelState: {} }))
+    const { ctx, commandBus } = makeCtx({ aiPresent: true })
+
+    await handler(basePayload, ctx)
+
+    expect(findOne).toHaveBeenCalledTimes(1)
+    expect(commandBus.execute).not.toHaveBeenCalled()
+  })
+
+  it('loads the channel scoped by tenant + organization', async () => {
+    findOne.mockResolvedValueOnce(channelRow()).mockResolvedValueOnce(messageRow('hi there'))
+    const { ctx } = makeCtx({ aiPresent: true })
+
+    await handler(basePayload, ctx)
+
+    const [, entityArg, where, , dscope] = findOne.mock.calls[0]
+    expect(entityArg).toBeDefined()
+    expect(where).toMatchObject({ id: 'c-1', tenantId: 't-1', organizationId: 'o-1', deletedAt: null })
+    expect(dscope).toEqual({ tenantId: 't-1', organizationId: 'o-1' })
+  })
+})