Refuse a post that mentions a deactivated account

Zulip still resolves a deactivated account's name in @**Name** markup,
but renders the mention silent, so it notifies nobody. The write-path
check resolved names against every member of /users, deactivated ones
included, so a post naming a released ephemeral seat went out silently
instead of failing with UnresolvedMention.

The check now counts only active members, in both the @**Name** and
@**Name|id** forms. The read path is unchanged: it already reads the
rendered span, which Zulip marks silent.

Author: GraemeF

packages/zulip/adapter.test.ts

@@ -31,7 +31,7 @@ import {
   type UnknownIdentity,
   UnresolvedMention,
 } from '@commy/core/ports'
-import { effectTest } from '@commy/testing/effect-test'
+import { effectTest, runTestEffect } from '@commy/testing/effect-test'
 import {
   makeStubHttpClient,
   type StubBody,
@@ -1237,6 +1237,45 @@ effectTest('publisher.post fails with a tagged UnresolvedMention on a dead menti
   }),
 )
 
+// Zulip still resolves a deactivated account's name, but renders the mention
+// silent, so it notifies nobody. The directory lists deactivated members too,
+// which must not count as resolving the mention — in either markup form.
+test.each([
+  ['@**cc-homelab-e99f08af**', 'cc-homelab-e99f08af'],
+  ['@**cc-homelab-e99f08af|4977**', 'cc-homelab-e99f08af|4977'],
+])(
+  'publisher.post fails with UnresolvedMention when %s names a deactivated seat',
+  (markup, token) =>
+    runTestEffect(() =>
+      Effect.gen(function* () {
+        const stub = yield* makeStubHttpClient
+        yield* seedSendMessage(stub, 203)
+        const adapter = yield* buildAdapter(stub)
+        yield* seedUsers(stub, [
+          HERMES,
+          {
+            user_id: 4977,
+            email: 'cc-homelab-e99f08af-bot@example.com',
+            full_name: 'cc-homelab-e99f08af',
+            is_bot: true,
+            is_active: false,
+            role: 400,
+          },
+        ])
+        const error = yield* Effect.flip(
+          adapter.publisher.post(
+            generalChannel.name,
+            decodeMessageBodySync(`${markup} your answer`),
+          ),
+        )
+        expect(error).toBeInstanceOf(UnresolvedMention)
+        if (error instanceof UnresolvedMention) {
+          expect(error.tokens).toEqual([token])
+        }
+      }),
+    ),
+)
+
 // A dead form written as an example inside a code span is literal text Zulip
 // never delivers as a mention — validating it would block agents from
 // discussing mention discipline. It must post verbatim, not fail.

packages/zulip/adapter.ts

@@ -693,6 +693,7 @@ export const zulipAdapter = (
       readonly byId: ReadonlyMap<ZulipUserRef, Identity>
       readonly byName: ReadonlyMap<string, Identity>
       readonly byIdentityId: ReadonlyMap<IdentityId, ZulipUserRef>
+      readonly active: ReadonlySet<IdentityId>
     }
 
     const buildDirectoryLookup = (): Effect.Effect<
@@ -705,13 +706,15 @@ export const zulipAdapter = (
             const byId = new Map<ZulipUserRef, Identity>()
             const byName = new Map<string, Identity>()
             const byIdentityId = new Map<IdentityId, ZulipUserRef>()
+            const active = new Set<IdentityId>()
             for (const u of members) {
               const ident = yield* toIdentity(u)
               byId.set(ZulipUserRef(u.user_id), ident)
               byName.set(u.full_name, ident)
               byIdentityId.set(ident.id, ZulipUserRef(u.user_id))
+              if (u.is_active) active.add(ident.id)
             }
-            return { byId, byName, byIdentityId }
+            return { byId, byName, byIdentityId, active }
           }),
         ),
       )
@@ -738,6 +741,20 @@ export const zulipAdapter = (
       byUserId: (userId) => directory.byId.get(ZulipUserRef(userId)),
     })
 
+    // Zulip resolves a deactivated member's name but renders the mention
+    // silent, so only active members can be notified by one.
+    const notifiableMentionDirectory = (directory: DirectoryLookup): MentionDirectory => {
+      const isActive = (identity: Identity | undefined): identity is Identity =>
+        identity !== undefined && directory.active.has(identity.id)
+      return {
+        byName: new Map([...directory.byName].filter(([, identity]) => isActive(identity))),
+        byUserId: (userId) => {
+          const identity = directory.byId.get(ZulipUserRef(userId))
+          return isActive(identity) ? identity : undefined
+        },
+      }
+    }
+
     // Write-path mention pre-flight: a `@**Name**` token in an outbound body
     // that resolves to no known identity would be posted verbatim and notify
     // nobody — Zulip accepts it silently. Reject the write instead. The token
@@ -754,7 +771,7 @@ export const zulipAdapter = (
         ? Effect.void
         : buildDirectoryLookup().pipe(
             Effect.flatMap((directory) => {
-              const dead = unresolvedMentions(body, mentionDirectory(directory))
+              const dead = unresolvedMentions(body, notifiableMentionDirectory(directory))
               return dead.length === 0
                 ? Effect.void
                 : Effect.fail(