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

package/tests/service.test.ts

@@ -1,53 +1,614 @@
-import { describe, expect, it } from 'vitest';
-import { createServerContext } from '@tbox.cn/app-sdk/server';
+/**
+ * module-member 工具链回归（F5 终态）：槽位轴解析 → 自包含 stub adapter 产出
+ * 完整 MemberService 面；锁定工具投影、卡片决策与上下文服务行为。
+ * 上下文统一化：显式缝——工具 execute 第二参 = createToolExecContext(reqCtx)，
+ * 跨模块消费走 'member.service' 工厂（替代旧 ctx.auth 全局单例假缝）。
+ */
+import { describe, expect, it, vi } from 'vitest';
+
+// 模块级 mock：resolveMemberStatus 默认转发真实实现（其余用例不感知）；
+// 仅 handler「active 缺服务实例」防御分支用例经 mockResolvedValueOnce 构造
+// 真实 resolver 类型上不可产出的形态（active ⟹ service 必在）
+vi.mock('../src/server/status', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../src/server/status')>();
+  return { ...actual, resolveMemberStatus: vi.fn(actual.resolveMemberStatus) };
+});
+
+import type { RequestContext } from '@tbox.cn/app-contracts';
+import {
+  createIntegrationsRegistry,
+  createAuthStrategyRegistry,
+  createEnvironmentSecretProvider,
+  createServerContext,
+  createToolExecContext,
+} from '@tbox.cn/app-sdk/server';
+import type { ToolExecContextLike, ServerContext } from '@tbox.cn/app-sdk/server';
+import type { MemberAccountPort, MemberBenefitsFactory, MemberStatusFactory } from '@tbox.cn/app-contracts-mall';
+import type { MemberService } from '../src/server/service';
 import { serverModule } from '../src/server/index';
+import { createMemberHandler } from '../src/server/handler';
+import { resolveMemberStatus } from '../src/server/status';
+import { memberCardSummaryMeta } from '../src/server/cards';
+import {
+  MEMBER_PRIVACY_REFUSAL,
+  createQueryEnrollmentCtaTool,
+  createQueryLoginCtaTool,
+  createQueryMemberCardTool,
+  createQueryMemberInfoTool,
+  createQueryPointsTool,
+} from '../src/server/tool';
 
-describe('module-member 自注册与积分服务', () => {
-  it('serverModule.register 注册 tool/card/service/handler', () => {
-    const ctx = createServerContext();
-    serverModule.register(ctx);
 
-    expect(ctx.tools.has('queryPoints')).toBe(true);
-    expect(ctx.cards.has('points')).toBe(true);
+/** fat stub getter → 五槽 ports 注入（017 槽位原子化测试基建：stub 实现全部 Port 方法，
+ *  结构兼容任一槽产物视图）。 */
+function memberPortsOf(getStub: () => Promise<MemberService>): import('../src/server/tool').MemberToolPorts {
+  return {
+    getAccount: getStub,
+    getProfile: getStub,
+    getCard: getStub,
+    getBenefits: getStub,
+    getEnrollment: getStub,
+  };
+}
+
+function requestContext(mallId = 'mall-demo', token = 'user-token', provider = 'dev'): RequestContext {
+  return {
+    identity: { userId: 'u_1001', source: 'dev' },
+    credentials: { provider, token },
+    attributes: { mall: { miniAppId: 'demo-app', mallId } },
+  };
+}
+
+/** 自包含 stub：登录状态与会员状态分轴。 */
+function stubMemberService(userToken: string, completeCard = false): MemberService {
+  const now = new Date().toISOString();
+  return {
+    enrollUrl: 'alipays://platformapi/startapp?appId=demo',
+    async getAccount() {
+      if (!userToken) {
+        return { authState: 'unauthenticated', state: 'unknown', observedAt: now };
+      }
+      return { authState: 'authenticated', state: 'active', memberRef: 'member:C-1001', primaryMallCardNo: 'C-1001', observedAt: now };
+    },
+    async getProfile() {
+      return {
+        displayName: '测试会员',
+        contactDisplay: '138****0000',
+        labels: [{ labelRef: 'member', name: '悦享卡' }],
+        observedAt: now,
+      };
+    },
+    async getCard() {
+      return {
+        cardRef: 'card:C-1001',
+        cardDisplay: '悦享卡',
+        status: 'active',
+        cardImageUrl: 'https://img.example-mall.cn/sp_mall/member-card.png',
+        ...(completeCard ? { presentation: { variant: 'blue' as const } } : {}),
+        observedAt: now,
+      };
+    },
+    async queryPoints(userId) {
+      return { userId, balance: 300, membershipLabel: '悦享卡' };
+    },
+    async getBenefits() {
+      return { availablePoints: 300, observedAt: now };
+    },
+    async listPointUsage() {
+      return {
+        items: [
+          {
+            usageRecordRef: 'usage:1',
+            title: '促销奖励',
+            amount: '+300',
+            usedAt: '2026-08-14T03:05:25.000Z',
+            description: '开卡礼',
+          },
+        ],
+        total: 1,
+      };
+    },
+    async queryDiscount() {
+      return undefined;
+    },
+    async deductPoints() {
+      return false;
+    },
+    async refundPoints() {
+      return false;
+    },
+    async awardPoints() {
+      return false;
+    },
+    async getEnrollmentFormDefinition() {
+      return {
+        formVersion: 'fixture-9-2',
+        fields: [{ fieldId: 'mobile', label: '手机号', type: 'tel', required: true, placeholder: '请输入手机号' }],
+        consents: [{ consentId: 'privacy', version: '2', title: '隐私政策', required: true }],
+        authorizationStatus: 'required',
+      };
+    },
+    async enroll(input) {
+      return { status: 'pending_confirmation', attemptRef: input.idempotencyKey };
+    },
+    async getEnrollmentStatus() {
+      return { status: 'active', memberRef: 'member:C-1001' };
+    },
+  } satisfies MemberService;
+}
+
+const FIXTURE_PROVIDER = 'fixture';
+const FIXTURE_PROVIDER_ID = 'fixture-member@1';
+
+function fixtureServer(mallId = 'mall-demo', token = 'user-token'): ServerContext {
+  const registry = createIntegrationsRegistry({
+    integrations: {
+      services: {
+        'member.account': { provider: FIXTURE_PROVIDER, implementation: FIXTURE_PROVIDER_ID, instances: { [mallId]: { enabled: true } } },
+        'member.profile': { provider: FIXTURE_PROVIDER, implementation: FIXTURE_PROVIDER_ID, instances: { [mallId]: { enabled: true } } },
+        'member.card': { provider: FIXTURE_PROVIDER, implementation: FIXTURE_PROVIDER_ID, instances: { [mallId]: { enabled: true } } },
+        'member.benefits': { provider: FIXTURE_PROVIDER, implementation: FIXTURE_PROVIDER_ID, instances: { [mallId]: { enabled: true } } },
+        'member.enrollment': { provider: FIXTURE_PROVIDER, implementation: FIXTURE_PROVIDER_ID, instances: { [mallId]: { enabled: true } } },
+      },
+    },
+    catalog: {
+      providers: {
+        // local: true → transport 短路（stub 不消费 transport，免凭据/认证链）
+        [FIXTURE_PROVIDER]: {
+          [FIXTURE_PROVIDER_ID]: { provider: FIXTURE_PROVIDER, implementation: FIXTURE_PROVIDER_ID, credentialType: '-', owner: 'fixture', services: ['member.account', 'member.profile', 'member.card', 'member.benefits', 'member.enrollment'], local: true },
+        },
+      },
+      services: {},
+      credentialTypes: {},
+    },
+    authStrategies: createAuthStrategyRegistry(),
+    secretProvider: createEnvironmentSecretProvider({ source: {}, production: false }),
+    instanceIdOf: (scope) => scope.mallId ?? '',
+  });
+  registry.registerAdapter(FIXTURE_PROVIDER, FIXTURE_PROVIDER_ID, () => stubMemberService(token));
+  const ctx = createServerContext({ integrations: registry });
+  serverModule.register(ctx);
+  return ctx;
+}
+
+/** 显式缝：工具 execute 第二参（reqCtx 散键写入与引擎 buildRunRequestContext 同构） */
+function execCtx(mallId = 'mall-demo', token = 'user-token'): ToolExecContextLike {
+  return createToolExecContext(requestContext(mallId, token));
+}
+
+describe('module-member 槽位轴工具链', () => {
+  it('注册五个工具、七张卡、动作、handler 和上下文服务', () => {
+    const ctx = fixtureServer();
+    expect(
+      ['queryPoints', 'queryMemberInfo', 'queryMemberCard', 'queryEnrollmentForm', 'queryEnrollmentCta'].every((id) =>
+        ctx.tools.has(id),
+      ),
+    ).toBe(true);
+    expect(ctx.tools.resolve('queryPoints')?.description).not.toContain('等级');
+    expect(ctx.tools.resolve('queryMemberCard')?.description).not.toContain('等级');
+    expect(ctx.cards.has('member-point-usage-list')).toBe(true);
+    expect(ctx.cards.has('member-info')).toBe(true);
+    expect(ctx.cards.has('member-card-summary')).toBe(true);
+    expect(ctx.cards.has('member-enrollment-form')).toBe(true);
+    expect(ctx.cards.has('member-enrollment-status')).toBe(true);
+    expect(ctx.cards.has('member-enrollment-cta')).toBe(true);
+    expect(ctx.cards.has('member-login-cta')).toBe(true);
+    expect(ctx.cardActions.get('member.enroll')).toBeDefined();
     expect(ctx.handlers.has('member')).toBe(true);
-    expect(ctx.resolveService('member')).toBeDefined();
+    expect(ctx.resolveService<MemberBenefitsFactory>('member.service')).toBeDefined();
+    expect(ctx.resolveService<MemberStatusFactory>('member.status')).toBeDefined();
   });
 
-  it('queryPoints 返回初始积分', async () => {
-    const ctx = createServerContext();
-    serverModule.register(ctx);
-    const member = ctx.resolveService<{ queryPoints(u: string): Promise<{ balance: number; level: string }> }>('member')!;
-    const points = await member.queryPoints('u_1001');
-    expect(points.balance).toBe(860);
-    expect(points.level).toBe('gold');
+  it('会员卡契约升至 v4，并以 identity migrate 兼容旧快照', () => {
+    const oldData = {
+      userId: 'u_1001',
+      cardRef: 'card:C-1001',
+      cardDisplay: '悦享卡',
+      status: 'active',
+      availablePoints: 300,
+    };
+    expect(memberCardSummaryMeta.schemaVersion).toBe(5);
+    expect(memberCardSummaryMeta.migrate?.(oldData, 1)).toEqual(oldData);
+    expect(memberCardSummaryMeta.dataSchema.safeParse(oldData).success).toBe(true);
   });
 
-  it('deductPoints 幂等（同 idempotencyKey 只扣一次）', async () => {
-    const ctx = createServerContext();
-    serverModule.register(ctx);
-    const member = ctx.resolveService<{ deductPoints(u: string, a: number, k: string): Promise<boolean> }>('member')!;
+  it('queryMemberCard 将动态卡面、进度和真实权益投影到出卡数据', async () => {
+    const tool = createQueryMemberCardTool(memberPortsOf(async () => ({
+      ...stubMemberService('user-token'),
+      async getCard() {
+        return {
+          cardRef: 'card:dynamic',
+          cardDisplay: '金卡会员',
+          status: 'active' as const,
+          pointsRuleImageUrl: 'https://assets.example.com/member/points-rule.jpg',
+          presentation: { variant: 'gold' as const, labelsEmbedded: true },
+          progress: {
+            daySpentCents: 12_345,
+            yearSpentCents: 500_000,
+            percent: 25,
+            message: '今日已消费123.45元，年累计已消费5000.00元',
+          },
+          benefits: [{ benefitRef: 'benefit:points', name: '消费积分' }],
+          observedAt: '2026-08-25T00:00:00.000Z',
+        };
+      },
+      async queryPoints(userId: string) {
+        return { userId, balance: 987 };
+      },
+    })));
+    const result = await (tool as unknown as {
+      execute(input: unknown, execCtx?: ToolExecContextLike): Promise<{ cards: Array<{ data: Record<string, unknown> }> }>;
+    }).execute({}, execCtx());
+    expect(result.cards[0]?.data).toMatchObject({
+      presentation: { variant: 'gold', labelsEmbedded: true },
+      pointsRuleImageUrl: 'https://assets.example.com/member/points-rule.jpg',
+      progress: { percent: 25 },
+      benefits: [{ benefitRef: 'benefit:points', name: '消费积分' }],
+      contractNotice: expect.stringContaining('仅展示系统返回的当前等级权益'),
+    });
+  });
 
-    expect(await member.deductPoints('u_1001', 100, 'key-1')).toBe(true);
-    expect(await member.deductPoints('u_1001', 100, 'key-1')).toBe(true); // 幂等
-    const after = await ctx.resolveService<{ queryPoints(u: string): Promise<{ balance: number }> }>('member')!.queryPoints('u_1001');
-    expect(after.balance).toBe(760); // 只扣一次
+  it('跨模块 MemberBenefitsFactory 解析后按 reqCtx 调用读取余额真值', async () => {
+    const ctx = fixtureServer();
+    const factory = ctx.resolveService<MemberBenefitsFactory>('member.service');
+    const member = await factory?.(requestContext());
+    await expect(member?.queryPoints('u_1001')).resolves.toMatchObject({ balance: 300, membershipLabel: '悦享卡' });
   });
 
-  it('余额不足扣减失败', async () => {
-    const ctx = createServerContext();
-    serverModule.register(ctx);
-    const member = ctx.resolveService<{ deductPoints(u: string, a: number, k: string): Promise<boolean> }>('member')!;
-    expect(await member.deductPoints('u_1001', 99999, 'key-x')).toBe(false);
+  it('跨模块会员工厂解析后暴露账户状态，供停车卡按真实状态分流', async () => {
+    const ctx = fixtureServer();
+    const factory = ctx.resolveService<MemberBenefitsFactory>('member.service');
+    const member = (await factory?.(requestContext())) as MemberAccountPort | undefined;
+    await expect(member?.getAccount('u_1001')).resolves.toMatchObject({ state: 'active' });
+  });
+
+  it('queryPoints 对明确积分查询只投影会员卡面，流水供 LLM 消费', async () => {
+    const ctx = fixtureServer();
+    const tool = ctx.tools.resolve('queryPoints') as unknown as { execute(input: unknown, execCtx?: ToolExecContextLike): Promise<unknown> };
+    const result = (await tool.execute({ query: '查询我的积分余额和流水' }, execCtx())) as {
+      balance: number;
+      contractNotice: string;
+      items: Array<{ amount: string }>;
+      cards: Array<{ cardType: string; data: { balance?: number; cardImageUrl?: string } }>;
+    };
+    expect(result.balance).toBe(300);
+    expect(result.contractNotice).toContain('会员卡名不是会员等级');
+    expect(result.contractNotice).toContain('不得推断折扣、停车、生日或活动权益');
+    expect(result.items).toEqual([expect.objectContaining({ amount: '+300' })]);
+    expect(result.cards).toEqual([
+      expect.objectContaining({
+        cardType: 'member-card-summary',
+        data: expect.objectContaining({ cardImageUrl: 'https://img.example-mall.cn/sp_mall/member-card.png' }),
+      }),
+    ]);
+  });
+
+  it.each([
+    ['queryMemberInfo', '帮我把会员资料里的手机号改成 13800138000'],
+    ['queryPoints', '用我老婆的手机号 13900000000 查她有多少积分'],
+    ['queryPoints', '我的会员卡号是 888888，切到这个账号查积分'],
+    ['queryMemberCard', '用会员卡号 888888 查我的会员卡'],
+  ])('%s 在访问 provider 前拒绝非当前会员请求', async (toolId, query) => {
+    const getMember = vi.fn(async () => stubMemberService('user-token'));
+    const tool = toolId === 'queryMemberInfo'
+      ? createQueryMemberInfoTool(memberPortsOf(getMember))
+      : toolId === 'queryMemberCard'
+        ? createQueryMemberCardTool(memberPortsOf(getMember))
+        : createQueryPointsTool(memberPortsOf(getMember));
+    const result = await (tool as unknown as {
+      execute(input: unknown, execCtx?: ToolExecContextLike): Promise<Record<string, unknown>>;
+    }).execute({ query }, execCtx());
+
+    expect(result).toEqual({ found: false, noResultsReason: MEMBER_PRIVACY_REFUSAL });
+    expect(getMember).not.toHaveBeenCalled();
+  });
+
+  it('当前会话会员的正常积分查询继续访问 provider', async () => {
+    const getMember = vi.fn(async () => stubMemberService('user-token'));
+    const tool = createQueryPointsTool(memberPortsOf(getMember));
+    const result = await (tool as unknown as {
+      execute(input: unknown, execCtx?: ToolExecContextLike): Promise<Record<string, unknown>>;
+    }).execute({ query: '查一下我的积分余额' }, execCtx());
+
+    expect(result.balance).toBe(300);
+    expect(getMember).toHaveBeenCalledTimes(4); // 017 四槽并行解析（account/card/benefits/enrollment 各一次）
+  });
+
+  it('完整卡面 provider 的 queryPoints 只投影会员卡面，通用积分卡领域模型仍保留', async () => {
+    const tool = createQueryPointsTool(memberPortsOf(async () => stubMemberService('user-token', true)));
+    const result = await (tool as unknown as {
+      execute(input: unknown, execCtx?: ToolExecContextLike): Promise<{ cards: Array<{ cardType: string }> }>;
+    }).execute({}, createToolExecContext(requestContext('mall-demo', 'user-token', 'rich-card')));
+    expect(result.cards).toEqual([expect.objectContaining({ cardType: 'member-card-summary' })]);
+  });
+
+  it('完整卡面 provider 的 queryMemberInfo 只投影会员卡面', async () => {
+    const tool = createQueryMemberInfoTool(memberPortsOf(async () => stubMemberService('user-token', true)));
+    const result = await (tool as unknown as {
+      execute(input: unknown, execCtx?: ToolExecContextLike): Promise<{ cards: Array<{ cardType: string }> }>;
+    }).execute({}, createToolExecContext(requestContext('mall-demo', 'user-token', 'rich-card')));
+    expect(result.cards).toEqual([expect.objectContaining({ cardType: 'member-card-summary' })]);
+  });
+
+  it('会员查询以卡面为唯一积分主卡，流水不进入候选卡池', async () => {
+    const ctx = fixtureServer();
+    const execute = async (toolId: string, input: unknown) => {
+      const tool = ctx.tools.resolve(toolId) as unknown as { execute(input: unknown, execCtx?: ToolExecContextLike): Promise<Record<string, unknown>> };
+      return tool.execute(input, execCtx());
+    };
+
+    const points = await execute('queryPoints', { query: '查询我的积分余额和流水' });
+    expect(points.cards).toEqual([expect.objectContaining({ cardType: 'member-card-summary' })]);
+
+    const info = await execute('queryMemberInfo', {});
+    expect(info.cards).toEqual([
+      expect.objectContaining({ cardType: 'member-card-summary' }),
+      expect.objectContaining({ cardType: 'member-info' }),
+    ]);
+
+    const card = await execute('queryMemberCard', {});
+    expect(card.cards).toEqual([expect.objectContaining({ cardType: 'member-card-summary' })]);
+
+    const enrollment = await execute('queryEnrollmentForm', {});
+    expect(enrollment).toMatchObject({ state: 'active', found: false });
+    expect(enrollment).not.toHaveProperty('cards');
+  });
+
+  it('numeric-looking member IDs stay strings through member card/info tools', async () => {
+    const ctx = fixtureServer();
+    const execute = async (toolId: string, input: unknown) => {
+      const tool = ctx.tools.resolve(toolId) as unknown as { execute(input: unknown, execCtx?: ToolExecContextLike): Promise<Record<string, unknown>> };
+      return tool.execute(input, execCtx());
+    };
+    // 上下文统一化：userId 来自运行身份（reqCtx.identity.userId）不再经 LLM 传参——
+    // 数值形态字符串由 requestContext 的 userId 承载（注入面关闭后该用例锁「字符串不数值化」）
+    const numericCtx = createToolExecContext({
+      identity: { userId: '17000001019327925', source: 'dev' },
+      attributes: { mall: { miniAppId: 'demo-app', mallId: 'mall-demo' } },
+    });
+    const tool = ctx.tools.resolve('queryMemberInfo') as unknown as { execute(input: unknown, execCtx?: ToolExecContextLike): Promise<Record<string, unknown>> };
+    await expect(tool.execute({}, numericCtx)).resolves.toMatchObject({
+      userId: '17000001019327925',
+    });
+    const cardTool = ctx.tools.resolve('queryMemberCard') as unknown as { execute(input: unknown, execCtx?: ToolExecContextLike): Promise<Record<string, unknown>> };
+    await expect(cardTool.execute({}, numericCtx)).resolves.toMatchObject({
+      userId: '17000001019327925',
+    });
+    void execute;
   });
 
-  it('parking.coupon.used 事件 → 奖积分（跨模块解耦）', async () => {
+  it('integrations 缺失时明确失败（F5 终态：唯一供给轴缺席即报错）', async () => {
     const ctx = createServerContext();
     serverModule.register(ctx);
-    // 模拟 parking 发布事件
-    ctx.bus.emit('parking.coupon.used', { userId: 'u_1002', couponId: 'c_1', amount: 50 });
-    await new Promise((r) => setTimeout(r, 10)); // 等待异步订阅
-    const member = ctx.resolveService<{ queryPoints(u: string): Promise<{ balance: number }> }>('member')!;
-    const after = await member.queryPoints('u_1002');
-    expect(after.balance).toBe(120 + Math.floor(50 / 10));
+    const factory = ctx.resolveService<MemberBenefitsFactory>('member.service');
+    await expect(factory?.(requestContext('mall-without-provider'))).rejects.toThrow(/integrations registry 缺失/);
+  });
+
+  it('queryEnrollmentCta 未登录且未配登录入口：出登录卡（无 URL 字段，深链解耦后恒出卡）', async () => {
+    const ctx = fixtureServer('10025', '');
+    const tool = ctx.tools.resolve('queryEnrollmentCta') as unknown as {
+      execute(input: unknown, execCtx?: ToolExecContextLike): Promise<{ found?: boolean; cards?: Array<{ cardType: string; data: Record<string, unknown> }> }>;
+    };
+    const result = await tool.execute({}, execCtx('10025', ''));
+    expect(result.found).toBe(true);
+    expect(result.cards).toEqual([expect.objectContaining({ cardType: 'member-login-cta' })]);
+    expect(result.cards?.[0]?.data).not.toHaveProperty('loginUrl');
+  });
+
+  it('queryEnrollmentCta 未登录且配了登录入口：出登录卡而非入会卡', async () => {
+    const tool = createQueryEnrollmentCtaTool(
+      memberPortsOf(async () =>
+        ({ ...stubMemberService(''), async getAccount() {
+          return { authState: 'unauthenticated' as const, state: 'unknown' as const, observedAt: new Date().toISOString() };
+        }, loginUrl: 'alipays://platformapi/startapp?appId=demo&page=login' }) as unknown as Promise<MemberService>),
+    ) as unknown as { execute(input: unknown, execCtx?: ToolExecContextLike): Promise<Record<string, unknown>> };
+    const result = await tool.execute({}, execCtx());
+    // 登录卡而不是入会卡——此刻还没有身份，谈入会为时过早
+    expect(result.cards).toEqual([expect.objectContaining({ cardType: 'member-login-cta' })]);
+    expect(result).toMatchObject({ loginUrl: 'alipays://platformapi/startapp?appId=demo&page=login' });
+  });
+
+  it('queryLoginCta 主动索要登录入口即出卡', async () => {
+    const tool = createQueryLoginCtaTool(
+      memberPortsOf(async () =>
+        ({ ...stubMemberService('user-token'), loginUrl: 'alipays://platformapi/startapp?appId=demo&page=login' }) as unknown as Promise<MemberService>),
+    ) as unknown as { execute(input: unknown, execCtx?: ToolExecContextLike): Promise<Record<string, unknown>> };
+    const result = await tool.execute({}, execCtx());
+    expect(result.cards).toEqual([expect.objectContaining({ cardType: 'member-login-cta' })]);
+    expect(result).toMatchObject({ title: '登录后继续', loginUrl: 'alipays://platformapi/startapp?appId=demo&page=login' });
+  });
+
+  it('queryLoginCta 未配登录入口时仍出卡（深链解耦：无 URL 字段，不设闸于登录态）', async () => {
+    const tool = createQueryLoginCtaTool(memberPortsOf(async () => stubMemberService('user-token'))) as unknown as {
+      execute(input: unknown, execCtx?: ToolExecContextLike): Promise<Record<string, unknown>>;
+    };
+    const result = await tool.execute({}, execCtx());
+    expect(result.cards).toEqual([expect.objectContaining({ cardType: 'member-login-cta' })]);
+    expect((result.cards as Array<{ data: Record<string, unknown> }>)[0].data).not.toHaveProperty('loginUrl');
+  });
+
+  it('queryEnrollmentCta 只为已登录且确认未入会的用户出卡', async () => {
+    const tool = createQueryEnrollmentCtaTool(
+      memberPortsOf(async () =>
+        ({ ...stubMemberService('user-token'), async getAccount() {
+          return { authState: 'authenticated' as const, state: 'not_enrolled' as const, observedAt: new Date().toISOString() };
+        } }) as unknown as Promise<MemberService>),
+    ) as unknown as { execute(input: unknown, execCtx?: ToolExecContextLike): Promise<Record<string, unknown>> };
+    const result = await tool.execute({}, execCtx());
+    expect(result).toMatchObject({ authState: 'authenticated', state: 'not_enrolled' });
+    expect(result.cards).toEqual([expect.objectContaining({ cardType: 'member-enrollment-cta' })]);
+  });
+
+  it('queryPoints 已登录未入会：出 enrollment-cta 引导卡（半屏入会闭环投影源），话术区分已退会', async () => {
+    const notEnrolled = async () =>
+      ({ ...stubMemberService('user-token'), async getAccount() {
+        return { authState: 'authenticated' as const, state: 'not_enrolled' as const, observedAt: '2026-08-30T00:00:00.000Z' };
+      } }) as MemberService;
+    const execute = (tool: unknown) =>
+      (tool as unknown as { execute(input: unknown, execCtx?: ToolExecContextLike): Promise<Record<string, unknown>> }).execute({}, execCtx());
+    const tool = createQueryPointsTool(memberPortsOf(notEnrolled));
+    const result = await execute(tool);
+    expect(result.noResultsReason).toContain('尚未入会');
+    expect(result.cards).toEqual([
+      expect.objectContaining({
+        cardType: 'member-enrollment-cta',
+        data: expect.objectContaining({
+          authState: 'authenticated',
+          state: 'not_enrolled',
+          enrollUrl: 'alipays://platformapi/startapp?appId=demo',
+        }),
+      }),
+    ]);
+    // 已退会（closed）：同样出引导卡，话术保持「无积分」不称「尚未入会」
+    const closed = async () =>
+      ({ ...stubMemberService('user-token'), async getAccount() {
+        return { authState: 'authenticated' as const, state: 'closed' as const, observedAt: '2026-08-30T00:00:00.000Z' };
+      } }) as MemberService;
+    const closedResult = await execute(createQueryPointsTool(memberPortsOf(closed)));
+    expect(closedResult.noResultsReason).toBe('当前没有可查询的会员积分');
+    expect(closedResult.cards).toEqual([expect.objectContaining({ cardType: 'member-enrollment-cta' })]);
+  });
+
+  it('queryPoints 已登录未入会且未配入会入口：恒出卡（无 URL 字段，深链为可选透传素材）', async () => {
+    const tool = createQueryPointsTool(
+      memberPortsOf(async () =>
+        ({ ...stubMemberService('user-token'), enrollUrl: '', async getAccount() {
+          return { authState: 'authenticated' as const, state: 'not_enrolled' as const, observedAt: '2026-08-30T00:00:00.000Z' };
+        } }) as MemberService),
+    ) as unknown as { execute(input: unknown, execCtx?: ToolExecContextLike): Promise<Record<string, unknown>> };
+    const result = await tool.execute({}, execCtx());
+    expect(result.noResultsReason).toContain('尚未入会');
+    expect(result.cards).toEqual([
+      expect.objectContaining({
+        cardType: 'member-enrollment-cta',
+        data: expect.objectContaining({ authState: 'authenticated', state: 'not_enrolled' }),
+      }),
+    ]);
+    expect((result.cards as Array<{ data: Record<string, unknown> }>)[0].data).not.toHaveProperty('enrollUrl');
+  });
+
+  it('queryPoints 未登录不出入会卡（登录 ≠ 入会）', async () => {
+    const tool = createQueryPointsTool(
+      memberPortsOf(async () => stubMemberService('')),
+    ) as unknown as { execute(input: unknown, execCtx?: ToolExecContextLike): Promise<Record<string, unknown>> };
+    const result = await tool.execute({}, execCtx());
+    expect(result.noResultsReason).toContain('请先登录');
+    expect(result).not.toHaveProperty('cards');
+  });
+
+  it('queryMemberInfo 已登录未入会：入会引导卡排首位、资料卡保留', async () => {
+    const tool = createQueryMemberInfoTool(
+      memberPortsOf(async () =>
+        ({ ...stubMemberService('user-token'), async getAccount() {
+          return { authState: 'authenticated' as const, state: 'not_enrolled' as const, observedAt: '2026-08-30T00:00:00.000Z' };
+        } }) as MemberService),
+    ) as unknown as { execute(input: unknown, execCtx?: ToolExecContextLike): Promise<Record<string, unknown>> };
+    const result = await tool.execute({}, execCtx());
+    expect(result.cards).toEqual([
+      expect.objectContaining({ cardType: 'member-enrollment-cta' }),
+      expect.objectContaining({ cardType: 'member-info' }),
+    ]);
+  });
+
+  it('queryMemberCard 已登录未入会：同构出 enrollment-cta 引导卡', async () => {
+    const tool = createQueryMemberCardTool(
+      memberPortsOf(async () =>
+        ({ ...stubMemberService('user-token'), async getAccount() {
+          return { authState: 'authenticated' as const, state: 'not_enrolled' as const, observedAt: '2026-08-30T00:00:00.000Z' };
+        } }) as MemberService),
+    ) as unknown as { execute(input: unknown, execCtx?: ToolExecContextLike): Promise<Record<string, unknown>> };
+    const result = await tool.execute({}, execCtx());
+    expect(result.noResultsReason).toContain('尚未入会');
+    expect(result.cards).toEqual([
+      expect.objectContaining({
+        cardType: 'member-enrollment-cta',
+        data: expect.objectContaining({ state: 'not_enrolled', enrollUrl: 'alipays://platformapi/startapp?appId=demo' }),
+      }),
+    ]);
+  });
+});
+
+describe('createMemberHandler 查询路径门禁（意图与工具路径一致：不再对非 active 态答「积分 0」）', () => {
+  const handlerReqCtx = (source: 'dev' | 'anonymous' = 'dev'): RequestContext =>
+    ({
+      identity: { userId: 'u_1001', source },
+      attributes: { mall: { miniAppId: 'demo-app', mallId: 'mall-demo' } },
+    }) as RequestContext;
+
+  /** integrations.resolveService → 预置 account 的 stub service（'throw' = 解析失败） */
+  const handlerCtx = (accountOrThrow: unknown): ServerContext =>
+    ({
+      integrations: {
+        resolveService: async () => {
+          if (accountOrThrow === 'throw') throw new Error('registry down');
+          return { ...stubMemberService('user-token'), getAccount: async () => accountOrThrow };
+        },
+      },
+    }) as unknown as ServerContext;
+
+  it('匿名 → 请先登录后再查询会员信息（若触 provider 必转 unavailable——本例即短路证明）', async () => {
+    const ctx = handlerCtx('throw');
+    const handler = createMemberHandler(ctx);
+    const result = await handler.handle('query-points', {}, ctx, handlerReqCtx('anonymous'));
+    expect(result).toEqual({ cards: [], text: '请先登录后再查询会员信息' });
+  });
+
+  it('not_enrolled → 入会引导话术（已登录未入会，非「无积分」）', async () => {
+    const ctx = handlerCtx({ authState: 'authenticated' as const, state: 'not_enrolled' as const, observedAt: '2026-08-30T00:00:00.000Z' });
+    const handler = createMemberHandler(ctx);
+    const result = await handler.handle('query-points', {}, ctx, handlerReqCtx());
+    expect(result).toEqual({ cards: [], text: '尚未入会，入会后可查询积分与服务' });
+  });
+
+  it('closed → 积分话术（已退会无积分）', async () => {
+    const ctx = handlerCtx({ authState: 'authenticated' as const, state: 'closed' as const, observedAt: '2026-08-30T00:00:00.000Z' });
+    const handler = createMemberHandler(ctx);
+    const result = await handler.handle('query-points', {}, ctx, handlerReqCtx());
+    expect(result).toEqual({ cards: [], text: '当前没有可查询的会员积分' });
+  });
+
+  it('unknown → 无法确认话术', async () => {
+    const ctx = handlerCtx({ authState: 'authenticated' as const, state: 'unknown' as const, observedAt: '2026-08-30T00:00:00.000Z' });
+    const handler = createMemberHandler(ctx);
+    const result = await handler.handle('query-points', {}, ctx, handlerReqCtx());
+    expect(result).toEqual({ cards: [], text: '当前无法确认会员状态，请稍后重试' });
+  });
+
+  it('凭证轴未认证 → 请先登录后再查询会员信息（tokenless 合法登录形态）', async () => {
+    const ctx = handlerCtx({ authState: 'unauthenticated' as const, state: 'unknown' as const, observedAt: '2026-08-30T00:00:00.000Z' });
+    const handler = createMemberHandler(ctx);
+    const result = await handler.handle('query-points', {}, ctx, handlerReqCtx());
+    expect(result).toEqual({ cards: [], text: '请先登录后再查询会员信息' });
+  });
+
+  it('服务解析失败 → unavailable 软文案（原为裸抛）', async () => {
+    const ctx = handlerCtx('throw');
+    const handler = createMemberHandler(ctx);
+    const result = await handler.handle('query-points', {}, ctx, handlerReqCtx());
+    expect(result).toEqual({ cards: [], text: '会员服务暂时不可用，请稍后再试' });
+  });
+
+  it('active → 只出会员卡面，积分流水仅进入文本', async () => {
+    const ctx = handlerCtx({ authState: 'authenticated' as const, state: 'active' as const, memberRef: 'member:C-1001', primaryMallCardNo: 'C-1001', observedAt: '2026-08-30T00:00:00.000Z' });
+    const handler = createMemberHandler(ctx);
+    const result = await handler.handle('query-points', {}, ctx, handlerReqCtx());
+    expect(result.cards).toEqual([expect.objectContaining({ cardType: 'member-card-summary' })]);
+    expect(result.text).toContain('当前积分 300');
+  });
+
+  it('active + card/benefits 槽解析失败（N1 双槽：service 字段退役，防御分支随架构消解）→ unavailable 收口不裸抛', async () => {
+    const warn = vi.fn();
+    const ctx = {
+      // account 槽短路 status（active），card/benefits 槽放炸药证明失败被 handler 收口
+      integrations: { resolveService: async () => { throw new Error('unreachable'); } },
+      logger: { warn },
+    } as unknown as ServerContext;
+    vi.mocked(resolveMemberStatus).mockResolvedValueOnce({
+      outcome: 'active',
+      account: { authState: 'authenticated', state: 'active', observedAt: '2026-08-30T00:00:00.000Z' },
+    });
+    const handler = createMemberHandler(ctx);
+    const result = await handler.handle('query-points', {}, ctx, handlerReqCtx());
+    expect(result).toEqual({ cards: [], text: '会员服务暂时不可用，请稍后再试' });
   });
 });