@tbox.cn/app-module-member 0.1.0 → 0.8.6

package/src/server/index.ts

@@ -1,45 +1,157 @@
-import type { ServerContext, ServerModule, TypedBus } from '@tbox.cn/app-sdk/server';
-import type { MallEventMap } from '@tbox.cn/app-contracts-mall';
-import { InMemoryMemberService } from './service';
-import pointsMeta from './cards/points/meta';
-import { createQueryPointsTool } from './tool';
+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 memberInfoMeta from './cards/member-info/meta';
+import memberCardSummaryMeta from './cards/member-card-summary/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,
+  createQueryEnrollmentFormTool,
+  createQueryEnrollmentCtaTool,
+  createQueryLoginCtaTool,
+} from './tool';
 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 { default as pointsMeta } from './cards/points/meta';
+export {
+  resolveMemberAccountPort,
+  resolveMemberProfilePort,
+  resolveMemberCardPort,
+  resolveMemberBenefitsPort,
+  resolveMemberEnrollmentPort,
+} from './ports';
+export type { MemberAccountService, MemberEnrollmentService } from './ports';
+export { memberCards } from './cards';
 
-/**
- * 模块级单例（B14）：实例在模块包加载时创建，serverModule.register 幂等（重复调用共享状态）。
- * 服务实例生命周期 = 模块包加载期，而非 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()),
+};
+
+/** 工具实例顶层创建；每次 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 = {
-  points: pointsMeta,
+  'member-info': memberInfoMeta,
+  'member-card-summary': memberCardSummaryMeta,
+  'member-point-usage-list': memberPointUsageListMeta,
+  'member-enrollment-form': memberEnrollmentFormMeta,
+  'member-enrollment-status': memberEnrollmentStatusMeta,
+  'member-enrollment-cta': memberEnrollmentCtaMeta,
+  'member-login-cta': memberLoginCtaMeta,
 } as const;
 
+/**
+ * 会员前置工具暂时停用（保留原实现，便于恢复）：
+ * 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 = {} 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: {
+    moduleId: 'member',
+  },
   cards,
+  preTools,
+  skills,
   register(ctx: ServerContext): void {
-    ctx.services.register('member', member);
-    ctx.tools.register(createQueryPointsTool(() => ctx.resolveService('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(queryEnrollmentFormTool);
+    ctx.tools.register(queryEnrollmentCtaTool);
+    ctx.tools.register(queryLoginCtaTool);
     ctx.cards.registerMap(cards);
     ctx.handlers.register(createMemberHandler(ctx));
 
-    // 类型化事件总线：以 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);
+    }
 
-    // 跨模块异步通知：parking 核销停车券 → member 奖积分（member 不依赖 parking）
-    mallBus.subscribe('parking.coupon.used', async ({ userId, amount }) => {
-      await member.awardPoints(userId, Math.floor(amount / 10));
-    });
+    // 015 D9：主体绑定（promotion acquire 消费；ctx.services 跨模块 resolveService）
+    ctx.services.register('member.subject-binding', createSubjectBinding(ctx));
 
-    // 等级变更对外发布（member 发事件，其他模块订阅）；publish 为 async（B1，fire-and-forget）
-    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';

package/src/server/service.ts

@@ -1,20 +1,66 @@
-import type { MemberQueryPort, MemberSettlementPort, Points } from '@tbox.cn/app-contracts-mall';
-import type { DiscountRule } from '@tbox.cn/app-contracts-mall';
+import type {
+  MemberAccountPort,
+  MemberAccountSnapshot,
+  MemberBenefitsPort,
+  MemberBenefitsSnapshot,
+  MemberCardPort,
+  MemberCardSnapshot,
+  MemberEnrollmentInput,
+  MemberEnrollmentPort,
+  MemberEnrollmentResult,
+  MemberEnrollmentStatus,
+  MemberProfilePort,
+  MemberProfileSnapshot,
+  Points,
+  PointUsageRecord,
+} from '@tbox.cn/app-contracts-mall';
+import type {
+  DiscountRule,
+  MemberEnrollmentFormDefinition,
+} from '@tbox.cn/app-contracts-mall';
 
 /**
- * MemberService：商圈会员完整实现。
+ * MemberService：商圈会员完整实现（011 K2 六 Port + 015 入会升级）。
  * extends 契约 Port（保证满足消费方子集约束）；完整接口只在本模块包内。
  */
-export interface MemberService extends MemberQueryPort, MemberSettlementPort {
-  /** 积分变动记录（单测/观测用） */
-  audit: { action: string; userId: string; amount: number; key?: string }[];
+/**
+ * InMemory 演示实现（仅供隔离单测；运行时注册与 Provider 解析不得使用）。
+ * 017 槽位原子化后非 Port 成员归位：getEnrollmentFormDefinition 已收编
+ * MemberEnrollmentPort optional 方法（R13）；enrollUrl/loginUrl 为槽产物自由属性
+ * （enrollment/account 槽的类型视图见 ports.ts）；audit 转 InMemory 私有观测成员。
+ */
+export interface MemberService
+  extends MemberAccountPort,
+    MemberProfilePort,
+    MemberCardPort,
+    MemberBenefitsPort,
+    MemberEnrollmentPort {
+  /** 入会落地页深链（alipays:// 或 H5 链接），从 deployment provider config 注入；空串表示未配置。 */
+  readonly enrollUrl: string;
+  /**
+   * 登录页深链，同样从 deployment provider config 注入。
+   * 可选而非必填——真实 provider 接入前不该被迫实现；缺省时登录引导退回文本。
+   */
+  readonly loginUrl?: string;
 }
 
-/** 内存实现（PoC） */
+// Form 族归源 TIER1（F5 下沉：provider 出参与模块投影共用同一契约面）
+export type {
+  MemberEnrollmentConsentDefinition,
+  MemberEnrollmentFormFieldDefinition,
+  MemberEnrollmentFormDefinition,
+} from '@tbox.cn/app-contracts-mall';
+
+/** 仅供隔离单测使用的 fixture；运行时注册与 Provider 解析不得使用。 */
 export class InMemoryMemberService implements MemberService {
+  readonly enrollUrl: string = '';
   private balances = new Map<string, number>();
-  private levels = new Map<string, 'silver' | 'gold' | 'platinum'>();
   private idempotentKeys = new Set<string>();
+  private usages: PointUsageRecord[] = [];
+  private profiles = new Map<string, MemberProfileSnapshot>();
+  private enrollmentAttempts = new Map<string, { result: MemberEnrollmentResult; userId: string }>();
+  private pendingConfirmations = new Set<string>();
+  private statusQueries = new Map<string, number>();
   audit: { action: string; userId: string; amount: number; key?: string }[] = [];
 
   constructor(initial: Record<string, number> = {}) {
@@ -23,22 +69,82 @@ export class InMemoryMemberService implements MemberService {
     }
   }
 
+  // ===== 1. MemberAccountPort =====
+
+  async getAccount(userId: string): Promise<MemberAccountSnapshot> {
+    return {
+      authState: 'authenticated',
+      state: this.balances.has(userId) ? 'active' : 'not_enrolled',
+      ...(this.balances.has(userId) ? { memberRef: `member:${userId}` } : {}),
+      observedAt: new Date().toISOString(),
+    };
+  }
+
+  // ===== 2. MemberProfilePort =====
+
+  async getProfile(userId: string): Promise<MemberProfileSnapshot> {
+    return (
+      this.profiles.get(userId) ?? {
+        labels: [],
+        observedAt: new Date().toISOString(),
+      }
+    );
+  }
+
+  // ===== 3. MemberCardPort =====
+
+  async getCard(userId: string): Promise<MemberCardSnapshot | null> {
+    if (!this.balances.has(userId)) return null;
+    return {
+      cardRef: `card:${userId}`,
+      cardDisplay: '示例会员卡',
+      status: 'active',
+      observedAt: new Date().toISOString(),
+    };
+  }
+
+  // ===== 4. MemberBenefitsPort =====
+
   async queryPoints(userId: string): Promise<Points> {
     return {
       userId,
       balance: this.balances.get(userId) ?? 0,
-      level: this.levelOf(userId),
+      membershipLabel: '测试会员卡',
     };
   }
 
-  async queryDiscount(userId: string): Promise<DiscountRule | undefined> {
-    const level = this.levelOf(userId);
-    const map: Record<string, DiscountRule> = {
-      silver: { level: 'silver', discount: 0.95 },
-      gold: { level: 'gold', discount: 0.9 },
-      platinum: { level: 'platinum', discount: 0.85 },
+  async getBenefits(userId: string): Promise<MemberBenefitsSnapshot> {
+    return {
+      availablePoints: this.balances.get(userId) ?? 0,
+      observedAt: new Date().toISOString(),
+    };
+  }
+
+  async getEnrollmentFormDefinition(): Promise<MemberEnrollmentFormDefinition> {
+    return {
+      formVersion: 'fixture-v1',
+      fields: [
+        { fieldId: 'mobile', label: '手机号', type: 'tel', required: true, placeholder: '请输入手机号' },
+        { fieldId: 'displayName', label: '姓名', type: 'text', required: false },
+      ],
+      consents: [{ consentId: 'privacy', version: '1', title: '隐私政策', required: true }],
+      authorizationStatus: 'required',
     };
-    return map[level];
+  }
+
+  async listPointUsage(
+    userId: string,
+    page: number,
+    pageSize: number,
+  ): Promise<{ items: ReadonlyArray<PointUsageRecord>; total: number }> {
+    const all = this.usages.filter((u) => u.usageRecordRef.startsWith(userId));
+    const start = (page - 1) * pageSize;
+    return { items: all.slice(start, start + pageSize), total: all.length };
+  }
+
+  async queryDiscount(userId: string): Promise<DiscountRule | undefined> {
+    void userId;
+    return undefined;
   }
 
   async deductPoints(userId: string, amount: number, idempotencyKey: string): Promise<boolean> {
@@ -48,7 +154,12 @@ export class InMemoryMemberService implements MemberService {
     this.balances.set(userId, current - amount);
     this.idempotentKeys.add(idempotencyKey);
     this.audit.push({ action: 'deduct', userId, amount, key: idempotencyKey });
-    this.maybeUpgrade(userId);
+    this.usages.push({
+      usageRecordRef: `${userId}:${Date.now()}`,
+      title: '积分抵扣',
+      amount: `-${amount}`,
+      usedAt: new Date().toISOString(),
+    });
     return true;
   }
 
@@ -58,6 +169,12 @@ export class InMemoryMemberService implements MemberService {
     this.balances.set(userId, current + amount);
     this.idempotentKeys.add(`refund:${idempotencyKey}`);
     this.audit.push({ action: 'refund', userId, amount, key: idempotencyKey });
+    this.usages.push({
+      usageRecordRef: `${userId}:${Date.now()}`,
+      title: '积分退回',
+      amount: `+${amount}`,
+      usedAt: new Date().toISOString(),
+    });
     return true;
   }
 
@@ -65,31 +182,66 @@ export class InMemoryMemberService implements MemberService {
     const current = this.balances.get(userId) ?? 0;
     this.balances.set(userId, current + amount);
     this.audit.push({ action: 'award', userId, amount });
-    this.maybeUpgrade(userId);
+    this.usages.push({
+      usageRecordRef: `${userId}:${Date.now()}`,
+      title: '消费奖励',
+      amount: `+${amount}`,
+      usedAt: new Date().toISOString(),
+    });
     return true;
   }
 
-  private levelOf(userId: string): 'silver' | 'gold' | 'platinum' {
-    const cached = this.levels.get(userId);
-    if (cached) return cached;
-    const balance = this.balances.get(userId) ?? 0;
-    if (balance >= 1000) return 'platinum';
-    if (balance >= 300) return 'gold';
-    return 'silver';
-  }
+  // ===== 5. MemberCouponPort（0.4.0 净删——券域 promotion 承接，恒空面移除） =====
+
+  // ===== 6. MemberEnrollmentPort（015：授权预填 + 幂等 + pending 收口） =====
 
-  private maybeUpgrade(userId: string): void {
-    const newLevel = this.levelOf(userId);
-    const prev = this.levels.get(userId);
-    this.levels.set(userId, newLevel);
-    if (prev && prev !== newLevel) {
-      // 等级变更事件由 serverModule.register 订阅侧转发（保持 service 与 bus 解耦）
-      this.levelChangeListeners.forEach((fn) => fn({ userId, newLevel }));
+  async enroll(input: MemberEnrollmentInput): Promise<MemberEnrollmentResult> {
+    // 幂等：同 idempotencyKey 重入返回首果（015 W3 语义，模块顶层 IdempotencyStore 之上的双保险）
+    const existing = this.enrollmentAttempts.get(input.idempotencyKey);
+    if (existing) return existing.result;
+
+    const mobile = input.fieldValues.mobile ?? '';
+    if (!/^1[3-9]\d{9}$/.test(mobile)) {
+      return { status: 'rejected', reason: '手机号格式不正确' };
+    }
+    const result: MemberEnrollmentResult =
+      this.balances.has(input.userId) || this.pendingConfirmations.has(input.userId)
+        ? { status: 'active', memberRef: `member:${input.userId}` }
+        : { status: 'pending_confirmation', attemptRef: input.idempotencyKey };
+    if (result.status === 'active') {
+      this.profiles.set(input.userId, {
+        ...(input.fieldValues.displayName ? { displayName: input.fieldValues.displayName } : {}),
+        contactDisplay: mobile.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2'),
+        labels: [{ labelRef: 'member', name: '会员' }],
+        observedAt: new Date().toISOString(),
+      });
+    } else {
+      this.pendingConfirmations.add(input.userId);
     }
+    this.enrollmentAttempts.set(input.idempotencyKey, { result, userId: input.userId });
+    return result;
   }
 
-  private levelChangeListeners = new Set<(e: { userId: string; newLevel: 'silver' | 'gold' | 'platinum' }) => void>();
-  onLevelChange(fn: (e: { userId: string; newLevel: 'silver' | 'gold' | 'platinum' }) => void): void {
-    this.levelChangeListeners.add(fn);
+  async getEnrollmentStatus(
+    userId: string,
+    attemptRef: string,
+  ): Promise<{ status: MemberEnrollmentStatus; memberRef?: string; reason?: string }> {
+    const attempt = this.enrollmentAttempts.get(attemptRef);
+    if (!attempt || attempt.userId !== userId) {
+      return { status: 'failed', reason: '入会记录不存在或不属于当前用户' };
+    }
+    if (this.balances.has(userId)) {
+      return { status: 'active', memberRef: `member:${userId}` };
+    }
+    // InMemory 模拟：首次查询 pending，第二次查询确认（厂商异步确认的演示语义）
+    const queried = this.statusQueries.get(attemptRef) ?? 0;
+    this.statusQueries.set(attemptRef, queried + 1);
+    if (queried >= 1) {
+      this.balances.set(userId, 0);
+      this.pendingConfirmations.delete(userId);
+      return { status: 'active', memberRef: `member:${userId}` };
+    }
+    return { status: 'pending_confirmation' };
   }
+
 }

package/src/server/status.ts

@@ -0,0 +1,87 @@
+/**
+ * 会员状态解析（IO 唯一入口）+ outcome 话术单源。
+ * soft 单档：任何失败收口 unavailable + warn 留痕——不伪装状态、不臆测未入会。
+ */
+import type {
+  MemberAccountSnapshot,
+  MemberOutcome,
+  MemberStatusResolution,
+} from '@tbox.cn/app-contracts-mall';
+import { classifyMemberOutcome } from '@tbox.cn/app-contracts-mall';
+import type { RequestContext } from '@tbox.cn/app-contracts';
+import type { ServerContext } from '@tbox.cn/app-sdk/server';
+import { resolveMemberAccountPort, resolveMemberEnrollmentPort } from './ports';
+
+/** 模块内超集（跨模块窄面 = 契约 MemberStatusResolution）。
+ *  017 槽位原子化：service 字段退役（跨槽 fat 类型谎言）——深链素材随 resolution 携带，
+ *  调用方（handler/跨模块 gate）按槽另行解析；厂商快照 memo 由共享 impl 的请求级
+ *  transport 缓存承接（多次构造廉价，行为变化声明④）。 */
+export interface ResolvedMemberStatus extends MemberStatusResolution {}
+
+/** 模型面话术（工具 noResultsReason 消费；与现状逐字节一致） */
+export const MEMBER_LOGIN_NOTICE = '请先登录；登录不要求开通会员';
+export const MEMBER_UNKNOWN_NOTICE = '当前无法确认会员状态，请稍后重试';
+/** 已登录未入会（GUEST/潜客）：下一步是入会引导而非「无积分」——与已退会拆分 */
+export const MEMBER_NOT_ENROLLED_NOTICE = '尚未入会，入会后可查询积分与服务';
+/** 已退会/资格关闭：账户在但积分语义为空（入会引导卡可另出，话术不混同） */
+export const MEMBER_NO_POINTS_NOTICE = '当前没有可查询的会员积分';
+
+/** 直聊面穷尽表（handler 消费；active 走业务路径不查表——Exclude 编译锁死） */
+export const MEMBER_QUERY_NOTICES: Record<Exclude<MemberOutcome | 'unavailable', 'active'>, string> = {
+  unauthenticated: '请先登录后再查询会员信息',
+  unknown: MEMBER_UNKNOWN_NOTICE,
+  not_enrolled: MEMBER_NOT_ENROLLED_NOTICE,
+  closed: MEMBER_NO_POINTS_NOTICE,
+  unavailable: '会员服务暂时不可用，请稍后再试',
+};
+
+/** 匿名短路不触 provider；上下文缺席/resolve/getAccount 失败 → unavailable + warn 留痕
+ *  （管路故障收口可用性语义，不冒充身份语义）。 */
+export async function resolveMemberStatus(
+  reqCtx: RequestContext | undefined,
+  ctx: ServerContext,
+): Promise<ResolvedMemberStatus> {
+  if (!reqCtx) {
+    // 上下文缺席 = 调用方管路断裂（匿名身份语义经 identity.source 表达，与此无关）
+    ctx.logger?.warn('会员状态解析失败：运行上下文缺席');
+    return { outcome: 'unavailable' };
+  }
+  if (reqCtx.identity?.source === 'anonymous') {
+    // 匿名也 attempt 取 loginUrl（登录引导卡降级深链）：工厂建实例只读部署配置、零网络 IO；
+    // 未配置/无 mallId/registry 缺失 → fail-soft 无深链（消费方退文字）
+    let loginUrl: string | undefined;
+    try {
+      const accountPort = await resolveMemberAccountPort(reqCtx, ctx);
+      loginUrl = accountPort.loginUrl || undefined;
+    } catch {
+      /* fail-soft */
+    }
+    return loginUrl ? { outcome: 'unauthenticated', loginUrl } : { outcome: 'unauthenticated' };
+  }
+  // N1 双槽编排（017）：account 槽承载身份判定 + loginUrl；enrollment 槽仅承载
+  // enrollUrl 素材——缺席/失败不拖累身份判定（缺省 = 未配置恒出卡、无 URL 字段）。
+  let accountPort;
+  let account: MemberAccountSnapshot;
+  try {
+    accountPort = await resolveMemberAccountPort(reqCtx, ctx);
+    account = await accountPort.getAccount(reqCtx.identity.userId);
+  } catch (error) {
+    ctx.logger?.warn(`会员状态解析失败：err=${(error as Error).message}`);
+    return { outcome: 'unavailable' };
+  }
+  let enrollUrl: string | undefined;
+  try {
+    const enrollmentPort = await resolveMemberEnrollmentPort(reqCtx, ctx);
+    enrollUrl = enrollmentPort.enrollUrl || undefined;
+  } catch (error) {
+    // enrollment 槽缺席/失败 → 无深链素材（CTA 卡仍可出，memberGateCardOf 既有设计）；
+    // warn 留痕供诊断（配置类错误不静默），不拖累身份判定。
+    ctx.logger?.warn(`会员入会深链解析失败：err=${(error as Error).message}`);
+  }
+  return {
+    outcome: classifyMemberOutcome(reqCtx.identity, account),
+    account,
+    ...(enrollUrl ? { enrollUrl } : {}),
+    ...(accountPort.loginUrl ? { loginUrl: accountPort.loginUrl } : {}),
+  };
+}

package/src/server/subject-binding.ts

@@ -0,0 +1,19 @@
+/**
+ * SubjectBindingPort 兼容实现（已 deprecated——见 contracts-mall 契约注释）：
+ * 同步签名对任意非空 userId 恒返回平台侧派生引用，不承载会员身份语义。
+ * 会员状态判定与真实外部会员引用请消费 'member.status' 服务 + externalMemberRefOf。
+ * 保留注册仅为版本偏斜期兼容（旧消费方混装）。
+ */
+import type { SubjectBindingPort } from '@tbox.cn/app-contracts-mall';
+import { createHash } from 'node:crypto';
+import type { ServerContext } from '@tbox.cn/app-sdk/server';
+
+export function createSubjectBinding(ctx: ServerContext): SubjectBindingPort {
+  return {
+    resolveExternalMemberRef(userId: string): string | undefined {
+      void ctx;
+      // 同步签名无法访问异步 Provider，这里只提供稳定派生 ref。
+      return userId ? `member-ref:${createHash('sha256').update(userId).digest('hex').slice(0, 24)}` : undefined;
+    },
+  };
+}