@blogmcp/community 0.2.0 → 0.3.0

package/src/core/forum-words.ts

@@ -0,0 +1,38 @@
+/**
+ * The forum's words for the discussion's components (m3-contracts.md §5.3): a topic's thread reuses the discussion's
+ * view — the same messages, composer, dialogs and refusals — and reads it with these keys in place of the
+ * discussion's, so a forum reads „příspěvek" (a post) where an article's discussion reads „komentář" (a comment). Every
+ * key is the SDK catalogue's in both languages; a plural maps by its name (test/forum-elements.spec.ts checks both).
+ */
+import type { CommunityMessageKey } from '@blogmcp/sdk/community'
+
+export const FORUM_WORDS: Readonly<Partial<Record<CommunityMessageKey, CommunityMessageKey>>> = Object.freeze({
+  'composer.label': 'forumText.composer.label',
+  'composer.editLabel': 'forumText.composer.editLabel',
+  'composer.placeholder': 'forumText.composer.placeholder',
+  'composer.tooLong': 'forumText.composer.tooLong',
+  'composer.linksNote': 'forumText.composer.linksNote',
+  'composer.posted': 'forumText.composer.posted',
+  'composer.held': 'forumText.composer.held',
+  'composer.cooldown': 'forumText.composer.cooldown',
+  'discussion.empty': 'forumText.discussion.empty',
+  'discussion.deleteTitle': 'forumText.discussion.deleteTitle',
+  'discussion.deleteExplain': 'forumText.discussion.deleteExplain',
+  'discussion.collapsed': 'forumText.discussion.collapsed',
+  'discussion.heldNote': 'forumText.discussion.heldNote',
+  'discussion.hiddenUntilConsentNote': 'forumText.discussion.hiddenUntilConsentNote',
+  'discussion.removedNote': 'forumText.discussion.removedNote',
+  'discussion.placeholderHeld': 'forumText.discussion.placeholderHeld',
+  'discussion.placeholderRemoved': 'forumText.discussion.placeholderRemoved',
+  'discussion.placeholderDeleted': 'forumText.discussion.placeholderDeleted',
+  'report.title': 'forumText.report.title',
+  'report.category': 'forumText.report.category',
+  'error.links': 'forumText.error.links',
+  'error.blocked': 'forumText.error.blocked',
+  'error.confirm': 'forumText.error.confirm',
+  'confirm.other': 'forumText.confirm.other',
+  'warning.identifier': 'forumText.warning.identifier',
+  'warning.other': 'forumText.warning.other',
+  'need.onboarding': 'forumText.need.onboarding',
+  'need.art9_consent': 'forumText.need.art9_consent',
+})

package/src/core/forum.ts

@@ -0,0 +1,83 @@
+/**
+ * `<blogmcp-forum>`'s brain (m3-contracts.md §3.2, §5.3): the listed categories in the team's order
+ * (`forum/categories/list`), each with its latest topics (`forum/topics/list`, the activity order, a few rows of the
+ * first categories), and `me/get` for the notices (away mode, the forum's pause). The forum is for its members:
+ * anyone else gets `membersOnly` (with `needs` for a member session short of its onboarding); a forum switched off
+ * renders nothing.
+ */
+import { reactive } from 'vue'
+import {
+  knownTopicItemsOf,
+  type CommunityCallOptions,
+  type CommunityClient,
+  type CommunityFailure,
+  type ForumCategory,
+  type KnownTopicItem,
+  type MyState,
+} from '@blogmcp/sdk/community'
+
+export type ForumPhase = 'loading' | 'ready' | 'failed' | 'hidden' | 'membersOnly'
+
+/** The categories whose latest topics the index shows, and how many of each (one request a category). */
+export const FORUM_LATEST_CATEGORIES = 10
+export const FORUM_LATEST_PER_CATEGORY = 3
+
+export interface ForumUi {
+  phase: ForumPhase
+  failure: CommunityFailure | null
+  me: MyState | null
+  categories: ForumCategory[]
+  /** The latest rows of a category, by its id (a category whose list failed has none). */
+  latest: Record<string, KnownTopicItem[]>
+}
+
+export interface ForumController {
+  readonly state: ForumUi
+  load(): Promise<void>
+  dispose(): void
+}
+
+export function createForum(o: { client: CommunityClient }): ForumController {
+  const { client } = o
+  const abort = new AbortController()
+  const call: CommunityCallOptions = { signal: abort.signal }
+  let disposed = false
+  let ticket = 0
+  const state = reactive<ForumUi>({ phase: 'loading', failure: null, me: null, categories: [], latest: {} }) as ForumUi
+
+  async function load(): Promise<void> {
+    const mine = ++ticket
+    state.phase = 'loading'
+    state.failure = null
+    const [me, list] = await Promise.all([client.me.get(call), client.forum.categories.list(call)])
+    if (disposed || mine !== ticket) return
+    if (me.ok) state.me = me.value
+    if (!list.ok) {
+      state.failure = list
+      state.phase = list.code === 'surfaceOff' ? 'hidden' : list.code === 'membersOnly' ? 'membersOnly' : 'failed'
+      return
+    }
+    state.categories = [...list.value.categories].sort((a, b) => a.position - b.position)
+    state.latest = {}
+    state.phase = 'ready'
+    // The latest rows of the first categories, side by side; a category whose list fails just shows none.
+    const first = state.categories.slice(0, FORUM_LATEST_CATEGORIES)
+    const pages = await Promise.all(first.map((c) => client.forum.topics.list({ categoryId: c.id, sort: 'activity', limit: FORUM_LATEST_PER_CATEGORY }, call)))
+    if (disposed || mine !== ticket) return
+    const latest: Record<string, KnownTopicItem[]> = {}
+    first.forEach((c, i) => {
+      const page = pages[i]
+      if (page?.ok) latest[c.id] = knownTopicItemsOf(page.value.items).slice(0, FORUM_LATEST_PER_CATEGORY)
+    })
+    state.latest = latest
+  }
+
+  return {
+    state,
+    load,
+    dispose() {
+      disposed = true
+      abort.abort()
+    },
+  }
+}

package/src/core/moderation.ts

@@ -0,0 +1,414 @@
+/**
+ * `<blogmcp-forum-moderation>`'s brain (m3-contracts.md §3.4, §4.2, §4.5, §5.3; D-M3-6): a category moderator's queue —
+ * the cases of category `rules` in their categories (open ones, and decided ones a `system` decision still holds:
+ * `caseStatus`) and the messages waiting in pre-moderation — and what they do with them:
+ *
+ *   - a case: its package as written (text only; no reporter, note or contact), then a decision through the engine —
+ *     restore (`no_action`), hide (`visibility_restricted`) or remove — with the facts and the rule it rests on (the
+ *     case's own by default: a restriction without one is `invalid` on `contractualGround`, and the rule is asked for),
+ *     the statement previewed first (`dryRun`), decided after; or passed to the team (`moderation/escalate`, a category
+ *     of the illegal line);
+ *   - a pre-moderated message: published (no statement: nothing was restricted) or refused (a rule and the facts: a
+ *     removal with its statement) — M3 FX (R3): the queue carries its text (rendered as text) and its `rev`, and the
+ *     review sends the `rev` back: kb-api decides that text only. A refusal other than `notFound` (STALE_REVISION is
+ *     `submit`) re-reads the item: its author edited it meanwhile → the new text is shown with `moderation.textChanged`
+ *     and the moderator decides again; gone → it leaves the queue.
+ *
+ * A member who moderates nothing now (me/get's `moderator` null or empty) gets nothing at all: the element renders
+ * nothing. kb-api re-checks the appointment on every call — anything outside the moderator's scope is `notFound`, and
+ * the row leaves the queue.
+ */
+import { reactive } from 'vue'
+import {
+  ESCALATION_CATEGORIES,
+  communityRulesOf,
+  type CaseCategory,
+  type CommunityCallOptions,
+  type CommunityClient,
+  type CommunityFailure,
+  type CommunityRule,
+  type ForumCategory,
+  type ModerationCase,
+  type ModerationItem,
+  type ModerationRestriction,
+  type MyState,
+} from '@blogmcp/sdk/community'
+import type { Lang, TextRef } from './i18n'
+import { failureText } from './outcomes'
+import { codePointLength, normalizeBody } from './text'
+
+export type ModerationPhase = 'loading' | 'ready' | 'none' | 'failed' | 'hidden' | 'membersOnly'
+
+/** The facts' bound here (kb-api checks its own). */
+const FACTS_MAX = 4000
+
+/** A case opened from the queue: its package and the decision being made. */
+export interface OpenCase {
+  item: ModerationItem
+  kase: ModerationCase | null
+  loading: boolean
+  restriction: ModerationRestriction | ''
+  facts: string
+  /** The rule the restriction rests on ('' the case's own). */
+  ground: string
+  /** kb-api asked for the rule (`invalid` on `contractualGround`): the rule must be chosen. */
+  needsRule: boolean
+  /** The statement of the previewed decision, for the same choice. */
+  preview: string | null
+  previewing: boolean
+  deciding: boolean
+  failure: CommunityFailure | null
+  decided: boolean
+  escalation: { category: CaseCategory | ''; sending: boolean; failure: CommunityFailure | null; done: boolean } | null
+}
+
+/** A pre-moderated message being reviewed. */
+export interface PremodReview {
+  item: ModerationItem
+  outcome: 'approve' | 'reject' | ''
+  ruleId: string
+  facts: string
+  sending: boolean
+  failure: CommunityFailure | null
+  statement: string | null
+  done: 'approved' | 'rejected' | null
+  /** M3 FX (R3): the author edited the text while it was being reviewed — `item` holds the new one; decide again. */
+  changed: boolean
+}
+
+/** How far a review's re-read pages the queue for its item (50 a page): the queue is oldest first and the item is old. */
+const REREAD_PAGES = 20
+
+export interface ModerationUi {
+  phase: ModerationPhase
+  failure: CommunityFailure | null
+  me: MyState | null
+  /** '' every category of the moderator's. */
+  categoryId: string
+  /** The moderator's categories (their names), in the forum's order. */
+  categories: ForumCategory[]
+  items: ModerationItem[]
+  nextCursor: string | null
+  loadingMore: boolean
+  rules: CommunityRule[] | null
+  open: OpenCase | null
+  review: PremodReview | null
+  announcement: TextRef | null
+  announceId: number
+}
+
+export interface ModerationController {
+  readonly state: ModerationUi
+  load(): Promise<void>
+  loadMore(): Promise<void>
+  setCategory(categoryId: string): Promise<void>
+  openCase(item: ModerationItem): Promise<void>
+  closeCase(): void
+  /** Whether the case's decision may be previewed now (a restriction, facts, a rule where one is needed). */
+  canPreview(): boolean
+  preview(): Promise<void>
+  decide(): Promise<void>
+  startEscalation(): void
+  escalate(): Promise<void>
+  openReview(item: ModerationItem, outcome: 'approve' | 'reject'): void
+  closeReview(): void
+  review(): Promise<void>
+  dispose(): void
+}
+
+export function createModeration(o: { client: CommunityClient; lang: Lang; categoryId?: string | null }): ModerationController {
+  const { client, lang } = o
+  const abort = new AbortController()
+  const call: CommunityCallOptions = { signal: abort.signal }
+  let disposed = false
+  let ticket = 0
+  const state = reactive<ModerationUi>({
+    phase: 'loading',
+    failure: null,
+    me: null,
+    categoryId: o.categoryId?.toLowerCase() ?? '',
+    categories: [],
+    items: [],
+    nextCursor: null,
+    loadingMore: false,
+    rules: null,
+    open: null,
+    review: null,
+    announcement: null,
+    announceId: 0,
+  }) as ModerationUi
+
+  const announce = (text: TextRef): void => {
+    state.announcement = text
+    state.announceId += 1
+  }
+
+  /** The moderator's categories now (me/get), or none. */
+  const categoryIds = (): string[] => [...(state.me?.moderator?.categoryIds ?? [])].map((id) => id.toLowerCase())
+
+  /** A row the moderator may no longer act on (another moderator decided it, the appointment ended): out of the queue. */
+  function gone(item: ModerationItem): void {
+    state.items = state.items.filter((i) => i !== item)
+    announce({ key: 'moderation.gone' })
+  }
+
+  const queueInput = (cursor: string | null) => ({ ...(state.categoryId !== '' ? { categoryId: state.categoryId } : {}), ...(cursor ? { cursor } : {}) })
+
+  async function readQueue(mine: number): Promise<void> {
+    const r = await client.moderation.queue(queueInput(null), call)
+    if (disposed || mine !== ticket) return
+    if (!r.ok) {
+      state.failure = r
+      // Not (or no longer) a moderator of what was asked: nothing to show.
+      state.phase = r.code === 'notFound' ? 'none' : r.code === 'surfaceOff' ? 'hidden' : r.code === 'membersOnly' ? 'membersOnly' : 'failed'
+      return
+    }
+    state.items = [...r.value.items]
+    state.nextCursor = r.value.nextCursor
+    state.phase = 'ready'
+  }
+
+  async function loadRules(): Promise<void> {
+    if (state.rules !== null) return
+    const r = await client.legal.current({ kind: 'rules', locale: lang }, call)
+    if (!disposed && r.ok) state.rules = communityRulesOf(r.value.bodyJson)
+  }
+
+  async function load(): Promise<void> {
+    const mine = ++ticket
+    state.phase = 'loading'
+    state.failure = null
+    const me = await client.me.get(call)
+    if (disposed || mine !== ticket) return
+    if (!me.ok) {
+      state.failure = me
+      state.phase = 'failed'
+      return
+    }
+    state.me = me.value
+    // A member who moderates nothing now: nothing at all (not even a heading).
+    if (categoryIds().length === 0) {
+      state.phase = 'none'
+      return
+    }
+    const list = await client.forum.categories.list(call)
+    if (disposed || mine !== ticket) return
+    if (list.ok) state.categories = list.value.categories.filter((c) => categoryIds().includes(c.id.toLowerCase()))
+    // The rules' titles name a queued case's rule (and the decision's choices).
+    void loadRules()
+    if (state.categoryId !== '' && !categoryIds().includes(state.categoryId)) state.categoryId = ''
+    await readQueue(mine)
+  }
+
+  const decisionInput = (dryRun: boolean) => {
+    const c = state.open!
+    return {
+      caseId: c.item.caseId!,
+      restriction: c.restriction as ModerationRestriction,
+      // A member's report is a notice (DSA art. 16); the filters' and the team's cases are the provider's initiative.
+      basis: c.item.source === 'member_report' ? ('notice' as const) : ('own_initiative' as const),
+      facts: normalizeBody(c.facts),
+      ...(c.ground !== '' ? { contractualGround: c.ground } : {}),
+      locale: lang,
+      dryRun,
+    }
+  }
+
+  function canPreview(): boolean {
+    const c = state.open
+    if (!c || !c.kase || c.restriction === '' || c.previewing || c.deciding || c.decided) return false
+    const facts = normalizeBody(c.facts)
+    if (facts === '' || codePointLength(facts) > FACTS_MAX) return false
+    // A restriction rests on a rule: the case's own, else one chosen (kb-api asks for it when the case has none).
+    return c.restriction === 'no_action' || c.ground !== '' || (c.kase.ruleId !== null && !c.needsRule)
+  }
+
+  /**
+   * R3: after a review's refusal, the item as the queue holds it now. Its text changed (a newer rev) — the review shows
+   * the new text (`changed`) and asks again; it is no longer queued — it leaves; unchanged — the refusal stands.
+   */
+  async function reread(v: PremodReview): Promise<void> {
+    const same = (i: ModerationItem): boolean => i.kind === 'premod' && i.conversationId === v.item.conversationId && i.seq === v.item.seq
+    let cursor: string | null = null
+    for (let page = 0; page < REREAD_PAGES; page++) {
+      const r = await client.moderation.queue(queueInput(cursor), call)
+      if (disposed || state.review !== v || !r.ok) return
+      const now = r.value.items.find(same)
+      if (now) {
+        if (now.rev === v.item.rev) return
+        state.items = state.items.map((i) => (same(i) ? now : i))
+        v.item = now
+        v.failure = null
+        v.changed = true
+        announce({ key: 'moderation.textChanged' })
+        return
+      }
+      cursor = r.value.nextCursor
+      if (cursor === null) break
+    }
+    state.review = null
+    gone(v.item)
+  }
+
+  function caseRefused(c: OpenCase, f: CommunityFailure): void {
+    c.failure = f
+    if (f.code === 'invalid' && f.fields?.includes('contractualGround')) {
+      c.needsRule = true
+      void loadRules()
+      return
+    }
+    if (f.code === 'notFound') {
+      state.open = null
+      gone(c.item)
+    }
+  }
+
+  return {
+    state,
+    load,
+    async loadMore() {
+      if (state.loadingMore || state.nextCursor === null || state.phase !== 'ready') return
+      const mine = ticket
+      state.loadingMore = true
+      const r = await client.moderation.queue(queueInput(state.nextCursor), call)
+      state.loadingMore = false
+      if (disposed || mine !== ticket) return
+      if (!r.ok) return announce(failureText(r, lang))
+      state.items = [...state.items, ...r.value.items]
+      state.nextCursor = r.value.nextCursor
+    },
+    async setCategory(categoryId) {
+      const id = categoryId.toLowerCase()
+      if (id === state.categoryId || (id !== '' && !categoryIds().includes(id))) return
+      state.categoryId = id
+      const mine = ++ticket
+      await readQueue(mine)
+    },
+    async openCase(item) {
+      if (item.kind !== 'case' || !item.caseId) return
+      state.review = null
+      state.open = {
+        item,
+        kase: null,
+        loading: true,
+        restriction: '',
+        facts: '',
+        ground: '',
+        needsRule: false,
+        preview: null,
+        previewing: false,
+        deciding: false,
+        failure: null,
+        decided: false,
+        escalation: null,
+      }
+      // The reactive one: what is compared and changed below is what the view reads.
+      const c = state.open
+      void loadRules()
+      const r = await client.moderation.getCase({ caseId: item.caseId }, call)
+      if (disposed || state.open !== c) return
+      c.loading = false
+      if (r.ok) c.kase = r.value.case
+      else caseRefused(c, r)
+    },
+    closeCase() {
+      state.open = null
+    },
+    canPreview,
+    async preview() {
+      const c = state.open
+      if (!c || !canPreview()) return
+      c.previewing = true
+      c.failure = null
+      const r = await client.moderation.decide(decisionInput(true), call)
+      c.previewing = false
+      if (disposed || state.open !== c) return
+      if (r.ok) c.preview = r.value.statement
+      else caseRefused(c, r)
+    },
+    async decide() {
+      const c = state.open
+      // Only what was previewed is decided: the moderator saw the statement the author gets.
+      if (!c || c.preview === null || c.deciding || c.decided) return
+      c.deciding = true
+      c.failure = null
+      const r = await client.moderation.decide(decisionInput(false), call)
+      c.deciding = false
+      if (disposed || state.open !== c) return
+      if (!r.ok) return caseRefused(c, r)
+      c.decided = true
+      c.preview = r.value.statement
+      state.items = state.items.filter((i) => i !== c.item)
+      announce({ key: 'moderation.decided' })
+    },
+    startEscalation() {
+      const c = state.open
+      if (c && !c.escalation) c.escalation = { category: '', sending: false, failure: null, done: false }
+    },
+    async escalate() {
+      const c = state.open
+      const e = c?.escalation
+      if (!c || !e || e.sending || e.done || e.category === '' || !ESCALATION_CATEGORIES.includes(e.category)) return
+      e.sending = true
+      e.failure = null
+      const r = await client.moderation.escalate({ conversationId: c.item.conversationId, seq: c.item.seq, category: e.category }, call)
+      e.sending = false
+      if (disposed || state.open !== c) return
+      if (r.ok) {
+        e.done = true
+        announce({ key: 'moderation.escalated' })
+        return
+      }
+      e.failure = r
+      if (r.code === 'notFound') {
+        state.open = null
+        gone(c.item)
+      }
+    },
+    openReview(item, outcome) {
+      if (item.kind !== 'premod') return
+      state.open = null
+      state.review = { item, outcome, ruleId: '', facts: '', sending: false, failure: null, statement: null, done: null, changed: false }
+      if (outcome === 'reject') void loadRules()
+    },
+    closeReview() {
+      state.review = null
+    },
+    async review() {
+      const v = state.review
+      if (!v || v.sending || v.done || v.outcome === '') return
+      const facts = normalizeBody(v.facts)
+      if (v.outcome === 'reject' && (v.ruleId === '' || facts === '' || codePointLength(facts) > FACTS_MAX)) return
+      v.sending = true
+      v.failure = null
+      v.changed = false
+      // R3: the rev of the text shown — kb-api decides that text only (a newer one is STALE_REVISION, nothing written).
+      const ref = { conversationId: v.item.conversationId, seq: v.item.seq, rev: v.item.rev ?? 1 }
+      const r =
+        v.outcome === 'approve'
+          ? await client.moderation.reviewPremod({ ...ref, outcome: 'approve' }, call)
+          : // The statement of a rejection in the reader's language, as decide's and remove's (kb-api's schema takes it).
+            await client.moderation.reviewPremod({ ...ref, outcome: 'reject', ruleId: v.ruleId, facts, locale: lang }, call)
+      v.sending = false
+      if (disposed || state.review !== v) return
+      if (!r.ok) {
+        v.failure = r
+        if (r.code === 'notFound') {
+          state.review = null
+          gone(v.item)
+          return
+        }
+        await reread(v)
+        return
+      }
+      v.done = v.outcome === 'approve' ? 'approved' : 'rejected'
+      if ('statement' in r.value) v.statement = r.value.statement
+      state.items = state.items.filter((i) => i !== v.item)
+      announce({ key: v.done === 'approved' ? 'moderation.approved' : 'moderation.rejected' })
+    },
+    dispose() {
+      disposed = true
+      abort.abort()
+    },
+  }
+}

package/src/core/onboarding.ts

@@ -7,7 +7,8 @@
  *            minimum kb-api stores nothing and the reader is told from what age the discussion is open;
  *   rules    the rules' summary (`legal/current` → `bodyJson`, text only) with a link to the full text, and
  *            the acceptance;
- *   art9     the art. 9 consent's text and the acceptance, when the tenant asks for it (M2 T9, m2-contracts.md §3.8:
+ *   art9     the art. 9 consent's text and the acceptance, when the tenant asks for it — or, M3, before a forum write,
+ *            whatever the tenant's setting says (`forceArt9`: m3-contracts.md §3.1 step 5, U14) — (M2 T9, m2-contracts.md §3.8:
  *            the layout from me/get's `settings.art9ConsentLayout` — `joint` one consent, `split` one per controller of
  *            the text's `bodyJson.controllers` when it names two, all of them required, the text itself shown once —
  *            and, where `settings.art9Refusal` is `public_write`, a refusal that joins without the consent: kb-api then
@@ -135,6 +136,13 @@ export interface OnboardingOptions {
    * member who refused it, or has not given it, where the tenant asks for it — and no refusal is offered.
    */
   offerArt9?: boolean
+  /**
+   * M3 (m3-contracts.md §3.1 step 5, U14): a forum write needs the art. 9 consent whatever the tenant's
+   * `require_art9_consent` says, so the step is asked whenever the consent is not in force — me/get names no
+   * `art9_consent` need (and may report the consent as null) where the tenant does not ask for it elsewhere. A refusal
+   * is offered as for the discussion (`art9Refusal = public_write`), and a member who refused there is not asked again.
+   */
+  forceArt9?: boolean
   signal?: AbortSignal
 }
 
@@ -157,12 +165,15 @@ export function onboardingFailureText(failure: Pick<CommunityFailure, 'code' | '
 }
 
 /** What is still missing for this member, in order (MyState and its known needs). */
-function stepsOf(me: MyState, needs: readonly string[], offerArt9: boolean): OnboardingStep[] {
+function stepsOf(me: MyState, needs: readonly string[], offerArt9: boolean, forceArt9: boolean): OnboardingStep[] {
   const steps: OnboardingStep[] = []
   if (!me.member?.ageBand) steps.push('age')
   if (me.acceptances.rules !== 'accepted') steps.push('rules')
   const art9 = me.acceptances.art9Consent
-  if (needs.includes('art9_consent') || (offerArt9 && art9 !== null && art9 !== 'accepted')) steps.push('art9')
+  // A forum write: the consent, unless it is in force or refused where a refusal leaves public writes (kb-api's needs).
+  const refusedOpen = me.acceptances.art9Refused === true && art9RefusalOf(me.settings?.art9Refusal) === 'public_write'
+  const forced = forceArt9 && art9 !== 'accepted' && !refusedOpen
+  if (needs.includes('art9_consent') || (offerArt9 && art9 !== null && art9 !== 'accepted') || forced) steps.push('art9')
   if (!me.profile) steps.push('profile')
   return steps
 }
@@ -191,6 +202,7 @@ interface Read {
 export function createOnboarding(o: OnboardingOptions): OnboardingModel {
   const call: CommunityCallOptions = o.signal ? { signal: o.signal } : {}
   const offerArt9 = o.offerArt9 === true
+  const forceArt9 = o.forceArt9 === true && !offerArt9
   const state = reactive<OnboardingState>({
     phase: 'loading',
     steps: [],
@@ -255,7 +267,7 @@ export function createOnboarding(o: OnboardingOptions): OnboardingModel {
       o.onSignIn()
       return null
     }
-    const steps = stepsOf(me.value, needs, offerArt9)
+    const steps = stepsOf(me.value, needs, offerArt9, forceArt9)
     const texts = await textsFor(steps)
     return texts ? { me: me.value, steps, texts } : null
   }

package/src/core/outcomes.ts

@@ -78,6 +78,16 @@ const EFFECTS: Readonly<Record<CommunityUiCode, FailureEffect>> = Object.freeze(
   pushRefused: 'show',
   // Live updates are off here: nothing to show the reader — the discussion keeps polling (the realtime session's fallback).
   realtimeOff: 'hide',
+  // M3 (m3-contracts.md §1.2): the forum is not open to this viewer — read again, and the read's answer is the
+  // members-only state with its sign-in or onboarding (`needs`); no write of a topic answers it (a topic id's refusals
+  // are its `notFound`, A11).
+  membersOnly: 'reload',
+  // The topic was closed meanwhile: read again — the topic's state closes the composer (`error.topicLocked` until then).
+  topicLocked: 'reload',
+  // A category that takes no topic from the member: the sentence, and the category's composer goes.
+  topicCreationClosed: 'show',
+  // Following as much as one member may: the sentence (the member unfollows something first).
+  followLimit: 'show',
   submit: 'show',
 } satisfies Record<CommunityUiCode, FailureEffect>)
 

package/src/core/profile.ts

@@ -18,6 +18,7 @@ import {
   type CommunityFailure,
   type CommunityMessageKey,
   type CommunityRule,
+  type ForumCategoryRef,
   type KnownAuthor,
   type PublicProfile,
 } from '@blogmcp/sdk/community'
@@ -32,6 +33,11 @@ export interface ProfileUi {
   bio: string | null
   /** The trust level's catalogue key (`trust.<n>`), or null for a label this SDK does not know. */
   trustKey: CommunityMessageKey | null
+  /**
+   * M3 (m3-contracts.md §3.5, §4.5; D-M3-7): the categories the member moderates now — „Moderátor" names this
+   * appointment on the profile, never a trust level; kb-api sends it to a forum member only (else none).
+   */
+  moderates: ForumCategoryRef[]
 }
 
 export interface ProfileController {
@@ -53,7 +59,7 @@ export function createProfile(o: { client: CommunityClient }): ProfileController
   const call: CommunityCallOptions = { signal: abort.signal }
   let disposed = false
   let ticket = 0
-  const state = reactive<ProfileUi>({ phase: 'idle', failure: null, author: null, memberSince: null, bio: null, trustKey: null }) as ProfileUi
+  const state = reactive<ProfileUi>({ phase: 'idle', failure: null, author: null, memberSince: null, bio: null, trustKey: null, moderates: [] }) as ProfileUi
 
   return {
     state,
@@ -64,6 +70,7 @@ export function createProfile(o: { client: CommunityClient }): ProfileController
       state.memberSince = null
       state.bio = null
       state.trustKey = null
+      state.moderates = []
       const h = handleOf(handle)
       if (h === null) {
         state.phase = 'notFound'
@@ -87,6 +94,10 @@ export function createProfile(o: { client: CommunityClient }): ProfileController
       state.memberSince = typeof p.memberSince === 'string' ? p.memberSince : null
       state.bio = typeof p.bio === 'string' && p.bio.trim() !== '' ? p.bio : null
       state.trustKey = trustLabelMessageKey(p.trustLabel)
+      // M3: the appointments acting now (a category's slug and name each; anything else is skipped).
+      state.moderates = Array.isArray(p.moderates)
+        ? p.moderates.filter((c): c is ForumCategoryRef => typeof c?.slug === 'string' && typeof c?.name === 'string').map((c) => ({ slug: c.slug, name: c.name }))
+        : []
       state.phase = 'ready'
     },
     dispose() {