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

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

@@ -0,0 +1,185 @@
+/**
+ * The write half of the configuration path (issue #4778): the only place the
+ * `aiAutoReplyEnabled` / `aiAgentId` keys are ever set.
+ *
+ * What matters here is not that the values land — it is that they land WITHOUT
+ * collateral damage. `channelState` is shared with the gateway worker, which
+ * writes resume state from a socket callback, so a settings save that replaced
+ * the blob would silently cost a live session its cursor.
+ */
+jest.mock('@open-mercato/shared/lib/encryption/find', () => ({
+  findOneWithDecryption: jest.fn(),
+}))
+jest.mock('@open-mercato/shared/lib/commands/flush', () => ({
+  withAtomicFlush: jest.fn(async (_em: unknown, phases: Array<() => unknown>) => {
+    for (const phase of phases) await phase()
+  }),
+}))
+
+import updateAiAutoReplyCommand from '../update-ai-auto-reply'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { isCrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import { OPTIMISTIC_LOCK_HEADER_NAME } from '@open-mercato/shared/lib/crud/optimistic-lock-headers'
+
+const findOne = findOneWithDecryption as unknown as jest.Mock
+
+const TENANT = '11111111-1111-4111-8111-111111111111'
+const ORG = '22222222-2222-4222-8222-222222222222'
+const CHANNEL = '33333333-3333-4333-8333-333333333333'
+const UPDATED_AT = new Date('2026-08-01T10:00:00.000Z')
+
+function makeCtx(request?: Request) {
+  const em = { fork: () => ({}) }
+  return {
+    container: { resolve: (name: string) => (name === 'em' ? em : {}) },
+    auth: null,
+    organizationScope: null,
+    selectedOrganizationId: ORG,
+    organizationIds: [ORG],
+    request,
+  } as never
+}
+
+function channelRow(channelState: Record<string, unknown>) {
+  return { id: CHANNEL, updatedAt: UPDATED_AT, channelState }
+}
+
+const gatewayState = {
+  sessionId: 'sess-1',
+  sequence: 42,
+  resumeGatewayUrl: 'wss://gateway.discord.gg',
+  botUserId: 'bot-1',
+}
+
+function baseInput(settings: Record<string, unknown>) {
+  return {
+    channelId: CHANNEL,
+    settings,
+    scope: { tenantId: TENANT, organizationId: ORG },
+  }
+}
+
+describe('channel_discord.channel.update_ai_auto_reply', () => {
+  beforeEach(() => {
+    findOne.mockReset()
+  })
+
+  it('arms the channel while carrying the gateway resume state forward', async () => {
+    const channel = channelRow({ ...gatewayState })
+    findOne.mockResolvedValueOnce(channel)
+
+    const result = await updateAiAutoReplyCommand.execute(
+      baseInput({ aiAutoReplyEnabled: true, aiAgentId: 'channel_discord.auto_reply' }) as never,
+      makeCtx(),
+    )
+
+    expect(result).toMatchObject({
+      status: 'updated',
+      aiAutoReplyEnabled: true,
+      aiAgentId: 'channel_discord.auto_reply',
+    })
+    expect(channel.channelState).toEqual({
+      ...gatewayState,
+      aiAutoReplyEnabled: true,
+      aiAgentId: 'channel_discord.auto_reply',
+    })
+  })
+
+  it('clears the agent when auto-reply is switched off, so stored state stays honest', async () => {
+    const channel = channelRow({ ...gatewayState, aiAutoReplyEnabled: true, aiAgentId: 'channel_discord.auto_reply' })
+    findOne.mockResolvedValueOnce(channel)
+
+    const result = await updateAiAutoReplyCommand.execute(
+      baseInput({ aiAutoReplyEnabled: false }) as never,
+      makeCtx(),
+    )
+
+    expect(result).toMatchObject({ status: 'updated', aiAutoReplyEnabled: false, aiAgentId: null })
+    expect((channel.channelState as { aiAgentId?: string }).aiAgentId).toBeUndefined()
+    expect(channel.channelState).toMatchObject(gatewayState)
+  })
+
+  it('refuses to arm a channel without naming an agent', async () => {
+    await expect(
+      updateAiAutoReplyCommand.execute(baseInput({ aiAutoReplyEnabled: true }) as never, makeCtx()),
+    ).rejects.toThrow()
+    expect(findOne).not.toHaveBeenCalled()
+  })
+
+  it('scopes the lookup to the tenant and the discord provider', async () => {
+    findOne.mockResolvedValueOnce(channelRow({}))
+
+    await updateAiAutoReplyCommand.execute(
+      baseInput({ aiAutoReplyEnabled: true, aiAgentId: 'channel_discord.auto_reply' }) as never,
+      makeCtx(),
+    )
+
+    const [, , where] = findOne.mock.calls[0]
+    expect(where).toMatchObject({
+      id: CHANNEL,
+      tenantId: TENANT,
+      providerKey: 'discord',
+      deletedAt: null,
+    })
+  })
+
+  it('keeps a tenant-scoped bot channel reachable while narrowing to the caller’s organizations', async () => {
+    findOne.mockResolvedValueOnce(channelRow({}))
+
+    await updateAiAutoReplyCommand.execute(
+      {
+        ...baseInput({ aiAutoReplyEnabled: false }),
+        scope: { tenantId: TENANT, organizationId: ORG, organizationIds: [ORG] },
+      } as never,
+      makeCtx(),
+    )
+
+    const [, , where] = findOne.mock.calls[0]
+    // A Discord bot channel normally has `organization_id IS NULL`; an equality
+    // filter on the caller's organization would hide it outright.
+    expect(where.$or).toEqual([{ organizationId: { $in: [ORG] } }, { organizationId: null }])
+  })
+
+  it('masks a channel it cannot see rather than reporting why', async () => {
+    findOne.mockResolvedValueOnce(null)
+
+    const result = await updateAiAutoReplyCommand.execute(
+      baseInput({ aiAutoReplyEnabled: false }) as never,
+      makeCtx(),
+    )
+
+    expect(result).toEqual({ status: 'not_found' })
+  })
+
+  it('rejects a save from a tab that loaded the channel before someone else changed it', async () => {
+    const channel = channelRow({ ...gatewayState })
+    findOne.mockResolvedValueOnce(channel)
+    const staleRequest = new Request('https://example.test/', {
+      headers: { [OPTIMISTIC_LOCK_HEADER_NAME]: new Date('2026-07-01T09:00:00.000Z').toISOString() },
+    })
+
+    const failure = await updateAiAutoReplyCommand
+      .execute(baseInput({ aiAutoReplyEnabled: false }) as never, makeCtx(staleRequest))
+      .catch((err: unknown) => err)
+
+    expect(isCrudHttpError(failure)).toBe(true)
+    if (isCrudHttpError(failure)) expect(failure.status).toBe(409)
+    // The stale save must not have touched the row on its way out.
+    expect(channel.channelState).toEqual(gatewayState)
+  })
+
+  it('accepts a save whose expected version matches the current one', async () => {
+    const channel = channelRow({ ...gatewayState })
+    findOne.mockResolvedValueOnce(channel)
+    const freshRequest = new Request('https://example.test/', {
+      headers: { [OPTIMISTIC_LOCK_HEADER_NAME]: UPDATED_AT.toISOString() },
+    })
+
+    const result = await updateAiAutoReplyCommand.execute(
+      baseInput({ aiAutoReplyEnabled: false }) as never,
+      makeCtx(freshRequest),
+    )
+
+    expect(result).toMatchObject({ status: 'updated' })
+  })
+})

package/src/modules/channel_discord/commands/ai-reply-proposal.ts

@@ -0,0 +1,162 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { z } from 'zod'
+import type { CommandBus, CommandHandler } from '@open-mercato/shared/lib/commands'
+import { registerCommand } from '@open-mercato/shared/lib/commands'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { Message } from '@open-mercato/core/modules/messages/data/entities'
+import {
+  CHANNEL_DISCORD_AI_PROPOSAL_APPROVE_COMMAND_ID,
+  CHANNEL_DISCORD_AI_PROPOSAL_DISMISS_COMMAND_ID,
+} from '../lib/ai-proposal-contract'
+import { CHANNEL_DISCORD_AI_PROPOSAL_MESSAGE_TYPE } from '../message-types'
+
+const logger = createLogger('channel_discord').child({ component: 'ai-reply-proposal' })
+
+/**
+ * Commands behind the `complex`-tier approval card (issue #4778).
+ *
+ * `messages.actions.execute` dispatches these after it has atomically claimed
+ * the terminal action, so both handlers can assume they run at most once per
+ * proposal. It passes `messageId` / `actionId` and the acting operator in
+ * `ctx.auth` — everything else these commands need is read from the stored
+ * proposal, never from the request body, so a caller cannot redirect the send.
+ */
+const proposalActionInputSchema = z
+  .object({
+    messageId: z.string().uuid(),
+    actionId: z.string().min(1),
+  })
+  .passthrough()
+
+type ProposalActionInput = z.infer<typeof proposalActionInputSchema>
+
+export type ApproveProposalResult = { ok: true; sentMessageId: string; threadId: string | null }
+export type DismissProposalResult = { ok: true; dismissed: true }
+
+type ResolvedScope = { tenantId: string; organizationId: string | null; userId: string }
+
+function requireScope(auth: { sub?: string; tenantId?: string | null; orgId?: string | null } | null): ResolvedScope {
+  const userId = auth?.sub
+  const tenantId = auth?.tenantId
+  if (!userId || !tenantId) {
+    throw new Error('[internal] channel_discord AI proposal action requires an authenticated actor')
+  }
+  return { tenantId, organizationId: auth?.orgId ?? null, userId }
+}
+
+async function loadProposal(
+  em: EntityManager,
+  messageId: string,
+  scope: ResolvedScope,
+): Promise<Message> {
+  const proposal = await findOneWithDecryption(
+    em,
+    Message,
+    { id: messageId, tenantId: scope.tenantId, deletedAt: null },
+    undefined,
+    { tenantId: scope.tenantId, organizationId: scope.organizationId },
+  )
+  if (!proposal) throw new Error('[internal] AI reply proposal not found')
+  if (proposal.type !== CHANNEL_DISCORD_AI_PROPOSAL_MESSAGE_TYPE) {
+    // The action is only ever rendered on our own message type; a mismatch means
+    // the id was swapped, so refuse rather than sending an unrelated message body
+    // into a Discord server.
+    throw new Error('[internal] Message is not a Discord AI reply proposal')
+  }
+  return proposal
+}
+
+const approveProposalCommand: CommandHandler<ProposalActionInput, ApproveProposalResult> = {
+  id: CHANNEL_DISCORD_AI_PROPOSAL_APPROVE_COMMAND_ID,
+  // A message posted into a Discord server cannot be recalled by undoing a row
+  // here, so the command declines to pretend otherwise.
+  isUndoable: false,
+  async execute(rawInput, ctx) {
+    const input = proposalActionInputSchema.parse(rawInput)
+    const scope = requireScope(ctx.auth)
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+
+    const proposal = await loadProposal(em, input.messageId, scope)
+    const inboundMessageId = proposal.sourceEntityId
+    if (!inboundMessageId) {
+      throw new Error('[internal] AI reply proposal has no source message to reply to')
+    }
+
+    const inbound = await findOneWithDecryption(
+      em,
+      Message,
+      { id: inboundMessageId, tenantId: scope.tenantId, deletedAt: null },
+      undefined,
+      { tenantId: scope.tenantId, organizationId: scope.organizationId },
+    )
+    if (!inbound) {
+      throw new Error('[internal] The message this proposal answers no longer exists')
+    }
+
+    const body = (proposal.body ?? '').trim()
+    if (!body) {
+      throw new Error('[internal] AI reply proposal has an empty body')
+    }
+
+    const commandBus = ctx.container.resolve('commandBus') as CommandBus
+    // Same generic outbound path the easy tier uses: compose a public reply in
+    // the thread and let the hub's outbound bridge deliver it. Attribution is the
+    // approving operator, not the bot — a human decided to send this.
+    const composeResult = await commandBus.execute<
+      Record<string, unknown>,
+      { id: string; threadId: string | null }
+    >('messages.messages.compose', {
+      input: {
+        type: inbound.type,
+        visibility: 'public' as const,
+        subject: (inbound.subject ?? 'Discord reply').toString().slice(0, 200) || 'Discord reply',
+        body,
+        bodyFormat: 'markdown' as const,
+        priority: 'normal' as const,
+        sendViaEmail: false,
+        parentMessageId: inbound.threadId ?? inbound.id,
+        isDraft: false,
+        tenantId: scope.tenantId,
+        organizationId: scope.organizationId,
+        userId: scope.userId,
+      },
+      ctx: {
+        container: ctx.container,
+        auth: ctx.auth ?? null,
+        organizationScope: null,
+        selectedOrganizationId: scope.organizationId,
+        organizationIds: scope.organizationId ? [scope.organizationId] : null,
+      },
+    })
+
+    const sent = composeResult.result
+    logger.info('AI reply proposal approved and sent', {
+      proposalId: proposal.id,
+      sentMessageId: sent.id,
+    })
+    return { ok: true, sentMessageId: sent.id, threadId: sent.threadId ?? null }
+  },
+}
+
+const dismissProposalCommand: CommandHandler<ProposalActionInput, DismissProposalResult> = {
+  id: CHANNEL_DISCORD_AI_PROPOSAL_DISMISS_COMMAND_ID,
+  isUndoable: false,
+  async execute(rawInput, ctx) {
+    const input = proposalActionInputSchema.parse(rawInput)
+    const scope = requireScope(ctx.auth)
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+
+    // Nothing to write: `messages.actions.execute` has already recorded the
+    // terminal action, which is what "dismissed" means. The load is the guard —
+    // it keeps the dismiss action from acknowledging a message that is not ours.
+    const proposal = await loadProposal(em, input.messageId, scope)
+    logger.info('AI reply proposal dismissed', { proposalId: proposal.id })
+    return { ok: true, dismissed: true }
+  },
+}
+
+registerCommand(approveProposalCommand as CommandHandler<unknown, unknown>)
+registerCommand(dismissProposalCommand as CommandHandler<unknown, unknown>)
+
+export { approveProposalCommand, dismissProposalCommand }

package/src/modules/channel_discord/commands/update-ai-auto-reply.ts

@@ -0,0 +1,157 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { z } from 'zod'
+import type { CommandHandler } from '@open-mercato/shared/lib/commands'
+import { registerCommand } from '@open-mercato/shared/lib/commands'
+import { withAtomicFlush } from '@open-mercato/shared/lib/commands/flush'
+import { enforceCommandOptimisticLockWithGuards } from '@open-mercato/shared/lib/crud/optimistic-lock-command'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { CommunicationChannel } from '@open-mercato/core/modules/communication_channels/data/entities'
+import { channelOrgScopeWhereFromFilter } from '@open-mercato/core/modules/communication_channels/lib/access-control'
+import { discordChannelStateSchema } from '../lib/credentials'
+
+/**
+ * Resource kind the channel's optimistic-lock check is scoped under. It matches
+ * the `resourceKind` the route's mutation guard uses, so an operator's stale tab
+ * fails the same way here as it would on any other channel write.
+ */
+export const CHANNEL_DISCORD_CHANNEL_RESOURCE_KIND = 'communication_channels.channel'
+
+export const CHANNEL_DISCORD_UPDATE_AI_AUTO_REPLY_COMMAND_ID =
+  'channel_discord.channel.update_ai_auto_reply'
+
+export const discordAiAutoReplySettingsSchema = z
+  .object({
+    aiAutoReplyEnabled: z.boolean(),
+    aiAgentId: z.string().trim().min(1).max(200).optional(),
+  })
+  .refine((value) => !value.aiAutoReplyEnabled || Boolean(value.aiAgentId), {
+    // Arming auto-reply without naming an agent is the state that made the
+    // original subscriber dormant; the schema refuses to reproduce it.
+    path: ['aiAgentId'],
+    message: 'channel_discord.aiAutoReply.errors.agentRequired',
+  })
+
+export type DiscordAiAutoReplySettings = z.infer<typeof discordAiAutoReplySettingsSchema>
+
+const updateAiAutoReplySchema = z.object({
+  channelId: z.string().uuid(),
+  settings: discordAiAutoReplySettingsSchema,
+  scope: z.object({
+    tenantId: z.string().uuid(),
+    /** Organization the decryption scope is anchored to. */
+    organizationId: z.string().uuid().nullable(),
+    /**
+     * Organizations the caller may see, as resolved by the route. A Discord bot
+     * channel is usually tenant-scoped (`organization_id IS NULL`), so filtering
+     * on a single organization would hide the very channels this command
+     * configures — the hub's `channelOrgScopeWhereFromFilter` encodes the right
+     * rule and is reused here.
+     */
+    organizationIds: z.array(z.string().uuid()).nullable().optional(),
+  }),
+  expectedUpdatedAt: z.string().optional(),
+})
+
+export type UpdateAiAutoReplyInput = z.infer<typeof updateAiAutoReplySchema>
+
+export type UpdateAiAutoReplyResult =
+  | {
+      status: 'updated'
+      channelId: string
+      aiAutoReplyEnabled: boolean
+      aiAgentId: string | null
+      updatedAt: string | null
+    }
+  | { status: 'not_found' }
+
+/**
+ * Persist a Discord channel's AI auto-reply settings (issue #4778).
+ *
+ * The write goes through the command bus rather than an entity write in the
+ * route so it inherits the platform's audit trail, and so the two keys the
+ * subscriber reads have exactly one writer.
+ *
+ * Two things it is careful about:
+ *
+ * - **It merges.** `channelState` is shared with the gateway worker, which writes
+ *   resume state (`sessionId`, `sequence`, `resumeGatewayUrl`, `botUserId`) from
+ *   a socket callback. Replacing the blob would drop a live session's cursor and
+ *   force a re-IDENTIFY, so only the two AI keys are touched — the mirror image
+ *   of what `lib/channel-state-store.ts` does from the other side.
+ * - **It version-checks.** The settings form sends the channel's `updatedAt`, so
+ *   a save from a tab opened before someone else changed the channel fails with
+ *   the standard 409 conflict body instead of silently winning.
+ */
+const updateAiAutoReplyCommand: CommandHandler<UpdateAiAutoReplyInput, UpdateAiAutoReplyResult> = {
+  id: CHANNEL_DISCORD_UPDATE_AI_AUTO_REPLY_COMMAND_ID,
+  // Not undoable on purpose: replaying a stale snapshot could re-arm auto-reply
+  // on a channel an operator deliberately disarmed — for example after the bot
+  // answered something it should not have. Reverting is a deliberate act through
+  // the same form, which leaves its own audit entry.
+  isUndoable: false,
+  async execute(rawInput, ctx) {
+    const input = updateAiAutoReplySchema.parse(rawInput)
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const dscope = { tenantId: input.scope.tenantId, organizationId: input.scope.organizationId }
+
+    const channel = await findOneWithDecryption(
+      em,
+      CommunicationChannel,
+      {
+        id: input.channelId,
+        tenantId: input.scope.tenantId,
+        providerKey: 'discord',
+        ...channelOrgScopeWhereFromFilter({ organizationIds: input.scope.organizationIds ?? undefined }),
+        deletedAt: null,
+      },
+      undefined,
+      dscope,
+    )
+    // Existence masking, consistent with the hub's channel-scoped routes: a
+    // channel in another tenant and a channel that never existed answer alike.
+    if (!channel) return { status: 'not_found' }
+
+    // The DI-aware seam, not the bare synchronous helper: it runs the OSS
+    // `updated_at` floor first and then awaits the optional enterprise
+    // `record_locks` guard, so a channel someone else holds a lock on is
+    // protected on an enterprise build too.
+    await enforceCommandOptimisticLockWithGuards(ctx.container, {
+      resourceKind: CHANNEL_DISCORD_CHANNEL_RESOURCE_KIND,
+      resourceId: channel.id,
+      current: channel.updatedAt,
+      expected: input.expectedUpdatedAt ?? null,
+      request: ctx.request ?? null,
+    })
+
+    const current = discordChannelStateSchema.parse(channel.channelState ?? {})
+    const aiAgentId = input.settings.aiAutoReplyEnabled ? input.settings.aiAgentId : undefined
+
+    await withAtomicFlush(
+      em,
+      [
+        () => {
+          channel.channelState = {
+            ...current,
+            aiAutoReplyEnabled: input.settings.aiAutoReplyEnabled,
+            // Clearing the agent when auto-reply is switched off keeps the stored
+            // state honest: a disabled channel does not keep pointing at an agent.
+            aiAgentId,
+          }
+        },
+      ],
+      { transaction: true, label: 'channel_discord.channel.update_ai_auto_reply' },
+    )
+
+    return {
+      status: 'updated',
+      channelId: channel.id,
+      aiAutoReplyEnabled: input.settings.aiAutoReplyEnabled,
+      aiAgentId: aiAgentId ?? null,
+      updatedAt: channel.updatedAt ? channel.updatedAt.toISOString() : null,
+    }
+  },
+}
+
+registerCommand(updateAiAutoReplyCommand as CommandHandler<unknown, unknown>)
+
+export default updateAiAutoReplyCommand

package/src/modules/channel_discord/di.ts

@@ -0,0 +1,26 @@
+import { asValue } from 'awilix'
+import type { AppContainer } from '@open-mercato/shared/lib/di/container'
+import {
+  hasChannelAdapter,
+  registerChannelAdapter,
+} from '@open-mercato/core/modules/communication_channels/lib/adapter-registry-singleton'
+import { getDiscordChannelAdapter } from './lib/adapter'
+import { channelDiscordHealthCheck } from './lib/health'
+
+/**
+ * Re-register the adapter on container creation as a safety net for runtime
+ * environments that bypass module setup (worker-only nodes, ad-hoc CLI). The
+ * underlying registry is process-wide so the registration is idempotent.
+ */
+export function register(container: AppContainer): void {
+  if (!hasChannelAdapter('discord')) {
+    registerChannelAdapter(getDiscordChannelAdapter())
+  }
+  container.register({
+    channelDiscordAdapter: asValue(getDiscordChannelAdapter()),
+    // Registered under the exact service name declared in `integration.ts`
+    // (`healthCheck.service`). Without this, the hub's `container.resolve(...)`
+    // throws and the channel reports permanently 'unhealthy'.
+    channelDiscordHealthCheck: asValue(channelDiscordHealthCheck),
+  })
+}

package/src/modules/channel_discord/i18n/de.json

@@ -0,0 +1,57 @@
+{
+  "channel_discord.aiAutoReply.errors.agentFeaturesMissing": "Dem Kanal-Bot-Benutzer fehlen die von diesem Agenten benötigten Berechtigungen: {features}. Vergeben Sie sie zuerst oder wählen Sie einen anderen Agenten.",
+  "channel_discord.aiAutoReply.errors.agentNotEligible": "Dieser Agent kann nicht auf einem Kanal antworten — wählen Sie einen mit strukturierter Ausgabe",
+  "channel_discord.aiAutoReply.errors.agentRequired": "Wählen Sie den Agenten, der auf diesem Kanal antworten soll",
+  "channel_discord.aiAutoReply.errors.aiUnavailable": "Die Autoantwort benötigt das KI-Assistent-Modul, das in dieser Installation fehlt",
+  "channel_discord.aiAutoReply.errors.load": "KI-Autoantwort-Einstellungen konnten nicht geladen werden",
+  "channel_discord.aiAutoReply.errors.loadChannels": "Discord-Kanäle konnten nicht geladen werden",
+  "channel_discord.aiAutoReply.errors.save": "KI-Autoantwort-Einstellungen konnten nicht gespeichert werden",
+  "channel_discord.aiAutoReply.fields.agent": "Agent",
+  "channel_discord.aiAutoReply.fields.agentHelp": "Nur Agenten mit strukturierter Ausgabe können auf einem Kanal antworten. Geben Sie dem Kanal-Bot-Benutzer des Mandanten die vom Agenten geforderten Berechtigungen, bevor Sie einen Agenten aus einem anderen Modul wählen.",
+  "channel_discord.aiAutoReply.fields.agentMissingFeatures": "{label} — benötigt {features}",
+  "channel_discord.aiAutoReply.fields.enabled": "Eingehende Discord-Nachrichten mit KI beantworten",
+  "channel_discord.aiAutoReply.fields.enabledHelp": "Standardmäßig aus. Wenn aktiviert, werden einfache Nachrichten automatisch beantwortet; alles Sensible, Unsichere oder Verdächtige wird stattdessen einem Menschen zur Freigabe vorgelegt.",
+  "channel_discord.aiAutoReply.intro": "Legen Sie fest, ob dieser Discord-Kanal selbstständig antworten darf und welcher Agent die Antwort entwirft.",
+  "channel_discord.aiAutoReply.lastError": "Der letzte Autoantwort-Versuch auf diesem Kanal ergab nichts: {reason}",
+  "channel_discord.aiAutoReply.lastErrorAt": "(erstmals {at})",
+  "channel_discord.aiAutoReply.loading": "KI-Autoantwort-Einstellungen werden geladen...",
+  "channel_discord.aiAutoReply.loadingChannels": "Discord-Kanäle werden geladen...",
+  "channel_discord.aiAutoReply.notFound": "Discord-Kanal nicht gefunden",
+  "channel_discord.aiAutoReply.page.title": "Discord KI-Autoantwort",
+  "channel_discord.aiAutoReply.save": "Speichern",
+  "channel_discord.aiAutoReply.saved": "KI-Autoantwort-Einstellungen gespeichert.",
+  "channel_discord.aiAutoReply.unavailable": "Das KI-Assistent-Modul ist in dieser Installation nicht vorhanden, daher lässt sich die Autoantwort nicht aktivieren. Der Kanal funktioniert weiterhin als normaler Posteingang.",
+  "channel_discord.aiAutoReply.widget.configure": "Konfigurieren",
+  "channel_discord.aiAutoReply.widget.description": "Lassen Sie einen KI-Agenten eingehende Discord-Nachrichten beantworten. Jeder Kanal ist standardmäßig aus, und alles Sensible oder Unsichere wird einem Menschen zur Freigabe vorgelegt, statt gesendet zu werden.",
+  "channel_discord.aiAutoReply.widget.failing": "Autoantwort fehlerhaft",
+  "channel_discord.aiAutoReply.widget.lastError": "Letzter Versuch fehlgeschlagen: {reason}",
+  "channel_discord.aiAutoReply.widget.noAgent": "Kein Agent ausgewählt",
+  "channel_discord.aiAutoReply.widget.noChannels": "Verbinden Sie zuerst einen Discord-Bot — die Autoantwort wird pro Kanal konfiguriert.",
+  "channel_discord.aiAutoReply.widget.off": "Autoantwort aus",
+  "channel_discord.aiAutoReply.widget.on": "Autoantwort an",
+  "channel_discord.aiAutoReply.widget.title": "KI-Autoantwort",
+  "channel_discord.aiAutoReply.widget.truncated": "Es werden nur die neuesten Kanäle angezeigt. Öffnen Sie die übrigen über die Kanalliste, um sie zu konfigurieren.",
+  "channel_discord.aiProposal.actions.approve": "Freigeben und senden",
+  "channel_discord.aiProposal.actions.dismiss": "Verwerfen",
+  "channel_discord.aiProposal.messageType": "Vorgeschlagene Discord-Antwort",
+  "channel_discord.connect.blocked": "Verbindung durch Validierung blockiert",
+  "channel_discord.connect.button": "Discord verbinden",
+  "channel_discord.connect.cancel": "Abbrechen",
+  "channel_discord.connect.connected": "Discord-Kanal verbunden.",
+  "channel_discord.connect.connecting": "Verbinde...",
+  "channel_discord.connect.failed": "Discord-Bot konnte nicht verbunden werden.",
+  "channel_discord.connect.fields.applicationId": "Anwendungs-ID",
+  "channel_discord.connect.fields.botToken": "Bot-Token",
+  "channel_discord.connect.fields.defaultChannelId": "Standard-Kanal-ID",
+  "channel_discord.connect.fields.displayName": "Anzeigename",
+  "channel_discord.connect.fields.guildId": "Server-ID (Guild)",
+  "channel_discord.connect.fields.publicKey": "Öffentlicher Schlüssel",
+  "channel_discord.connect.save": "Verbinden",
+  "channel_discord.connect.title": "Discord-Bot verbinden",
+  "channel_discord.interactions.commandReceived": "Empfangen — `/{command}` liegt jetzt im Open-Mercato-Posteingang und wird von dort bearbeitet.",
+  "channel_discord.interactions.componentReceived": "Empfangen — Deine Antwort liegt jetzt im Open-Mercato-Posteingang und wird von dort bearbeitet.",
+  "channel_discord.interactions.dispatchFailed": "Open Mercato konnte diese Interaktion gerade nicht erfassen. Bitte versuche es gleich noch einmal.",
+  "channel_discord.interactions.notDispatchable": "Dieser Interaktion fehlt der Kanal- oder Benutzerkontext, den Open Mercato benötigt, daher wurde sie nicht erfasst.",
+  "channel_discord.interactions.unsupported": "Der Discord-Kanal von Open Mercato verarbeitet diesen Interaktionstyp nicht.",
+  "channel_discord.provider.label": "Discord"
+}

package/src/modules/channel_discord/i18n/en.json

@@ -0,0 +1,57 @@
+{
+  "channel_discord.aiAutoReply.errors.agentFeaturesMissing": "The channel-bot user is missing the features this agent needs: {features}. Grant them first, or pick another agent.",
+  "channel_discord.aiAutoReply.errors.agentNotEligible": "That agent cannot answer a channel — pick one that produces structured output",
+  "channel_discord.aiAutoReply.errors.agentRequired": "Choose the agent that should answer this channel",
+  "channel_discord.aiAutoReply.errors.aiUnavailable": "Auto-reply needs the AI assistant module, which is not installed in this deployment",
+  "channel_discord.aiAutoReply.errors.load": "Failed to load AI auto-reply settings",
+  "channel_discord.aiAutoReply.errors.loadChannels": "Failed to load Discord channels",
+  "channel_discord.aiAutoReply.errors.save": "Failed to save AI auto-reply settings",
+  "channel_discord.aiAutoReply.fields.agent": "Agent",
+  "channel_discord.aiAutoReply.fields.agentHelp": "Only agents that produce structured output can answer a channel. Grant the tenant channel-bot user the agent's required features before choosing an agent from another module.",
+  "channel_discord.aiAutoReply.fields.agentMissingFeatures": "{label} — needs {features}",
+  "channel_discord.aiAutoReply.fields.enabled": "Answer inbound Discord messages with AI",
+  "channel_discord.aiAutoReply.fields.enabledHelp": "Off by default. When on, straightforward messages are answered automatically; anything sensitive, low-confidence or suspicious is proposed for a human to approve instead.",
+  "channel_discord.aiAutoReply.intro": "Choose whether this Discord channel may answer on its own, and which agent drafts the reply.",
+  "channel_discord.aiAutoReply.lastError": "The last auto-reply attempt on this channel produced nothing: {reason}",
+  "channel_discord.aiAutoReply.lastErrorAt": "(first seen {at})",
+  "channel_discord.aiAutoReply.loading": "Loading AI auto-reply settings...",
+  "channel_discord.aiAutoReply.loadingChannels": "Loading Discord channels...",
+  "channel_discord.aiAutoReply.notFound": "Discord channel not found",
+  "channel_discord.aiAutoReply.page.title": "Discord AI auto-reply",
+  "channel_discord.aiAutoReply.save": "Save",
+  "channel_discord.aiAutoReply.saved": "AI auto-reply settings saved.",
+  "channel_discord.aiAutoReply.unavailable": "The AI assistant module is not installed in this deployment, so auto-reply cannot be enabled. The channel keeps working as a normal inbox.",
+  "channel_discord.aiAutoReply.widget.configure": "Configure",
+  "channel_discord.aiAutoReply.widget.description": "Let an AI agent answer inbound Discord messages. Every channel is off by default, and anything sensitive or low-confidence is proposed for a human to approve instead of being sent.",
+  "channel_discord.aiAutoReply.widget.failing": "Auto-reply failing",
+  "channel_discord.aiAutoReply.widget.lastError": "Last attempt failed: {reason}",
+  "channel_discord.aiAutoReply.widget.noAgent": "No agent selected",
+  "channel_discord.aiAutoReply.widget.noChannels": "Connect a Discord bot first — auto-reply is configured per channel.",
+  "channel_discord.aiAutoReply.widget.off": "Auto-reply off",
+  "channel_discord.aiAutoReply.widget.on": "Auto-reply on",
+  "channel_discord.aiAutoReply.widget.title": "AI auto-reply",
+  "channel_discord.aiAutoReply.widget.truncated": "Only the most recent channels are shown. Open a channel from the Channels page to configure the rest.",
+  "channel_discord.aiProposal.actions.approve": "Approve and send",
+  "channel_discord.aiProposal.actions.dismiss": "Dismiss",
+  "channel_discord.aiProposal.messageType": "Proposed Discord reply",
+  "channel_discord.connect.blocked": "Connection blocked by validation",
+  "channel_discord.connect.button": "Connect Discord",
+  "channel_discord.connect.cancel": "Cancel",
+  "channel_discord.connect.connected": "Discord channel connected.",
+  "channel_discord.connect.connecting": "Connecting...",
+  "channel_discord.connect.failed": "Could not connect Discord bot.",
+  "channel_discord.connect.fields.applicationId": "Application ID",
+  "channel_discord.connect.fields.botToken": "Bot token",
+  "channel_discord.connect.fields.defaultChannelId": "Default channel ID",
+  "channel_discord.connect.fields.displayName": "Display name",
+  "channel_discord.connect.fields.guildId": "Guild (server) ID",
+  "channel_discord.connect.fields.publicKey": "Public key",
+  "channel_discord.connect.save": "Connect",
+  "channel_discord.connect.title": "Connect Discord bot",
+  "channel_discord.interactions.commandReceived": "Received — `/{command}` is now in the Open Mercato inbox and someone will pick it up from there.",
+  "channel_discord.interactions.componentReceived": "Received — your response is now in the Open Mercato inbox and someone will pick it up from there.",
+  "channel_discord.interactions.dispatchFailed": "Open Mercato could not record this interaction right now. Please try again in a moment.",
+  "channel_discord.interactions.notDispatchable": "This interaction is missing the channel or user context Open Mercato needs, so it was not recorded.",
+  "channel_discord.interactions.unsupported": "The Open Mercato Discord channel does not handle this interaction type.",
+  "channel_discord.provider.label": "Discord"
+}