@tbox.cn/app-module-member 0.2.0 → 0.8.7

package/src/server/handler.ts

@@ -1,138 +1,178 @@
 /**
- * member handler + 入会写动作（011 K2：enrollment grant 闭环）。
- * - 查积分/信息/卡 → 出对应卡（LLM 路径走同名工具）；
- * - 写：member.enroll CardAction（singleUse grant → dispatcher 授权 → execute → 状态卡）。
- * - 011 评审 M1 修复：execute 经 ctx.identity 取 userId（componentAction 无表单通道时
- *   会话身份入会可用），name/phone 读 input（二期表单数据），inputSchema 补齐护栏。
+ * member handler（011 K2；015：写动作拆至 action.ts，此处只保留意图路径出卡）。
+ * - 查积分/信息/卡 → 出对应卡（LLM 路径走同名工具）。
+ * - 会员偏好长期记忆（017 PRD）：三项声明式 intent → ctx.memory 保存 + continueWith 续接导购。
+ * - 上下文统一化：userId 来源 = 运行身份（reqCtx.identity.userId，handler 第四参）——
+ *   旧 payload.userId 是模型注入面（P4-3），已删除；偏好分支同经 reqCtx 显式读取。
  */
 import type { HandlerDefinition, ServerContext } from '@tbox.cn/app-sdk/server';
-import type { CardActionResult, RequestContext } from '@tbox.cn/app-contracts';
-import type { MemberBenefitsPort, MemberEnrollmentPort } from '@tbox.cn/app-contracts-mall';
-import { z } from 'zod';
+import {
+  MEMBER_PREFERENCE_PROMPTS,
+  MEMBER_PREFERENCE_RECOMMENDATION_QUERIES,
+  MEMBER_PREFERENCE_VALUES,
+  parseMallScope,
+} from '@tbox.cn/app-contracts-mall';
+import type { MemberPreferenceValue } from '@tbox.cn/app-contracts-mall';
+import { MEMBER_QUERY_NOTICES, resolveMemberStatus } from './status';
+import { memberPrivacyRefusal } from './tool';
+import { resolveMemberBenefitsPort, resolveMemberCardPort } from './ports';
+
+function matchMemberPreference(content: string) {
+  return MEMBER_PREFERENCE_PROMPTS.find((prompt) => content === prompt.query);
+}
+
+/** 偏好确认回执文案（第二人称）：按钮值是用户口吻（写记忆保留第一人称），
+ *  助手复述须转换人称；Record 穷尽性保证枚举扩容时编译期强制补齐。 */
+const MEMBER_PREFERENCE_ACK_TEXTS: Record<MemberPreferenceValue, string> = {
+  '我常来买衣服': '你常来买衣服',
+  '我常带娃来玩': '你常带娃来玩',
+  '我常来吃美食': '你常来吃美食',
+};
 
 export function createMemberHandler(ctx: ServerContext): HandlerDefinition {
   return {
     id: 'member',
-    handle: async (action, payload) => {
-      const member = ctx.resolveService<MemberBenefitsPort & MemberEnrollmentPort>('member');
-      if (!member) return { cards: [], text: '会员服务不可用' };
-      const { userId } = (payload ?? {}) as { userId?: string };
+    // match:'exact'：偏好按钮发出的是固定整句值（member-card-summary 按钮组），
+    // 整句全等命中——不入 BM25 词袋（相似查询「2楼有啥美食可逛」曾被词袋误吞，F3）
+    intents: [{ patterns: [...MEMBER_PREFERENCE_VALUES], match: 'exact' }],
+    handle: async (action, payload, _ctx, reqCtx) => {
+      if (action === 'intent') {
+        const content = typeof (payload as { content?: unknown } | undefined)?.content === 'string'
+          ? (payload as { content: string }).content.trim()
+          : '';
+        const prompt = matchMemberPreference(content);
+        // 洋葱定律 1：未识别 = 失败 = 必须放行（不再出 12 字死文案短路整轮）。
+        // exact 路由下正常不可达（全等已保证命中），防御性兜底同样放行 LLM 正常对话。
+        if (!prompt) return { cards: [], continueWith: { content } };
 
-      switch (action) {
-        case 'query-points': {
-          if (!userId) return { cards: [], text: '缺少 userId' };
-          const points = await member.queryPoints(userId);
-          const usage = await member.listPointUsage(userId, 1, 10);
-          return {
-            cards: [
-              {
-                cardType: 'member-point-usage-list',
-                data: {
-                  userId,
-                  balance: points.balance,
-                  level: points.level,
-                  items: usage.items,
-                  total: usage.total,
-                } as unknown as Record<string, unknown>,
-              },
-            ],
-            text: `当前积分 ${points.balance}，等级 ${points.level}`,
-          };
+        // 上下文统一化：运行身份 = handle 第四参 reqCtx（引擎意图分发注入）
+        const identity = reqCtx?.identity;
+        if (!identity || identity.source === 'anonymous') {
+          return { cards: [], text: '登录后才能保存会员偏好' };
         }
-        default: {
-          if (!userId) return { cards: [], text: '缺少 userId' };
-          const points = await member.queryPoints(userId);
-          return {
-            cards: [
-              {
-                cardType: 'member-point-usage-list',
-                data: {
-                  userId,
-                  balance: points.balance,
-                  level: points.level,
-                  items: [],
-                  total: 0,
-                } as unknown as Record<string, unknown>,
-              },
-            ],
-            text: `当前积分 ${points.balance}，等级 ${points.level}`,
-          };
+        if (!ctx.memory || ctx.memory.capabilities?.save === false) {
+          return { cards: [], text: '偏好记忆暂不可用，请稍后再试' };
         }
-      }
-    },
-  };
-}
 
-/** 入会写动作（011 E1/E4）：声明式 CardAction + singleUse grant。
- * 011 评审 M1 修复：userId 优先取 ctx.identity（会话身份），input 仅承载二期表单数据；
- * inputSchema 恒存在（空表单也通过——身份入会为最小闭环）。 */
-export const enrollActionInputSchema = z.object({
-  userId: z.string().optional(),
-  name: z.string().optional(),
-  phone: z.string().optional(),
-});
+        const mallId = parseMallScope(reqCtx?.attributes)?.mallId;
+        await ctx.memory.save({
+          userId: identity.userId,
+          ...(mallId ? { scope: { mallId } } : {}),
+          kind: 'preference',
+          content: `会员偏好：${prompt.value}`,
+        });
 
-export function createEnrollAction(
-  getMember: () => (MemberEnrollmentPort & MemberBenefitsPort) | undefined,
-): { actionId: string; componentId: string; cardType: string; label: string; singleUse: boolean; inputSchema: z.ZodTypeAny; execute(input: unknown, ctx: RequestContext): Promise<CardActionResult> } {
-  return {
-    actionId: 'member.enroll',
-    componentId: 'member',
-    cardType: 'member-enrollment-form',
-    label: '提交入会',
-    singleUse: true,
-    inputSchema: enrollActionInputSchema,
-    async execute(input, ctx): Promise<CardActionResult> {
-      // 011 M1：userId 优先会话身份（dispatcher 传入 ctx；表单无输入通道时身份入会仍闭环）
-      const sessionUserId = ctx?.identity?.userId;
-      const { userId: inputUserId, name, phone } = (input ?? {}) as {
-        userId?: string;
-        name?: string;
-        phone?: string;
-      };
-      const userId = sessionUserId ?? inputUserId;
-      const member = getMember();
-      if (!userId) {
         return {
-          card: {
-            cardType: 'member-enrollment-status',
-            data: { userId: '', success: false, message: '缺少 userId', state: 'not_enrolled' },
-          },
-          text: '入会失败：缺少身份信息',
+          cards: [],
+          text: `记住啦，${MEMBER_PREFERENCE_ACK_TEXTS[prompt.value]}。正在为你查找相关的门店和导购服务，请稍等。\n\n`,
+          continueWith: { content: MEMBER_PREFERENCE_RECOMMENDATION_QUERIES[prompt.value] },
         };
       }
-      if (!member) {
-        return {
-          card: {
-            cardType: 'member-enrollment-status',
-            data: { userId, success: false, message: '会员服务不可用', state: 'not_enrolled' },
-          },
-          text: '入会失败：会员服务不可用',
-        };
-      }
-      const result = await member.enroll({ userId, ...(name ? { name } : {}), ...(phone ? { phone } : {}) });
-      if (!result.success) {
-        return {
-          card: {
-            cardType: 'member-enrollment-status',
-            data: { userId, success: false, message: result.error, state: 'not_enrolled' },
-          },
-          text: `入会失败：${result.error ?? '未知错误'}`,
-        };
+
+      if (!reqCtx) return { cards: [], text: '会员服务不可用（运行上下文缺失）' };
+      const query = typeof (payload as { query?: unknown } | undefined)?.query === 'string'
+        ? (payload as { query: string }).query
+        : '';
+      const privacyRefusal = memberPrivacyRefusal(query);
+      if (privacyRefusal) return { cards: [], text: privacyRefusal };
+      const status = await resolveMemberStatus(reqCtx, ctx);
+      if (status.outcome === 'active') {
+        const userId = reqCtx.identity.userId;
+        switch (action) {
+          case 'query-points': {
+            // 017 槽位原子化：active 态按槽解析（card 面 + benefits 面；多次构造廉价）。
+            // 槽解析失败 → unavailable 收口（旧防御分支语义延续：不裸抛、不答「积分 0」）
+            let cardPort: Awaited<ReturnType<typeof resolveMemberCardPort>>;
+            let benefitsPort: Awaited<ReturnType<typeof resolveMemberBenefitsPort>>;
+            try {
+              [cardPort, benefitsPort] = await Promise.all([
+                resolveMemberCardPort(reqCtx, ctx),
+                resolveMemberBenefitsPort(reqCtx, ctx),
+              ]);
+            } catch (error) {
+              ctx.logger?.warn(`member handler：active 槽解析失败：err=${(error as Error).message}`);
+              return { cards: [], text: MEMBER_QUERY_NOTICES.unavailable };
+            }
+            const card = await cardPort.getCard(userId);
+            let points = { userId, balance: 0 } as Awaited<ReturnType<typeof benefitsPort.queryPoints>>;
+            let pointsUnavailable = false;
+            try {
+              points = await benefitsPort.queryPoints(userId);
+            } catch {
+              pointsUnavailable = true;
+            }
+            if (card?.presentation !== undefined) {
+              let usage: Awaited<ReturnType<typeof benefitsPort.listPointUsage>> | undefined;
+              let usageUnavailable = false;
+              if (card.pointsUrl) {
+                try {
+                  usage = await benefitsPort.listPointUsage(userId, 1, 10);
+                } catch {
+                  usageUnavailable = true;
+                }
+              }
+              const cardData = {
+                userId,
+                cardRef: card.cardRef,
+                cardDisplay: card.cardDisplay,
+                status: card.status,
+                ...(card.levelName ? { levelName: card.levelName } : {}),
+                availablePoints: points.balance,
+                ...(card.cardImageUrl ? { cardImageUrl: card.cardImageUrl } : {}),
+                ...(card.pointsRuleImageUrl ? { pointsRuleImageUrl: card.pointsRuleImageUrl } : {}),
+                ...(card.pointsRuleContent ? { pointsRuleContent: card.pointsRuleContent } : {}),
+                ...(card.pointsUrl ? { pointsUrl: card.pointsUrl } : {}),
+                ...(card.presentation ? { presentation: card.presentation } : {}),
+                ...(card.progress ? { progress: card.progress } : {}),
+                ...(card.benefits ? { benefits: [...card.benefits] } : {}),
+              } as Record<string, unknown>;
+              return {
+                cards: [{ cardType: 'member-card-summary', data: cardData }],
+                text: pointsUnavailable
+                  ? '会员卡可正常查看，但当前积分余额暂不可用，暂无最近积分流水记录'
+                  : usageUnavailable
+                  ? `当前积分 ${points.balance}，暂无最近积分流水记录`
+                  : usage && usage.items.length > 0
+                  ? `当前积分 ${points.balance}，最近流水：${usage.items.map((item) => `${item.title}${item.amount}分${item.usedAt ? `（${item.usedAt}）` : ''}`).join('；')}`
+                  : `当前积分 ${points.balance}，暂未查询到最近积分流水`,
+              };
+            }
+            const usage = await benefitsPort.listPointUsage(userId, 1, 10);
+            const usageText = usage.items.length > 0
+              ? `，最近流水：${usage.items.map((item) => `${item.title}${item.amount}分${item.usedAt ? `（${item.usedAt}）` : ''}`).join('；')}`
+              : '，暂未查询到最近积分流水';
+            if (!card) {
+              return {
+                cards: [],
+                text: `当前积分 ${points.balance}${points.membershipLabel ? `，会员卡 ${points.membershipLabel}` : ''}${usageText}`,
+              };
+            }
+            return {
+              cards: [{ cardType: 'member-card-summary', data: {
+                userId,
+                cardRef: card.cardRef,
+                cardDisplay: card.cardDisplay,
+                status: card.status,
+                ...(card.levelName ? { levelName: card.levelName } : {}),
+                availablePoints: points.balance,
+                ...(card.cardImageUrl ? { cardImageUrl: card.cardImageUrl } : {}),
+                ...(card.pointsRuleImageUrl ? { pointsRuleImageUrl: card.pointsRuleImageUrl } : {}),
+                ...(card.pointsRuleContent ? { pointsRuleContent: card.pointsRuleContent } : {}),
+                ...(card.pointsUrl ? { pointsUrl: card.pointsUrl } : {}),
+                ...(card.presentation ? { presentation: card.presentation } : {}),
+                ...(card.progress ? { progress: card.progress } : {}),
+                ...(card.benefits ? { benefits: [...card.benefits] } : {}),
+              } as Record<string, unknown> }],
+              text: `当前积分 ${points.balance}${points.membershipLabel ? `，会员卡 ${points.membershipLabel}` : ''}${usageText}`,
+            };
+          }
+          default: {
+            return { cards: [], text: '不支持的会员操作' };
+          }
+        }
       }
-      const points = await member.queryPoints(userId);
-      return {
-        card: {
-          cardType: 'member-enrollment-status',
-          data: {
-            userId,
-            success: true,
-            ...(result.memberRef ? { memberRef: result.memberRef } : {}),
-            state: 'active',
-          },
-        },
-        text: `入会成功！当前积分 ${points.balance}，等级 ${points.level}`,
-      };
+      // 非 active：门禁文案与工具路径同源（意图路径不再对未入会/未登录答「积分 0」）
+      return { cards: [], text: MEMBER_QUERY_NOTICES[status.outcome] };
     },
   };
 }

package/src/server/index.ts

@@ -1,98 +1,177 @@
-import type { ServerContext, ServerModule, TypedBus, PreToolDef } from '@tbox.cn/app-sdk/server';
-import { definePreTool } from '@tbox.cn/app-sdk/server';
-import type { MallEventMap } from '@tbox.cn/app-contracts-mall';
-import { InMemoryMemberService } from './service';
+import type { ServerContext, ServerModule } from '@tbox.cn/app-sdk/server';
+import { loadModuleSkills, withCardEmissionHint, withEarlyExecution } from '@tbox.cn/app-sdk/server';
+import type { RequestContext } from '@tbox.cn/app-contracts';
+import { MEMBER_SNAPSHOT_SERVICE, type MemberSnapshotPort } from '@tbox.cn/app-contracts-mall';
 import memberInfoMeta from './cards/member-info/meta';
 import memberCardSummaryMeta from './cards/member-card-summary/meta';
-import memberCouponListMeta from './cards/member-coupon-list/meta';
-import memberCouponDetailMeta from './cards/member-coupon-detail/meta';
 import memberPointUsageListMeta from './cards/member-point-usage-list/meta';
 import memberEnrollmentFormMeta from './cards/member-enrollment-form/meta';
 import memberEnrollmentStatusMeta from './cards/member-enrollment-status/meta';
+import memberEnrollmentCtaMeta from './cards/member-enrollment-cta/meta';
+import memberLoginCtaMeta from './cards/member-login-cta/meta';
 import {
   createQueryPointsTool,
   createQueryMemberInfoTool,
   createQueryMemberCardTool,
-  createQueryMemberCouponsTool,
   createQueryEnrollmentFormTool,
+  createQueryEnrollmentCtaTool,
+  createQueryLoginCtaTool,
 } from './tool';
-import { createMemberHandler, createEnrollAction } from './handler';
+import { createMemberHandler } from './handler';
+import { createMemberActions } from './action';
+import { createSubjectBinding } from './subject-binding';
+import {
+  resolveMemberAccountPort,
+  resolveMemberBenefitsPort,
+  resolveMemberCardPort,
+  resolveMemberEnrollmentPort,
+  resolveMemberProfilePort,
+} from './ports';
+import { resolveMemberStatus } from './status';
 
 export { InMemoryMemberService } from './service';
 export type { MemberService } from './service';
+export {
+  resolveMemberAccountPort,
+  resolveMemberProfilePort,
+  resolveMemberCardPort,
+  resolveMemberBenefitsPort,
+  resolveMemberEnrollmentPort,
+} from './ports';
+export type { MemberAccountService, MemberEnrollmentService } from './ports';
 export { memberCards } from './cards';
 
-/**
- * 模块级单例（B14）：实例在模块包加载时创建，serverModule.register 幂等（重复调用共享状态）。
- */
-const member = new InMemoryMemberService({ u_1001: 860, u_1002: 120 });
+let serverCtx: ServerContext | undefined;
+const getCtx = (): ServerContext => {
+  if (!serverCtx) throw new Error('member 模块未注册（ServerContext 未绑定）');
+  return serverCtx;
+};
+/** 请求级 member 槽服务集（017 槽位原子化：五槽 resolver 注入工具/动作；
+ *  上下文统一化：显式传 reqCtx，替代 ctx.auth 全局单例） */
+const memberPorts = {
+  getAccount: (reqCtx: RequestContext) => resolveMemberAccountPort(reqCtx, getCtx()),
+  getProfile: (reqCtx: RequestContext) => resolveMemberProfilePort(reqCtx, getCtx()),
+  getCard: (reqCtx: RequestContext) => resolveMemberCardPort(reqCtx, getCtx()),
+  getBenefits: (reqCtx: RequestContext) => resolveMemberBenefitsPort(reqCtx, getCtx()),
+  getEnrollment: (reqCtx: RequestContext) => resolveMemberEnrollmentPort(reqCtx, getCtx()),
+};
 
-/** 工具实例顶层创建（010：pre-tool 声明引用工具实例 = 单一真源） */
-const queryPointsTool = createQueryPointsTool(() => member);
-const queryMemberInfoTool = createQueryMemberInfoTool(() => member);
-const queryMemberCardTool = createQueryMemberCardTool(() => member);
-const queryMemberCouponsTool = createQueryMemberCouponsTool(() => member);
-const queryEnrollmentFormTool = createQueryEnrollmentFormTool(() => member);
+/** 工具实例顶层创建；每次 execute 解析当前请求的真实 C 端 Provider。
+ *  W2（2026-09-01）：出卡工具创建点单点 wrap（description 追加预告知句）——
+ *  注册即 wrapped 实例；CTA/表单卡承载操作入口带 actions 句。
+ *  PR-2：三个纯查询工具（只读/幂等/execCtx 仅消费 requestContext）标注尽早执行
+ *  白名单——env TBOX_EARLY_TOOL_EXECUTION=1 时参数流完即预执行；缺省 off 零行为。 */
+const queryPointsTool = withEarlyExecution(
+  withCardEmissionHint(createQueryPointsTool(memberPorts)),
+);
+const queryMemberInfoTool = withEarlyExecution(
+  withCardEmissionHint(createQueryMemberInfoTool(memberPorts)),
+);
+const queryMemberCardTool = withEarlyExecution(
+  withCardEmissionHint(createQueryMemberCardTool(memberPorts)),
+);
+const queryEnrollmentFormTool = withCardEmissionHint(createQueryEnrollmentFormTool(memberPorts), {
+  actions: true,
+});
+const queryEnrollmentCtaTool = withCardEmissionHint(createQueryEnrollmentCtaTool(memberPorts), {
+  actions: true,
+});
+const queryLoginCtaTool = withCardEmissionHint(createQueryLoginCtaTool(memberPorts), {
+  actions: true,
+});
 
 /** 卡片 meta 声明 map（key 约定 = meta.cardType；数据 + 类型源） */
 const cards = {
   'member-info': memberInfoMeta,
   'member-card-summary': memberCardSummaryMeta,
-  'member-coupon-list': memberCouponListMeta,
-  'member-coupon-detail': memberCouponDetailMeta,
   'member-point-usage-list': memberPointUsageListMeta,
   'member-enrollment-form': memberEnrollmentFormMeta,
   'member-enrollment-status': memberEnrollmentStatusMeta,
+  'member-enrollment-cta': memberEnrollmentCtaMeta,
+  'member-login-cta': memberLoginCtaMeta,
 } as const;
 
-/** 入会写动作（011 E4：singleUse grant 闭环） */
-const enrollAction = createEnrollAction(() => member);
-
 /**
- * 前置工具声明（010）：queryPoints 的 userId 可工程化获取（会话身份），
- * 无需模型抽参——always 必选候选 + 身份可用即预执行。
+ * 会员前置工具暂时停用（保留原实现，便于恢复）：
+ * queryPoints 会串联真实 MallCard/Get、BonusHistory 和卡片投影，当前前置预算下容易超时，
+ * 导致会员 Skill 一直处于执行中。现阶段统一走下方业务工具 queryPoints/queryMemberInfo/queryMemberCard，
+ * 等真实接口超时与前置预算重新评估后再恢复。
+ *
+ * const preTools = {
+ *   queryPoints: definePreTool(queryPointsTool, {
+ *     routing: { mode: 'always' },
+ *     decide: ({ identity, text }) =>
+ *       identity && identity.source !== 'anonymous'
+ *         ? { decision: 'run', args: { userId: identity.userId, query: text } }
+ *         : { decision: 'skip', reason: '匿名身份不预执行' },
+ *   }),
+ * } satisfies Record<string, PreToolDef>;
  */
-const preTools = {
-  queryPoints: definePreTool(queryPointsTool, {
-    routing: { mode: 'always' },
-    decide: ({ identity }) =>
-      identity && identity.source !== 'anonymous'
-        ? { decision: 'run', args: { userId: identity.userId } }
-        : { decision: 'skip', reason: '匿名身份不预执行' },
-  }),
-} satisfies Record<string, PreToolDef>;
+const preTools = {} as const;
+
+/** 文件加载式 skill（009 两形态之二；promotion 先例）：顶层 await → 填回声明式通道（装配端 registerAll 自动注册）。
+ * codegen 展开改写约定：第一参随包名改写（@tbox.cn/app-module-member → @app/module-member）。 */
+const skills = Object.fromEntries(
+  (await loadModuleSkills('@tbox.cn/app-module-member', import.meta.url)).map((s) => [s.name, s]),
+);
 
 /** 模块注册入口：自注册闭环（与客户端 clientModule 对称） */
 export const serverModule = {
   declaration: {
-    componentId: 'member',
-    features: ['member-profile', 'member-card', 'member-benefits', 'member-points', 'member-coupons', 'member-enrollment'],
+    moduleId: 'member',
   },
   cards,
   preTools,
+  skills,
   register(ctx: ServerContext): void {
-    ctx.services.register('member', member);
+    serverCtx = ctx;
+    // 上下文统一化：'member.service' 解析工厂（跨模块消费方 resolveService 后
+    // await factory(reqCtx)——替代旧 'member' 全局门面，并发安全）。
+    // 017 槽位原子化：积分结算写面语义锚 = benefits 槽（跨模块消费方为积分域）
+    ctx.services.register('member.service', (reqCtx: RequestContext) =>
+      resolveMemberBenefitsPort(reqCtx, ctx),
+    );
+    // 会员状态解析工厂（member.status）：跨模块门禁消费（如领券 acquire）；
+    // soft 单档——缺席/失败收口 unavailable，不伪装状态
+    ctx.services.register('member.status', (reqCtx: RequestContext) =>
+      resolveMemberStatus(reqCtx, ctx),
+    );
     ctx.tools.register(queryPointsTool);
     ctx.tools.register(queryMemberInfoTool);
     ctx.tools.register(queryMemberCardTool);
-    ctx.tools.register(queryMemberCouponsTool);
     ctx.tools.register(queryEnrollmentFormTool);
+    ctx.tools.register(queryEnrollmentCtaTool);
+    ctx.tools.register(queryLoginCtaTool);
     ctx.cards.registerMap(cards);
     ctx.handlers.register(createMemberHandler(ctx));
-    // 011 E7：入会写动作声明（装配端 dispatcher 收集 + 出卡时签发 token）
-    ctx.cardActions.register(enrollAction);
 
-    // 类型化事件总线：以 MallEventMap 收窄（keyof 约束载荷类型，编译期对齐）
-    const mallBus = ctx.bus as unknown as TypedBus<MallEventMap>;
+    // 015 S4：入会四动作（register 闭包 ctx——动作 execute 内经 enrollment 槽解析 + ctx.state PII 暂存）
+    const actions = createMemberActions(ctx, (reqCtx) => resolveMemberEnrollmentPort(reqCtx, ctx));
+    for (const action of Object.values(actions)) {
+      ctx.cardActions.register(action);
+    }
+
+    // 015 D9：主体绑定（promotion acquire 消费；ctx.services 跨模块 resolveService）
+    ctx.services.register('member.subject-binding', createSubjectBinding(ctx));
 
-    // 跨模块异步通知：parking 核销停车券 → member 奖积分（member 不依赖 parking）
-    mallBus.subscribe('parking.coupon.used', async ({ userId, amount }) => {
-      await member.awardPoints(userId, Math.floor(amount / 10));
-    });
+    // 会员快览工厂（member.snapshot，W3-3）：首页联单面板跨模块消费面
+    // （账户/授权三态 + 积分 + 入会引导）。三槽组装——enrollment 槽 fail-soft
+    // （缺席不拖垮账户/积分主面）；工厂运行期执行（注册期纯净铁律）。
+    ctx.services.register(
+      MEMBER_SNAPSHOT_SERVICE,
+      async (reqCtx: RequestContext): Promise<MemberSnapshotPort> => {
+        const [account, benefits, enrollment] = await Promise.all([
+          resolveMemberAccountPort(reqCtx, ctx),
+          resolveMemberBenefitsPort(reqCtx, ctx),
+          resolveMemberEnrollmentPort(reqCtx, ctx).catch(() => null),
+        ]);
+        return {
+          getAccount: (userId: string) => account.getAccount(userId),
+          queryPoints: (userId: string) => benefits.queryPoints(userId),
+          ...(enrollment?.enrollUrl ? { enrollUrl: enrollment.enrollUrl } : {}),
+        };
+      },
+    );
 
-    // 等级变更对外发布（member 发事件，其他模块订阅）
-    member.onLevelChange(({ userId, newLevel }) => {
-      void mallBus.publish('member.level.changed', { userId, newLevel });
-    });
   },
 } satisfies ServerModule;

package/src/server/ports.ts

@@ -0,0 +1,66 @@
+/**
+ * member Port 分槽解析（017 槽位原子化）：五槽独立解析（account/profile/card/
+ * benefits/enrollment），无运行时 InMemory 兜底（InMemoryMemberService 仅限隔离单测）。
+ * 解析失败一律上抛：未配置/禁用等预期缺席错误码由 registry 抛出，调用方按业务文案转译
+ * （status fail-soft / 工具层文案兜底）。
+ *
+ * 非 Port 成员归位：loginUrl 挂 account 槽产物、enrollUrl 挂 enrollment 槽产物
+ * （厂商 fat 实现运行期携带；契约 Port 不含——返回类型上的可选属性扩展即类型视图）。
+ */
+import {
+  MEMBER_ACCOUNT_SERVICE,
+  MEMBER_BENEFITS_SERVICE,
+  MEMBER_CARD_SERVICE,
+  MEMBER_ENROLLMENT_SERVICE,
+  MEMBER_PROFILE_SERVICE,
+  type MemberAccountPort,
+  type MemberBenefitsPort,
+  type MemberCardPort,
+  type MemberEnrollmentPort,
+  type MemberProfilePort,
+} from '@tbox.cn/app-contracts-mall';
+import { mallScopeOf } from '@tbox.cn/app-contracts-mall';
+import type { RequestContext } from '@tbox.cn/app-contracts';
+import type { ServerContext } from '@tbox.cn/app-sdk/server';
+
+/** account 槽产物类型视图：Port + 厂商实例携带的登录深链（可选） */
+export type MemberAccountService = MemberAccountPort & { readonly loginUrl?: string };
+/** enrollment 槽产物类型视图：Port + 厂商实例携带的入会深链（可选） */
+export type MemberEnrollmentService = MemberEnrollmentPort & { readonly enrollUrl?: string };
+
+async function resolveMemberSlot<T>(
+  service: string,
+  reqCtx: RequestContext,
+  ctx: ServerContext,
+): Promise<T> {
+  const scope = mallScopeOf(reqCtx);
+  if (!scope.mallId) throw new Error('会员 C 端请求缺少 mallId');
+  if (!ctx.integrations) throw new Error('integrations registry 缺失：member 服务不可用');
+  return (await ctx.integrations.resolveService({
+    service,
+    scope,
+    request: reqCtx,
+  })) as T;
+}
+
+export async function resolveMemberAccountPort(reqCtx: RequestContext, ctx: ServerContext): Promise<MemberAccountService> {
+  return resolveMemberSlot<MemberAccountService>(MEMBER_ACCOUNT_SERVICE, reqCtx, ctx);
+}
+
+export async function resolveMemberProfilePort(reqCtx: RequestContext, ctx: ServerContext): Promise<MemberProfilePort> {
+  return resolveMemberSlot<MemberProfilePort>(MEMBER_PROFILE_SERVICE, reqCtx, ctx);
+}
+
+export async function resolveMemberCardPort(reqCtx: RequestContext, ctx: ServerContext): Promise<MemberCardPort> {
+  return resolveMemberSlot<MemberCardPort>(MEMBER_CARD_SERVICE, reqCtx, ctx);
+}
+
+export async function resolveMemberBenefitsPort(reqCtx: RequestContext, ctx: ServerContext): Promise<MemberBenefitsPort> {
+  return resolveMemberSlot<MemberBenefitsPort>(MEMBER_BENEFITS_SERVICE, reqCtx, ctx);
+}
+
+export async function resolveMemberEnrollmentPort(reqCtx: RequestContext, ctx: ServerContext): Promise<MemberEnrollmentService> {
+  return resolveMemberSlot<MemberEnrollmentService>(MEMBER_ENROLLMENT_SERVICE, reqCtx, ctx);
+}
+
+export { InMemoryMemberService } from './service';