@open-mercato/ai-assistant 0.6.7-develop.6775.1.c2313bb8a3 → 0.6.7-develop.6785.1.1dd7cfac55

package/src/modules/ai_assistant/api/settings/route.ts

@@ -17,6 +17,7 @@ import {
   isOpenCodeProviderConfigured,
 } from '@open-mercato/shared/lib/ai/opencode-provider'
 import { AiAgentRuntimeOverrideRepository, AiAgentRuntimeOverrideValidationError } from '../../data/repositories/AiAgentRuntimeOverrideRepository'
+import { resolveModerationPolicy } from '../../lib/moderation-policy'
 import { AiTenantModelAllowlistRepository } from '../../data/repositories/AiTenantModelAllowlistRepository'
 import { isBaseurlAllowlisted, readBaseurlAllowlist } from '../../lib/baseurl-allowlist'
 import { loadAgentRegistry, listAgents } from '../../lib/agent-registry'
@@ -59,6 +60,9 @@ const runtimeOverrideUpsertSchema = z.object({
   allowedOverrideModelsByProvider: z
     .record(z.string().min(1).max(64), z.array(z.string().min(1).max(256)))
     .optional(),
+  // Input moderation override: true = on, false = off, null = inherit.
+  // Spec 2026-06-04-ai-input-moderation-and-safety-identifiers.
+  inputModeration: z.boolean().nullable().optional(),
 })
 
 const runtimeOverrideClearSchema = z.object({
@@ -248,6 +252,7 @@ export async function GET(req: NextRequest) {
         const em = container.resolve<EntityManager>('em')
         const repo = new AiAgentRuntimeOverrideRepository(em)
         const overrideRow = await repo.getDefault({ tenantId, organizationId, agentId: null })
+        const tenantWideInputModeration = overrideRow?.inputModeration ?? null
         if (overrideRow) {
           tenantOverride = {
             providerId: overrideRow.providerId ?? null,
@@ -363,6 +368,20 @@ export async function GET(req: NextRequest) {
             modelId: agentResolution.modelId,
             baseURL: agentResolution.baseURL ?? null,
             source: agentResolution.source,
+            moderation: {
+              // `untrustedInput` agents enforce moderation; the UI renders a
+              // non-editable "Enforced" badge for them.
+              enforced: agent.untrustedInput === true,
+              // Per-agent control value: null = inherit, true = on, false = off.
+              override: agentOverrideRow?.inputModeration ?? null,
+              // Resolved runtime policy (enforced | on | off) after precedence.
+              effective: resolveModerationPolicy({
+                untrustedInput: agent.untrustedInput,
+                perAgentOverride: agentOverrideRow?.inputModeration ?? null,
+                tenantWideOverride: tenantWideInputModeration,
+                env,
+              }),
+            },
           }
         })
         agentResolutions = await Promise.all(agentResolutionPromises)
@@ -691,11 +710,11 @@ export async function PUT(req: NextRequest) {
   try {
     const container = await createRequestContainer()
     const rbacService = container.resolve<RbacService>('rbacService')
-    const acl = await rbacService.loadAcl(auth.sub, {
-      tenantId: auth.tenantId,
-      organizationId: auth.orgId,
-    })
-    const canManage = acl.isSuperAdmin || acl.features.includes('ai_assistant.settings.manage')
+    const canManage = await rbacService.userHasAllFeatures(
+      auth.sub,
+      ['ai_assistant.settings.manage'],
+      { tenantId: auth.tenantId, organizationId: auth.orgId },
+    )
     if (!canManage) {
       return NextResponse.json({ error: 'Forbidden', code: 'forbidden' }, { status: 403 })
     }
@@ -719,6 +738,9 @@ export async function PUT(req: NextRequest) {
       ...(allowedOverrideModelsByProvider !== undefined
         ? { allowedOverrideModelsByProvider }
         : {}),
+      ...(Object.prototype.hasOwnProperty.call(bodyResult.data, 'inputModeration')
+        ? { inputModeration: bodyResult.data.inputModeration ?? null }
+        : {}),
     }
     const row = await repo.upsertDefault(
       upsertInput,
@@ -734,6 +756,7 @@ export async function PUT(req: NextRequest) {
       baseURL: row.baseUrl,
       allowedOverrideProviders: row.allowedOverrideProviders ?? null,
       allowedOverrideModelsByProvider: row.allowedOverrideModelsByProvider ?? {},
+      inputModeration: row.inputModeration ?? null,
       updatedAt: row.updatedAt,
     })
   } catch (error) {
@@ -777,11 +800,11 @@ export async function DELETE(req: NextRequest) {
   try {
     const container = await createRequestContainer()
     const rbacService = container.resolve<RbacService>('rbacService')
-    const acl = await rbacService.loadAcl(auth.sub, {
-      tenantId: auth.tenantId,
-      organizationId: auth.orgId,
-    })
-    const canManage = acl.isSuperAdmin || acl.features.includes('ai_assistant.settings.manage')
+    const canManage = await rbacService.userHasAllFeatures(
+      auth.sub,
+      ['ai_assistant.settings.manage'],
+      { tenantId: auth.tenantId, organizationId: auth.orgId },
+    )
     if (!canManage) {
       return NextResponse.json({ error: 'Forbidden', code: 'forbidden' }, { status: 403 })
     }

package/src/modules/ai_assistant/backend/config/ai-assistant/agents/AiAgentSettingsPageClient.tsx

@@ -121,6 +121,14 @@ type AgentResolution = {
   modelId: string
   baseURL: string | null
   source: string
+  moderation?: {
+    /** `untrustedInput` agents enforce moderation (non-editable). */
+    enforced: boolean
+    /** Per-agent control value: null = inherit, true = on, false = off. */
+    override: boolean | null
+    /** Resolved runtime policy after the precedence chain. */
+    effective: 'enforced' | 'on' | 'off'
+  }
 }
 
 type TenantAllowlist = {
@@ -875,6 +883,142 @@ function MutationPolicySection({ agent }: { agent: AgentSettings }) {
   )
 }
 
+type ModerationControlValue = 'inherit' | 'on' | 'off'
+
+function ModerationSection({ agent }: { agent: AgentSettings }) {
+  const t = useT()
+  const queryClient = useQueryClient()
+  const settingsQuery = useQuery<RuntimeSettingsResponse>({
+    queryKey: ['ai_assistant', 'agent_settings', 'runtime_settings'],
+    queryFn: fetchRuntimeSettings,
+    retry: false,
+  })
+  const agentResolution = settingsQuery.data?.agents.find((entry) => entry.agentId === agent.id) ?? null
+  const moderation = agentResolution?.moderation ?? null
+  const enforced = moderation?.enforced === true
+  const currentValue: ModerationControlValue =
+    moderation?.override === true ? 'on' : moderation?.override === false ? 'off' : 'inherit'
+  const [isSaving, setIsSaving] = React.useState(false)
+  const { runMutation } = useGuardedMutation({ contextId: `ai-agent-moderation-${agent.id}` })
+
+  const save = React.useCallback(
+    async (value: ModerationControlValue) => {
+      if (isSaving || enforced) return
+      setIsSaving(true)
+      try {
+        const inputModeration = value === 'inherit' ? null : value === 'on'
+        await runMutation({
+          operation: async () => {
+            const { ok, status, result } = await apiCall<{ error?: string }>(
+              '/api/ai_assistant/settings',
+              {
+                method: 'PUT',
+                headers: { 'content-type': 'application/json' },
+                credentials: 'include',
+                body: JSON.stringify({ agentId: agent.id, inputModeration }),
+              },
+            )
+            if (!ok) {
+              throw new Error(result?.error ?? `[internal] Failed to save moderation setting (${status}).`)
+            }
+          },
+          context: {},
+        })
+        flash(t('ai_assistant.agents.moderation.saved', 'Input moderation setting saved.'), 'success')
+        await queryClient.invalidateQueries({
+          queryKey: ['ai_assistant', 'agent_settings', 'runtime_settings'],
+        })
+      } catch (err) {
+        flash(err instanceof Error ? err.message : String(err), 'error')
+      } finally {
+        setIsSaving(false)
+      }
+    },
+    [agent.id, enforced, isSaving, queryClient, runMutation, t],
+  )
+
+  return (
+    <section
+      className="rounded-lg border border-border bg-background p-4"
+      data-ai-agent-moderation={agent.id}
+    >
+      <header className="flex flex-wrap items-start justify-between gap-3 border-b border-border pb-3">
+        <div className="flex min-w-0 items-start gap-2">
+          <ShieldAlert className="size-4 text-muted-foreground" aria-hidden />
+          <div className="min-w-0">
+            <h3 className="text-sm font-semibold">
+              {t('ai_assistant.agents.moderation.title', 'Input moderation')}
+            </h3>
+            <p className="text-xs text-muted-foreground">
+              {t(
+                'ai_assistant.agents.moderation.subtitle',
+                'Screen user input for unsafe content before the model runs. Applies only when the resolved provider supports moderation.',
+              )}
+            </p>
+          </div>
+        </div>
+        {moderation ? (
+          <StatusBadge
+            variant={moderation.effective === 'off' ? 'neutral' : 'info'}
+            dot
+            data-ai-agent-moderation-effective
+          >
+            {moderation.effective === 'enforced'
+              ? t('ai_assistant.agents.moderation.effectiveEnforced', 'Enforced')
+              : moderation.effective === 'on'
+                ? t('ai_assistant.agents.moderation.effectiveOn', 'On')
+                : t('ai_assistant.agents.moderation.effectiveOff', 'Off')}
+          </StatusBadge>
+        ) : null}
+      </header>
+
+      <div className="mt-3">
+        {enforced ? (
+          <div className="flex flex-wrap items-center gap-2" data-ai-agent-moderation-enforced>
+            <StatusBadge variant="warning" dot>
+              {t('ai_assistant.agents.moderation.enforcedBadge', 'Enforced')}
+            </StatusBadge>
+            <p className="text-xs text-muted-foreground">
+              {t(
+                'ai_assistant.agents.moderation.enforcedHint',
+                'This agent accepts untrusted input, so moderation is always on and cannot be disabled here.',
+              )}
+            </p>
+          </div>
+        ) : (
+          <div className="max-w-xs">
+            <span className="text-overline font-semibold uppercase tracking-wider text-muted-foreground">
+              {t('ai_assistant.agents.moderation.controlLabel', 'Moderation')}
+            </span>
+            <div className="mt-1">
+              <Select
+                value={currentValue}
+                onValueChange={(value) => save(value as ModerationControlValue)}
+                disabled={isSaving || !agentResolution}
+              >
+                <SelectTrigger aria-label={t('ai_assistant.agents.moderation.controlLabel', 'Moderation')}>
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value="inherit">
+                    {t('ai_assistant.agents.moderation.inheritLabel', 'Inherit')}
+                  </SelectItem>
+                  <SelectItem value="on">
+                    {t('ai_assistant.agents.moderation.onLabel', 'On')}
+                  </SelectItem>
+                  <SelectItem value="off">
+                    {t('ai_assistant.agents.moderation.offLabel', 'Off')}
+                  </SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+          </div>
+        )}
+      </div>
+    </section>
+  )
+}
+
 function AgentModelOverrideSection({ agent }: { agent: AgentSettings }) {
   const t = useT()
   const queryClient = useQueryClient()
@@ -2063,6 +2207,8 @@ function AgentDetailPanel({ agent }: { agent: AgentSettings }) {
 
       <AgentModelOverrideSection agent={agent} />
 
+      <ModerationSection agent={agent} />
+
       <MutationPolicySection agent={agent} />
 
       <LoopPolicySection agent={agent} />

package/src/modules/ai_assistant/backend/config/ai-assistant/moderation-flags/AiModerationFlagsPageClient.tsx

@@ -0,0 +1,186 @@
+'use client'
+
+import * as React from 'react'
+import { useQuery } from '@tanstack/react-query'
+import type { ColumnDef } from '@tanstack/react-table'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import { DataTable } from '@open-mercato/ui/backend/DataTable'
+import { Button } from '@open-mercato/ui/primitives/button'
+import { Input } from '@open-mercato/ui/primitives/input'
+import { Label } from '@open-mercato/ui/primitives/label'
+import { StatusBadge } from '@open-mercato/ui/primitives/status-badge'
+import { apiCallOrThrow } from '@open-mercato/ui/backend/utils/apiCall'
+
+const PAGE_SIZE = 50
+
+type ModerationCategory = { flagged: boolean; score: number }
+
+type ModerationFlagRow = {
+  id: string
+  tenantId: string
+  organizationId: string | null
+  agentId: string
+  userId: string
+  providerId: string
+  modelId: string
+  categories: Record<string, ModerationCategory>
+  createdAt: string
+}
+
+type ModerationFlagsResponse = {
+  items: ModerationFlagRow[]
+  total: number
+  page: number
+  pageSize: number
+}
+
+async function fetchModerationFlags(params: {
+  page: number
+  from: string
+  to: string
+  agentId: string
+  userId: string
+}): Promise<ModerationFlagsResponse> {
+  const search = new URLSearchParams()
+  search.set('page', String(params.page))
+  search.set('pageSize', String(PAGE_SIZE))
+  if (params.from) search.set('from', params.from)
+  if (params.to) search.set('to', params.to)
+  if (params.agentId) search.set('agentId', params.agentId)
+  if (params.userId) search.set('userId', params.userId)
+  const { result, status } = await apiCallOrThrow<ModerationFlagsResponse>(
+    `/api/ai_assistant/moderation-flags?${search.toString()}`,
+    undefined,
+    { errorMessage: 'Failed to load moderation flags' },
+  )
+  if (!result) throw new Error(`Failed to load moderation flags (${status})`)
+  return result
+}
+
+function flaggedCategoryNames(categories: Record<string, ModerationCategory>): string[] {
+  return Object.entries(categories)
+    .filter(([, value]) => value.flagged)
+    .map(([name]) => name)
+}
+
+export function AiModerationFlagsPageClient() {
+  const t = useT()
+  const [page, setPage] = React.useState(1)
+  const [from, setFrom] = React.useState('')
+  const [to, setTo] = React.useState('')
+  const [agentId, setAgentId] = React.useState('')
+  const [userId, setUserId] = React.useState('')
+  const [applied, setApplied] = React.useState({ from: '', to: '', agentId: '', userId: '' })
+
+  const query = useQuery<ModerationFlagsResponse>({
+    queryKey: ['ai_assistant', 'moderation_flags', page, applied],
+    queryFn: () => fetchModerationFlags({ page, ...applied }),
+    retry: false,
+  })
+
+  const applyFilters = React.useCallback(() => {
+    setPage(1)
+    setApplied({ from, to, agentId, userId })
+  }, [from, to, agentId, userId])
+
+  const columns = React.useMemo<ColumnDef<ModerationFlagRow, unknown>[]>(
+    () => [
+      {
+        accessorKey: 'agentId',
+        header: t('ai_assistant.moderationFlags.columns.agent', 'Agent'),
+      },
+      {
+        accessorKey: 'userId',
+        header: t('ai_assistant.moderationFlags.columns.user', 'User'),
+        meta: { truncate: true, maxWidth: 220 },
+      },
+      {
+        accessorKey: 'categories',
+        header: t('ai_assistant.moderationFlags.columns.categories', 'Categories'),
+        cell: ({ row }) => {
+          const names = flaggedCategoryNames(row.original.categories)
+          if (names.length === 0) {
+            return <span className="text-muted-foreground">—</span>
+          }
+          return (
+            <div className="flex flex-wrap gap-1">
+              {names.map((name) => (
+                <StatusBadge key={name} variant="error" dot>
+                  {name}
+                </StatusBadge>
+              ))}
+            </div>
+          )
+        },
+      },
+      {
+        accessorKey: 'createdAt',
+        header: t('ai_assistant.moderationFlags.columns.createdAt', 'Flagged at'),
+        cell: ({ row }) => new Date(row.original.createdAt).toLocaleString(),
+      },
+    ],
+    [t],
+  )
+
+  const total = query.data?.total ?? 0
+
+  return (
+    <div className="flex flex-col gap-4">
+      <div>
+        <h2 className="text-base font-semibold">
+          {t('ai_assistant.moderationFlags.title', 'Moderation flags')}
+        </h2>
+        <p className="text-xs text-muted-foreground">
+          {t(
+            'ai_assistant.moderationFlags.subtitle',
+            'Inputs blocked by the content safety filter. Category flags and scores only — no prompt content is stored.',
+          )}
+        </p>
+      </div>
+
+      <div className="flex flex-wrap items-end gap-3">
+        <div className="flex flex-col gap-1">
+          <Label htmlFor="moderation-from">{t('ai_assistant.moderationFlags.filters.from', 'From')}</Label>
+          <Input id="moderation-from" type="date" value={from} onChange={(e) => setFrom(e.target.value)} />
+        </div>
+        <div className="flex flex-col gap-1">
+          <Label htmlFor="moderation-to">{t('ai_assistant.moderationFlags.filters.to', 'To')}</Label>
+          <Input id="moderation-to" type="date" value={to} onChange={(e) => setTo(e.target.value)} />
+        </div>
+        <div className="flex flex-col gap-1">
+          <Label htmlFor="moderation-agent">{t('ai_assistant.moderationFlags.columns.agent', 'Agent')}</Label>
+          <Input
+            id="moderation-agent"
+            value={agentId}
+            onChange={(e) => setAgentId(e.target.value)}
+            placeholder={t('ai_assistant.moderationFlags.filters.agentPlaceholder', 'module.agent')}
+          />
+        </div>
+        <div className="flex flex-col gap-1">
+          <Label htmlFor="moderation-user">{t('ai_assistant.moderationFlags.columns.user', 'User')}</Label>
+          <Input id="moderation-user" value={userId} onChange={(e) => setUserId(e.target.value)} />
+        </div>
+        <Button type="button" variant="outline" onClick={applyFilters}>
+          {t('ai_assistant.moderationFlags.filters.apply', 'Apply')}
+        </Button>
+      </div>
+
+      <DataTable<ModerationFlagRow>
+        columns={columns}
+        data={query.data?.items ?? []}
+        isLoading={query.isLoading}
+        error={query.error ? (query.error as Error).message : undefined}
+        emptyState={t('ai_assistant.moderationFlags.empty', 'No flagged messages.')}
+        pagination={{
+          page,
+          pageSize: PAGE_SIZE,
+          total,
+          totalPages: Math.max(1, Math.ceil(total / PAGE_SIZE)),
+          onPageChange: setPage,
+        }}
+      />
+    </div>
+  )
+}
+
+export default AiModerationFlagsPageClient

package/src/modules/ai_assistant/backend/config/ai-assistant/moderation-flags/page.meta.ts

@@ -0,0 +1,24 @@
+import React from 'react'
+
+const moderationIcon = React.createElement(
+  'svg',
+  { width: 16, height: 16, viewBox: '0 0 24 24', fill: 'none', stroke: 'currentColor', strokeWidth: 2, strokeLinecap: 'round', strokeLinejoin: 'round' },
+  React.createElement('path', { d: 'M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z' }),
+  React.createElement('path', { d: 'M12 8v4' }),
+  React.createElement('path', { d: 'M12 16h.01' }),
+)
+
+export const metadata = {
+  requireAuth: true,
+  requireFeatures: ['ai_assistant.settings.manage'],
+  pageTitle: 'Moderation flags',
+  pageTitleKey: 'ai_assistant.moderationFlags.navTitle',
+  pageGroup: 'Module Configs',
+  pageGroupKey: 'settings.sections.moduleConfigs',
+  pageOrder: 432,
+  icon: moderationIcon,
+  pageContext: 'settings' as const,
+  breadcrumb: [
+    { label: 'Moderation flags', labelKey: 'ai_assistant.moderationFlags.navTitle' },
+  ],
+} as const

package/src/modules/ai_assistant/backend/config/ai-assistant/moderation-flags/page.tsx

@@ -0,0 +1,12 @@
+import { Page, PageBody } from '@open-mercato/ui/backend/Page'
+import { AiModerationFlagsPageClient } from './AiModerationFlagsPageClient'
+
+export default async function AiModerationFlagsPage() {
+  return (
+    <Page>
+      <PageBody>
+        <AiModerationFlagsPageClient />
+      </PageBody>
+    </Page>
+  )
+}

package/src/modules/ai_assistant/data/entities.ts

@@ -361,6 +361,17 @@ export class AiAgentRuntimeOverride {
    */
   @Property({ name: 'loop_active_tools_json', type: 'jsonb', nullable: true })
   loopActiveToolsJson?: unknown | null
+
+  /**
+   * Per-agent (or tenant-wide when `agent_id` is null) input-moderation
+   * override. `true` = on, `false` = off, `null` = inherit (env default →
+   * off). Additive nullable column; existing rows inherit. The `untrustedInput`
+   * agent flag still forces moderation regardless of this value.
+   *
+   * Spec `2026-06-04-ai-input-moderation-and-safety-identifiers`.
+   */
+  @Property({ name: 'input_moderation', type: 'boolean', nullable: true })
+  inputModeration?: boolean | null
 }
 
 /**
@@ -933,3 +944,48 @@ export class AiChatMessage {
   @Property({ name: 'deleted_at', type: Date, nullable: true })
   deletedAt?: Date | null
 }
+
+/**
+ * Append-only audit record of an input that the moderation gate blocked.
+ *
+ * Stores ONLY category flags + numeric scores — never the prompt content or
+ * any PII (Q4 data-minimization decision). Enough to identify repeat abusers
+ * and tune policy. No `updated_at` / `deleted_at`: rows are immutable. Two
+ * indexes back the audit listing (`tenant_id, created_at`) and the per-user
+ * abuse review (`tenant_id, user_id`); every read filters `tenant_id`.
+ *
+ * Spec `2026-06-04-ai-input-moderation-and-safety-identifiers`.
+ */
+@Entity({ tableName: 'ai_moderation_flags' })
+@Index({ name: 'ai_moderation_flags_tenant_created_idx', properties: ['tenantId', 'createdAt'] })
+@Index({ name: 'ai_moderation_flags_tenant_user_idx', properties: ['tenantId', 'userId'] })
+export class AiModerationFlag {
+  [OptionalProps]?: 'id' | 'createdAt' | 'organizationId'
+
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @Property({ name: 'organization_id', type: 'uuid', nullable: true })
+  organizationId?: string | null
+
+  @Property({ name: 'agent_id', type: 'text' })
+  agentId!: string
+
+  @Property({ name: 'user_id', type: 'text' })
+  userId!: string
+
+  @Property({ name: 'provider_id', type: 'text' })
+  providerId!: string
+
+  @Property({ name: 'model_id', type: 'text' })
+  modelId!: string
+
+  @Property({ name: 'categories', type: 'jsonb' })
+  categories!: Record<string, { flagged: boolean; score: number }>
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+}

package/src/modules/ai_assistant/data/repositories/AiAgentRuntimeOverrideRepository.ts

@@ -35,6 +35,8 @@ export interface AiAgentRuntimeOverrideInput extends AiAgentRuntimeOverrideLoopI
   baseURL?: string | null
   allowedOverrideProviders?: string[] | null
   allowedOverrideModelsByProvider?: Record<string, string[]>
+  /** Input-moderation override: true = on, false = off, null = inherit. */
+  inputModeration?: boolean | null
   /**
    * Optional: the agent's declared allowedTools. When provided, loopActiveToolsJson
    * is validated to be a subset. When omitted, allowlist validation is skipped
@@ -270,6 +272,7 @@ export class AiAgentRuntimeOverrideRepository {
         if ('loopMaxTokens' in input) existing.loopMaxTokens = input.loopMaxTokens ?? null
         if ('loopStopWhenJson' in input) existing.loopStopWhenJson = input.loopStopWhenJson ?? null
         if ('loopActiveToolsJson' in input) existing.loopActiveToolsJson = input.loopActiveToolsJson ?? null
+        if ('inputModeration' in input) existing.inputModeration = input.inputModeration ?? null
         await tx.persist(existing).flush()
         return existing
       }
@@ -295,6 +298,7 @@ export class AiAgentRuntimeOverrideRepository {
         loopMaxTokens: input.loopMaxTokens ?? null,
         loopStopWhenJson: input.loopStopWhenJson ?? null,
         loopActiveToolsJson: input.loopActiveToolsJson ?? null,
+        inputModeration: input.inputModeration ?? null,
       } as unknown as AiAgentRuntimeOverride)
       await tx.persist(row).flush()
       return row

package/src/modules/ai_assistant/data/repositories/AiModerationFlagRepository.ts

@@ -0,0 +1,79 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { AiModerationFlag } from '../entities'
+import type { ModerationCategoryResult } from '../../lib/moderation'
+
+export interface CreateModerationFlagInput {
+  tenantId: string
+  organizationId?: string | null
+  agentId: string
+  userId: string
+  providerId: string
+  modelId: string
+  categories: Record<string, ModerationCategoryResult>
+}
+
+export interface ListModerationFlagsFilter {
+  tenantId: string
+  organizationId?: string | null
+  agentId?: string
+  userId?: string
+  /** Inclusive lower bound on `created_at`. */
+  from?: Date
+  /** Inclusive upper bound on `created_at`. */
+  to?: Date
+  page: number
+  pageSize: number
+}
+
+export interface ModerationFlagListResult {
+  items: AiModerationFlag[]
+  total: number
+}
+
+/**
+ * Repository for the append-only `ai_moderation_flags` audit table. Every read
+ * is tenant-scoped — cross-tenant access is structurally impossible because
+ * `tenantId` is always part of the filter.
+ *
+ * Spec `2026-06-04-ai-input-moderation-and-safety-identifiers`.
+ */
+export class AiModerationFlagRepository {
+  constructor(private readonly em: EntityManager) {}
+
+  async create(input: CreateModerationFlagInput): Promise<AiModerationFlag> {
+    const flag = this.em.create(AiModerationFlag, {
+      tenantId: input.tenantId,
+      organizationId: input.organizationId ?? null,
+      agentId: input.agentId,
+      userId: input.userId,
+      providerId: input.providerId,
+      modelId: input.modelId,
+      categories: input.categories,
+    })
+    this.em.persist(flag)
+    await this.em.flush()
+    return flag
+  }
+
+  async list(filter: ListModerationFlagsFilter): Promise<ModerationFlagListResult> {
+    const where: Record<string, unknown> = { tenantId: filter.tenantId }
+    if (filter.organizationId !== undefined && filter.organizationId !== null) {
+      where.organizationId = filter.organizationId
+    }
+    if (filter.agentId) where.agentId = filter.agentId
+    if (filter.userId) where.userId = filter.userId
+    if (filter.from || filter.to) {
+      const createdAt: Record<string, Date> = {}
+      if (filter.from) createdAt.$gte = filter.from
+      if (filter.to) createdAt.$lte = filter.to
+      where.createdAt = createdAt
+    }
+
+    const [items, total] = await this.em.findAndCount(AiModerationFlag, where, {
+      orderBy: { createdAt: 'desc' },
+      limit: filter.pageSize,
+      offset: (filter.page - 1) * filter.pageSize,
+    })
+    return { items, total }
+  }
+}

package/src/modules/ai_assistant/di.ts

@@ -1,9 +1,13 @@
-import { asValue } from 'awilix'
+import { asFunction, asValue } from 'awilix'
 import type { AwilixContainer } from 'awilix'
 import { toolRegistry } from './lib/tool-registry'
+import { createModerationService } from './lib/moderation'
 
 export function register(container: AwilixContainer): void {
   container.register({
     mcpToolRegistry: asValue(toolRegistry),
+    // Input pre-moderation service (OpenAI /v1/moderations). Singleton +
+    // overridable by downstream apps via the module overrides DI seam.
+    moderationService: asFunction(() => createModerationService()).singleton(),
   })
 }