Merge unused step summary removal into test

apps/ai-service/src/modules/pac/pac.service.ts

@@ -7,7 +7,6 @@ import {
   type PacPatientProfileItem,
   type PacAppointment,
   type PacWindowFact,
-  type PacStepLatest,
   type PacOrgNode,
 } from '@pac/pac-client';
 import { BizError } from '../../common/errors/biz-error';
@@ -409,39 +408,6 @@ export class PacService {
   }
 
   /**
-   * ⭐⭐ 「这几步最近一次落在这段时间里」的患者 —— 周期维护（2026-09-15，PAC `steps/latest-window`）。
-   *
-   * ⚠️⚠️ 语义是**每位患者这几步里最近的那一次**落在窗口里，⛔ 不是「窗口里做过」——
-   *   「半年前洗过、上周又洗过」的人不会出现，这正是周期维护要的。
-   * ⚠️ 洁牙在 PAC 里有两种记法（牙周类 `supragingival_scaling` / 预防类 `professional_cleaning`），
-   *   调用方要一起传。
-   * ⚠️ 要不要排除「已经有预约」是我们自己的业务规则，PAC ⛔ 不管。
-   * ⚠️ 翻页、purpose、范围同 `getFactWindowForOrgUnit`。
-   */
-  async getStepLatestWindowForOrgUnit(
-    tenantId: string,
-    orgUnitId: string,
-    query: { steps: string[]; from: Date; to: Date },
-    opts: { maxPages?: number; pageSize?: number } = {},
-  ): Promise<{ items: PacStepLatest[]; truncated: boolean }> {
-    const scope = await this.scope.pacScopeForOrgUnit(tenantId, orgUnitId);
-    const c = this.require();
-    return this.pageAll('步骤最近一次', scope, opts, (cursor) =>
-      c.getStepLatestWindow({
-        host: scope.host,
-        tenantId: scope.tenantId,
-        orgScope: scope.orgScope,
-        purpose: 'outreach',
-        steps: query.steps,
-        from: query.from.toISOString(),
-        to: query.to.toISOString(),
-        limit: opts.pageSize ?? 200,
-        ...(cursor ? { cursor } : {}),
-      }),
-    );
-  }
-
-  /**
    * 事实优先端点共用的翻页 —— ⛔ 别各写一份，那道 `maxPages` 硬上限漏一处就是无限翻页。
    *
    * ⚠️⚠️ **必须翻到 nextCursor 为 null 为止** —— PAC 侧的越权过滤在分页**之后**,

apps/ai-service/tests/outreach-purpose.spec.ts

@@ -45,17 +45,17 @@ describe('外呼意图 —— 合规判据归 PAC', () => {
   });
 
   /**
-   * ⭐ 2026-09-15 PAC 加了事实窗口、步骤最近一次两个事实优先端点 —— **同样说清意图**。
-   * ⚠️ 翻页收在一个 `pageAll` 里（maxPages 硬上限只写一次），⛔ 三个入口各写一个 for 循环。
+   * ⭐ 2026-09-15 PAC 加了事实窗口端点 —— **同样说清意图**。
+   * ⚠️ 翻页收在一个 `pageAll` 里（maxPages 硬上限只写一次），⛔ 不要让每个入口各写一个 for 循环。
    */
-  it('⭐ 三个事实优先的读法都声明 outreach，翻页只有一份', () => {
+  it('⭐ 两个事实优先的读法都声明 outreach，翻页只有一份', () => {
     const src = stripTsComments(read('src/modules/pac/pac.service.ts'));
-    for (const call of ['c.getAppointmentWindow(', 'c.getFactWindow(', 'c.getStepLatestWindow(']) {
+    for (const call of ['c.getAppointmentWindow(', 'c.getFactWindow(']) {
       const seg = src.slice(src.indexOf(call), src.indexOf(call) + 400);
       expect({ call, outreach: /purpose: 'outreach'/.test(seg) }).toEqual({ call, outreach: true });
     }
     expect(src.match(/for \(let page = 0; page < maxPages; page \+= 1\)/g)?.length).toBe(1);
-    expect(src.match(/this\.pageAll\(/g)?.length).toBe(3);
+    expect(src.match(/this\.pageAll\(/g)?.length).toBe(2);
   });
 
   /**

apps/ai-service/tests/pac-host-from-tenant.spec.ts

@@ -83,7 +83,6 @@ describe('每个请求都带宿主', () => {
     ['getAppointmentWindow', () => pac.getAppointmentWindowForAccount(TENANT, 'a1', win), page],
     ['getAppointmentWindow', () => pac.getAppointmentWindowForOrgUnit(TENANT, 'n1', win), page],
     ['getFactWindow', () => pac.getFactWindowForOrgUnit(TENANT, 'n1', { ...win, types: ['treatment_record'], anchor: 'occurred' }), page],
-    ['getStepLatestWindow', () => pac.getStepLatestWindowForOrgUnit(TENANT, 'n1', { ...win, steps: ['professional_cleaning'] }), page],
   ] as const)('⭐ %s 带着坐标里的 host', async (method, run, resolved) => {
     const spy = jest.spyOn(PacClient.prototype, method).mockResolvedValue(resolved as never);
     await run();

apps/pac-docs/openapi/pac.json

@@ -3408,22 +3408,6 @@
         ]
       }
     },
-    "/pac/v1/open/patients/steps/latest-window": {
-      "post": {
-        "description": "Body:{ host, tenantId, orgScope(必填非空), purpose(必填), steps[1..16](必填,PAC 标准 step key), from, to, clinicIds?, cursor?, limit?≤200 }。返回每位患者在 steps 里**最近一次**落在 [from,to) 的那一步:{ patientId, step, lastAt, clinicId, subjectId }。窗口最长 31 天,按 (lastAt, patientId) 升序 keyset 分页;**必须翻到 nextCursor=null 为止**。⭐ purpose=outreach 时 PAC 过掉不打扰/已故/已归档;clinicIds 卡在最近那次做的诊所上。",
-        "operationId": "OpenPatientsController_stepLatestWindow",
-        "parameters": [],
-        "responses": {
-          "200": {
-            "description": ""
-          }
-        },
-        "summary": "按「某几步最近一次」的时间窗取患者(HMAC 验签,免登录)",
-        "tags": [
-          "open"
-        ]
-      }
-    },
     "/pac/v1/open/org/nodes": {
       "post": {
         "description": "Headers:X-PAC-Timestamp / X-PAC-Signature;Body:{ host, tenantId }。返回 { nodes: [{ ref, parentRef, kind(group|brand|region|clinic), name, aliases }] } —— ref 就是 orgScope 里要传的值。",

apps/pac-service/package.json

@@ -29,8 +29,6 @@
     "import-patient": "ts-node --transpile-only src/cli/import-patient.cli.ts",
     "recompute-persona": "ts-node --transpile-only src/cli/recompute-persona.cli.ts",
     "backfill-plan-labels": "ts-node --transpile-only src/cli/backfill-plan-labels.cli.ts",
-    "backfill-step-latest": "ts-node --transpile-only src/cli/backfill-step-latest.cli.ts",
-    "backfill-step-latest:prod": "node dist/cli/backfill-step-latest.cli.js",
     "recompute-persona:prod": "node --max-old-space-size=8192 dist/cli/recompute-persona.cli.js",
     "verify-gap-equivalence": "ts-node --transpile-only src/cli/verify-gap-equivalence.cli.ts",
     "verify-gap-equivalence:prod": "node --max-old-space-size=8192 dist/cli/verify-gap-equivalence.cli.js",

apps/pac-service/prisma/migrations/20261009160000_remove_unused_patient_step_latest/migration.sql

+-- 移除尚无业务使用的治疗步骤汇总；患者原始事实及治疗链不变。
+-- 历史建表迁移保持不变；新库和已部署环境都通过前向迁移收敛。
+-- 限制等锁时间，避免删除派生表时长期阻塞正在处理的请求。
+SET lock_timeout = '5s';
+DROP TABLE IF EXISTS "patient_step_latest";
+RESET lock_timeout;

apps/pac-service/prisma/schema.prisma

@@ -249,8 +249,6 @@ model Patient {
   relationsIn  PatientRelation[]    @relation("PatientRelationsIn")
   /// 诊所回访任务记录(展示用,5 试点;非召回信号)
   returnVisits PatientReturnVisit[]
-  /// 每一步治疗最近一次做的时间(派生,见 PatientStepLatest)
-  stepLatest   PatientStepLatest[]
 
   /// 跨同步 upsert 去重 + 集团内 external_id 撞号消歧(同号不同源 = 不同人,靠 source_unit 分开)
   @@unique([hostId, tenantId, sourceUnit, externalId])
@@ -403,46 +401,6 @@ model PatientRelation {
 /// 性质 = 诊所自己的外呼/回访运营记录(常规/术后/咨询回访),**不是临床 fact,不进召回信号**。
 /// 详情页"回访记录"块按 taskDate 倒序展示,让客服看到诊所已做/已排的回访 → 避免重复外呼 + 上下文。
 /// 独立表(非 transaction/fact):摄入按 organization_id ∈ 5 试点 + customer_id→patient 解析 upsert。
-/// ⭐⭐ **每位患者、每一步治疗，最近一次做的时间** —— 派生表（2026-09-15）。
-///
-/// ═══ 为什么要物化 ═══════════════════════════════════════════════════════════
-///
-/// 周期维护要问「**上次**洁牙在 6 个月前」的人 —— 那是每位患者治疗事实的**最大值**，
-/// 而 step 是按 `treatmentStepsOf`（@pac/types，词根归一）算出来的，⛔ SQL 里做不了
-/// （做了就是第二份词表，改一个词两边就漂）。⇒ 同 `patient_profiles.last_visit_at`:
-///
-/// ```
-/// 存日期不存分档   「6 个月前」在查询时按 now 现算，时间流逝不会让它变错 ⇒ 不需要到期重扫
-/// 画像重算顺路刷新  事实变了 ⇒ 推进事实水位 ⇒ 触发重算 ⇒ 这里跟着刷新（同一趟已经加载了全部事实）
-/// ```
-///
-/// ⚠️ 只收 `kind=actual` 的治疗事实（做过的），⛔ 不收 planned（「计划洁牙」不是洁过牙）。
-/// ⚠️ 改了词表 / 口径之后要跑 `pnpm backfill-step-latest -- --all`，⛔ 别等画像水位自己动
-///   （事实没变，画像重算会被水位闸 noop 掉，这张表就停在旧口径）。
-model PatientStepLatest {
-  patientId String   @map("patient_id") @db.Uuid
-  /// PAC 标准 step key(`professional_cleaning` / `canal_filling` / …)
-  step      String
-  hostId    String   @map("host_id") @db.Uuid
-  tenantId  String   @map("tenant_id")
-  /// 最近一次做这一步的时刻(事实的 occurred_at)
-  lastAt    DateTime @map("last_at") @db.Timestamptz(3)
-  /// 最近那次在哪家诊所做的
-  clinicId  String?  @map("clinic_id")
-  /// 最近那次对应的事实身份(treatment_record 的 subject_id)
-  subjectId String   @map("subject_id")
-
-  createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz(3)
-  updatedAt DateTime @updatedAt @map("updated_at") @db.Timestamptz(3)
-
-  patient Patient @relation(fields: [patientId], references: [id], onDelete: Cascade)
-
-  @@id([patientId, step])
-  /// 开放面「步骤最近一次」:按 step 圈，再按 last_at 取窗口
-  @@index([hostId, tenantId, step, lastAt])
-  @@map("patient_step_latest")
-}
-
 model PatientReturnVisit {
   id             String    @id @default(uuid()) @db.Uuid
   hostId         String    @map("host_id") @db.Uuid

apps/pac-service/src/cli/backfill-step-latest.cli.ts

-/**
- * Backfill Step Latest CLI —— 回填 `patient_step_latest`（每位患者每一步治疗最近一次做的时间）。
- *
- * 🔴 **上线后必须立刻跑一次**:迁移只建了空表，而开放面「步骤最近一次」只查它 ⇒
- *   不跑的话周期维护一个人都查不到。⛔ 别指望画像重算自愈 —— 事实没变的患者会被水位闸 noop 掉，永远补不上。
- * 🔴 **改了 step 词表 / 口径之后也要跑**（`@pac/types` 的 LegacyStepSubtypeKeywords / TreatmentMilestones）:
- *   理由同上，事实没变画像就不重算。
- *
- * ⚠️ 幂等:值没变的患者一行都不写，重复跑安全。
- *
- * Usage:
- *   pnpm backfill-step-latest              # 全量翻一遍，只写有变化的
- *   pnpm backfill-step-latest -- --check   # 只报表里现在有多少，不写库
- */
-import { NestFactory } from '@nestjs/core';
-import { Logger } from '@nestjs/common';
-import { AppModule } from '../app.module';
-import { PrismaService } from '../prisma/prisma.service';
-import { StepLatestService } from '../modules/persona/step-latest.service';
-import { disableSchedulersForCli } from './bootstrap-flags';
-
-async function main(): Promise<void> {
-  const log = new Logger('backfill-step-latest');
-  const checkOnly = process.argv.slice(2).includes('--check');
-
-  // ⚠️ 必须在建应用上下文之前:否则会清掉 service 里正在跑的同步锁(见 bootstrap-flags)
-  disableSchedulersForCli();
-
-  const app = await NestFactory.createApplicationContext(AppModule, { logger: ['error', 'warn', 'log'] });
-  try {
-    const prisma = app.get(PrismaService);
-    const report = async () => {
-      const rows = await prisma.$queryRaw<{ step: string; patients: bigint }[]>`
-        SELECT step, count(*) AS patients FROM patient_step_latest GROUP BY step ORDER BY 2 DESC`;
-      log.log(`patient_step_latest 现状:${rows.map((r) => `${r.step}=${r.patients}`).join(' ') || '空表'}`);
-    };
-    await report();
-    if (checkOnly) return;
-
-    const t0 = Date.now();
-    await app.get(StepLatestService).backfill({
-      onBatch: ({ patients, written }) => log.log(`已翻 ${patients} 位患者,改了 ${written} 位`),
-    });
-    log.log(`耗时 ${((Date.now() - t0) / 1000).toFixed(1)}s`);
-    await report();
-  } finally {
-    await app.close();
-  }
-}
-
-main().catch((e) => {
-  console.error(e);
-  process.exit(1);
-});

apps/pac-service/src/modules/open/open-appointment.service.ts

@@ -28,7 +28,7 @@ export interface OpenAppointment {
  *
  * 越权防线在 `PatientService.getByIds(scope, ids)`,而事实优先的查询天然不在那条路上。
  * ⇒ **先查 fact,再把 patientId 送回两道闸**(越权收窄 + 合规闸),活下来的才出库。
- * ⭐ 两道闸 2026-09-15 收进了 `OpenFactGate` —— 事实窗口、步骤最近一次也走同一份,
+ * ⭐ 两道闸 2026-09-15 收进了 `OpenFactGate` —— 事实窗口也走同一份,
  *   ⛔ 别为了省一次查询改成"直接拿 fact.clinic_id 判范围":那一刻两套判据就并存了。
  *
  * ⚠️ 副作用:**先分页后过滤** ⇒ 一页可能返回少于 limit 条,甚至 0 条,

apps/pac-service/src/modules/open/open-fact-gate.service.ts

@@ -14,9 +14,9 @@ export type OpenPurpose = 'outreach' | 'operations';
  * 患者优先的三个端点，越权防线在 `PatientService.getByIds(scope, ids)`，后面只用它返回的 id。
  * 事实优先的查询**天然不在那条路上**：先有 fact 才有 patient。
  * 最早只有预约窗口一个这样的端点，两道闸就写在 `OpenAppointmentService` 里；
- * 2026-09-15 加了事实窗口和「步骤最近一次」两个，⛔ 抄三份就是三套判据 ——
+ * 增加事实窗口后，⛔ 不要为新端点复制另一套判据 ——
  * 而漂掉的那一侧是**静默**的洞（多给一个别家诊所的人，没有任何东西会报错）。
- * ⇒ 收在这里，三个端点都调它。
+ * ⇒ 收在这里，预约和事实窗口都调它。
  *
  * ```
  * ① 越权收窄   patientId 原样送回 getByIds —— 端点在构造上不可能比患者优先的三个看得更宽

apps/pac-service/src/modules/open/open-fact-window.service.ts

@@ -9,20 +9,8 @@ export interface OpenWindowFact extends OpenFact {
   patientId: string;
 }
 
-/** 「步骤最近一次」里的一位患者 */
-export interface OpenStepLatest {
-  patientId: string;
-  /** 给的几个 step 里，最近做的是哪一个 */
-  step: string;
-  /** 最近那次的时刻（ISO） */
-  lastAt: string;
-  clinicId: string | null;
-  /** 最近那次对应的治疗事实身份 —— 要看详情走 profile */
-  subjectId: string;
-}
-
 /**
- * ⭐⭐ 开放面里**另外两个事实优先的查询**（2026-09-15）:按时间窗取事实、步骤最近一次。
+ * ⭐⭐ 按时间窗取事实的开放查询。
  *
  * ⚠️ 和预约窗口是同一个形状，两道闸、分页契约、脱敏**全部走同一份**:
  *   越权收窄 + 合规闸 → `OpenFactGate`；一条事实怎么出库 → `toOpenFact`。
@@ -108,65 +96,6 @@ export class OpenFactWindowService {
       nextCursor: rows.length === input.limit ? `${last.at.toISOString()}|${last.id}` : null,
     };
   }
-
-  /**
-   * 「给的这几步里，最近一次落在 [from, to) 的患者」。读 `patient_step_latest`（派生表，见 schema 头注）。
-   *
-   * ⚠️ 先按患者取**这几步里最近的那一次**，再看它落不落在窗口里 ——
-   *   ⛔ 不是「窗口里做过这几步的人」（那会把之后又做过的人也捞进来，而周期维护恰恰要排除他们）。
-   */
-  async stepLatest(
-    scope: TenantScopeContext,
-    input: {
-      steps: string[];
-      from: string;
-      to: string;
-      clinicIds?: string[];
-      cursor?: string;
-      limit: number;
-      purpose: OpenPurpose;
-    },
-  ): Promise<{ items: OpenStepLatest[]; nextCursor: string | null }> {
-    const clinics = this.gate.clinicsOf(scope, input.clinicIds);
-    if (clinics && clinics.length === 0) return { items: [], nextCursor: null };
-
-    const cur = parseCursor(input.cursor);
-    const rows = await this.prisma.$queryRaw<
-      { patient_id: string; step: string; last_at: Date; clinic_id: string | null; subject_id: string }[]
-    >`
-      SELECT patient_id, step, last_at, clinic_id, subject_id FROM (
-        SELECT DISTINCT ON (patient_id) patient_id, step, last_at, clinic_id, subject_id
-          FROM patient_step_latest
-         WHERE host_id = ${scope.hostId}::uuid
-           AND tenant_id = ${scope.tenantId}
-           AND step = ANY(${input.steps}::text[])
-         ORDER BY patient_id, last_at DESC, step ASC
-      ) latest
-       WHERE last_at >= ${new Date(input.from)}
-         AND last_at <  ${new Date(input.to)}
-         -- ⚠️ 诊所维卡在**最近那次**做的诊所上:「上次在这家店洗的牙」才归这家店提醒
-         AND (${clinics}::text[] IS NULL OR clinic_id = ANY(${clinics}::text[]))
-         AND (${cur === null}::boolean
-              OR (last_at, patient_id) > (${cur?.at ?? null}::timestamptz, ${cur?.id ?? null}::uuid))
-       ORDER BY last_at ASC, patient_id ASC
-       LIMIT ${input.limit}`;
-    if (rows.length === 0) return { items: [], nextCursor: null };
-
-    const admitted = await this.gate.admit(scope, rows.map((r) => r.patient_id), input.purpose, '步骤最近一次');
-    const last = rows[rows.length - 1]!;
-    return {
-      items: rows
-        .filter((r) => admitted.has(r.patient_id))
-        .map((r) => ({
-          patientId: r.patient_id,
-          step: r.step,
-          lastAt: r.last_at.toISOString(),
-          clinicId: r.clinic_id,
-          subjectId: r.subject_id,
-        })),
-      nextCursor: rows.length === input.limit ? `${last.last_at.toISOString()}|${last.patient_id}` : null,
-    };
-  }
 }
 
 /**

apps/pac-service/src/modules/open/open-patients.controller.ts

@@ -22,8 +22,6 @@ import {
   type OpenAppointmentWindowRequest,
   OpenFactWindowSchema,
   type OpenFactWindowRequest,
-  OpenStepLatestWindowSchema,
-  type OpenStepLatestWindowRequest,
 } from './open-patients.schema';
 
 /**
@@ -268,39 +266,6 @@ export class OpenPatientsController {
     return this.windows.facts(scope.tenant, { types, anchor, from, to, clinicIds, cursor, limit, purpose });
   }
 
-  /**
-   * ⭐⭐ 步骤最近一次 —— 「上次洁牙 / 涂氟落在这段时间里」的患者(2026-09-15)。
-   *
-   * ⚠️ 语义是**每位患者这几步里最近的那一次**落在窗口里,⛔ 不是「窗口里做过这几步」——
-   *   后者会把之后又做过的人也捞进来,而周期维护恰恰要排除他们。
-   * ⚠️ 读派生表 `patient_step_latest`(存日期不存分档,画像重算顺路刷新)。
-   * ⚠️ 两道闸、窗口上限、分页契约同上。
-   */
-  @Post('steps/latest-window')
-  @Public()
-  @HttpCode(200)
-  @ApiOperation({
-    summary: '按「某几步最近一次」的时间窗取患者(HMAC 验签,免登录)',
-    description:
-      'Body:{ host, tenantId, orgScope(必填非空), purpose(必填), steps[1..16](必填,PAC 标准 step key), from, to, clinicIds?, cursor?, limit?≤200 }。' +
-      '返回每位患者在 steps 里**最近一次**落在 [from,to) 的那一步:{ patientId, step, lastAt, clinicId, subjectId }。' +
-      '窗口最长 31 天,按 (lastAt, patientId) 升序 keyset 分页;**必须翻到 nextCursor=null 为止**。' +
-      '⭐ purpose=outreach 时 PAC 过掉不打扰/已故/已归档;clinicIds 卡在最近那次做的诊所上。',
-  })
-  async stepLatestWindow(
-    @Req() req: Request & { rawBody?: Buffer },
-    @Headers('x-pac-timestamp') timestampHeader: string | undefined,
-    @Headers('x-pac-signature') signatureHeader: string | undefined,
-    @Body() body: OpenStepLatestWindowRequest,
-  ) {
-    const scope = await this.authorize(req, timestampHeader, signatureHeader, body, () =>
-      OpenStepLatestWindowSchema.parse(body),
-    );
-    const { steps, from, to, clinicIds, cursor, limit, purpose } = scope.parsed;
-    assertWindow(from, to);
-    return this.windows.stepLatest(scope.tenant, { steps, from, to, clinicIds, cursor, limit, purpose });
-  }
-
   // ───────────────────────────────────────────────────────────────────────────
 
   /**

apps/pac-service/src/modules/open/open-patients.schema.ts

@@ -158,7 +158,7 @@ const Purpose = z
   );
 
 /**
- * ⭐⭐ **按时间窗取预约** —— 只读开放面里**第一个「事实优先」的查询**（2026-09-15 起还有事实窗口、步骤最近一次）。
+ * ⭐⭐ **按时间窗取预约** —— 只读开放面里**第一个「事实优先」的查询**（也提供事实窗口）。
  *
  * ═══ 为什么非要它不可 ═══════════════════════════════════════════════════════
  *
@@ -247,35 +247,3 @@ export const OpenFactWindowSchema = z.object({
 });
 
 export type OpenFactWindowRequest = z.infer<typeof OpenFactWindowSchema>;
-
-/**
- * ⭐⭐ **「某几步最近一次做的时间落在窗口里」的患者** —— 周期维护（洁牙、涂氟）要的人群查询（2026-09-15）。
- *
- * ═══ 为什么不能拿事实窗口拼 ═══════════════════════════════════════════════
- *
- * 「上次洁牙在 6 个月前」是**每位患者的最近一次**，⛔ 不是「6 个月前那天有人洁过牙」——
- * 后者会把这之后又来洁过牙的人也捞进来。要回答前者就得对全部治疗事实按患者取最大值，
- * 而 step 是词根归一出来的，⛔ SQL 里做不了（做了就是第二份词表）。
- * ⇒ 物化成 `patient_step_latest`（同「上次到诊日期」:存日期不存分档，画像重算顺路刷新），这里只查它。
- *
- * ⚠️ 语义:给了几个 step，取**这几个里最近的那一次**（`professional_cleaning` 和 `supragingival_scaling`
- *   都是洁牙，按任一算）。⚠️ 两道闸、31 天窗口上限、翻到 nextCursor=null —— 同事实窗口。
- * ⚠️ 只回 patientId + 最近那次的 step / 时间 / 诊所 / 事实身份。要不要排除「已有预约」
- *   是调用方的业务规则，⛔ 不在这里加参数（那一刻就在给某个场景定制了）。
- */
-export const OpenStepLatestWindowSchema = z.object({
-  host: HostName,
-  tenantId: z.string().min(1).describe('集团 id'),
-  orgScope: OrgScope,
-  purpose: Purpose,
-  /** PAC 标准 step key。⛔ PAC 不校验取值（同 factTypes 的理由） */
-  steps: z.array(z.string().min(1)).min(1).max(16).describe('PAC 标准 step key,如 professional_cleaning'),
-  from: z.string().datetime({ offset: true }).describe('最近一次落在 [from,to) 里,ISO8601 带时区'),
-  to: z.string().datetime({ offset: true }),
-  /** 只要最近那次在这几家诊所做的。⚠️ 再收窄，⛔ 不是放宽 */
-  clinicIds: z.array(z.string().min(1)).max(50).optional(),
-  cursor: z.string().max(160).optional(),
-  limit: z.number().int().min(1).max(200).optional().default(100),
-});
-
-export type OpenStepLatestWindowRequest = z.infer<typeof OpenStepLatestWindowSchema>;

apps/pac-service/src/modules/persona/persona.module.ts

@@ -2,7 +2,6 @@ import { Module } from '@nestjs/common';
 import { PersonaController } from './persona.controller';
 import { PersonaService } from './persona.service';
 import { PersonaCoverageMonitorService } from './persona-coverage-monitor.service';
-import { StepLatestService } from './step-latest.service';
 import { FeatureRegistry, FEATURE_EXTRACTOR_PROVIDERS } from './features/feature.registry';
 import { ClinicalGapModule } from '../clinical-gap/clinical-gap.module';
 
@@ -12,12 +11,10 @@ import { ClinicalGapModule } from '../clinical-gap/clinical-gap.module';
   providers: [
     PersonaService,
     PersonaCoverageMonitorService,
-    // ⭐ patient_step_latest —— 画像重算顺路刷新，回填 CLI 也用它（见 step-latest.service.ts）
-    StepLatestService,
     FeatureRegistry,
     // extractor 清单收在 feature.registry.ts(与 FeatureRegistry 构造参数同一份,免两边漏改)
     ...FEATURE_EXTRACTOR_PROVIDERS,
   ],
-  exports: [PersonaService, StepLatestService],
+  exports: [PersonaService],
 })
 export class PersonaModule {}

apps/pac-service/src/modules/persona/persona.service.ts

@@ -8,7 +8,6 @@ import { FeatureRegistry } from './features/feature.registry';
 import { visitFactsOf, visitSpanOf } from './features/visit-facts';
 import { PotentialTreatmentSelector } from '../clinical-gap/potential-treatment.selector';
 import { personaWriteVerdict, type StoredPersonaFeature } from './persona-diff';
-import { StepLatestService } from './step-latest.service';
 import type {
   ActiveFact,
   FeatureExtractorContext,
@@ -53,7 +52,6 @@ export class PersonaService {
     private readonly prisma: PrismaService,
     private readonly registry: FeatureRegistry,
     private readonly gapSelector: PotentialTreatmentSelector,
-    private readonly stepLatest: StepLatestService,
   ) {}
 
   /**
@@ -474,16 +472,6 @@ export class PersonaService {
           `到诊派生字段刷新失败 patient=${patient.id}: ${err instanceof Error ? err.message : err}`,
         ),
       );
-      // ─── 每一步治疗最近一次(**同样不是画像**)—— 同上:借这一趟已加载的事实,失败只告警 ───
-      // 开放面「步骤最近一次」(周期维护:上次洁牙 / 涂氟)读它。见 step-latest.service.ts。
-      await this.stepLatest
-        .refresh(patient, ctx.factsByType.get(FactType.TREATMENT_RECORD) ?? [])
-        .catch((err) =>
-          this.logger.warn(
-            `步骤最近一次刷新失败 patient=${patient.id}: ${err instanceof Error ? err.message : err}`,
-          ),
-        );
-
       // ─── 写入判定(写侧省写)───
       // 闸放宽到 fact 水位之后,「算了但内容没变」会变多(reparse 常常只动了不进画像的字段)。
       // 这里决定:不写 / 就地刷新 / 升版本。三种都要推水位,否则闸永远开着、下次还白算一遍。

apps/pac-service/src/modules/persona/step-latest.service.ts

-import { Injectable, Logger } from '@nestjs/common';
-import { FactType, treatmentStepsOf } from '@pac/types';
-import { PrismaService } from '../../prisma/prisma.service';
-
-/** 算「每一步最近一次」要用的那几列 —— 画像重算加载的 `ActiveFact` 和回填查询都满足它 */
-export interface StepSourceFact {
-  subjectId: string;
-  type: string;
-  kind: string;
-  status: string;
-  occurredAt: Date | null;
-  clinicId: string | null;
-  content: unknown;
-}
-
-export interface StepLatest {
-  step: string;
-  lastAt: Date;
-  clinicId: string | null;
-  subjectId: string;
-}
-
-/**
- * ⭐⭐ `patient_step_latest` 的维护 —— 每位患者、每一步治疗最近一次做的时间。
- *
- * ═══ 两条写入路，同一个算法 ═══════════════════════════════════════════════
- *
- * ```
- * 日常   画像重算顺路刷新（PersonaService.recompute —— 那一趟已经加载了该患者全部事实）
- * 存量   pnpm backfill-step-latest（上线后 / 改了词表之后跑一次）
- * ```
- * ⚠️ 两条路都调 `latestOf` + `write`，⛔ 别在 CLI 里另写一份「最近一次」的判定。
- *
- * ⚠️ step 的口径是 `@pac/types` 的 `treatmentStepsOf`（和治疗链、开放面 `steps` 同一个函数）。
- */
-@Injectable()
-export class StepLatestService {
-  private readonly logger = new Logger(StepLatestService.name);
-
-  constructor(private readonly prisma: PrismaService) {}
-
-  /**
-   * 纯函数:一位患者的事实 → 每一步最近一次。
-   *
-   * ⚠️ 只收**做过的**治疗:`type=treatment_record`、`kind=actual`、`status ∈ {active, fulfilled}`、有发生时间。
-   *   ⛔ 不收 planned —— 「计划洁牙」不是洁过牙，收进来会让周期维护漏掉真正该提醒的人。
-   * ⚠️ 同一时刻两条（同一天同一步两条记录）取 subjectId 大的那条 —— 只为结果稳定可复现，⛔ 没有业务含义。
-   */
-  static latestOf(facts: readonly StepSourceFact[]): StepLatest[] {
-    const best = new Map<string, StepLatest>();
-    for (const f of facts) {
-      if (f.type !== FactType.TREATMENT_RECORD || f.kind !== 'actual' || !f.occurredAt) continue;
-      if (f.status !== 'active' && f.status !== 'fulfilled') continue;
-      for (const step of treatmentStepsOf(f.content)) {
-        const cur = best.get(step);
-        const t = f.occurredAt.getTime();
-        if (
-          !cur ||
-          t > cur.lastAt.getTime() ||
-          (t === cur.lastAt.getTime() && f.subjectId > cur.subjectId)
-        ) {
-          best.set(step, { step, lastAt: f.occurredAt, clinicId: f.clinicId, subjectId: f.subjectId });
-        }
-      }
-    }
-    return [...best.values()].sort((a, b) => a.step.localeCompare(b.step));
-  }
-
-  /**
-   * 把一位患者的「每一步最近一次」写成 `want` 这样。
-   *
-   * ⚠️ **值没变就不写** —— 画像重算是全量遍历，无谓的 UPDATE 会把表的死行堆起来（同 refreshVisitDerivedFields）。
-   * ⚠️ `want` 里没有的 step **要删**:事实被作废 / 改了类目之后，那一步就不该再算做过。
-   * @returns 这一次有没有真的改库
-   */
-  async write(patient: { id: string; hostId: string; tenantId: string }, want: readonly StepLatest[]): Promise<boolean> {
-    const have = await this.prisma.patientStepLatest.findMany({
-      where: { patientId: patient.id },
-      select: { step: true, lastAt: true, clinicId: true, subjectId: true },
-    });
-    const key = (x: StepLatest) => `${x.step}|${x.lastAt.getTime()}|${x.clinicId ?? ''}|${x.subjectId}`;
-    const haveKeys = new Set(have.map(key));
-    const wantSteps = new Set(want.map((w) => w.step));
-    const changed = want.filter((w) => !haveKeys.has(key(w)));
-    const gone = have.filter((h) => !wantSteps.has(h.step)).map((h) => h.step);
-    if (changed.length === 0 && gone.length === 0) return false;
-
-    await this.prisma.$transaction(async (tx) => {
-      if (gone.length) {
-        await tx.patientStepLatest.deleteMany({ where: { patientId: patient.id, step: { in: gone } } });
-      }
-      for (const w of changed) {
-        const data = { lastAt: w.lastAt, clinicId: w.clinicId, subjectId: w.subjectId };
-        await tx.patientStepLatest.upsert({
-          where: { patientId_step: { patientId: patient.id, step: w.step } },
-          update: data,
-          create: { patientId: patient.id, step: w.step, hostId: patient.hostId, tenantId: patient.tenantId, ...data },
-        });
-      }
-    });
-    return true;
-  }
-
-  /** 画像重算那条路:事实已经在手上 */
-  async refresh(patient: { id: string; hostId: string; tenantId: string }, facts: readonly StepSourceFact[]): Promise<boolean> {
-    return this.write(patient, StepLatestService.latestOf(facts));
-  }
-
-  /**
-   * 存量回填 —— 按患者 id keyset 翻，一批一批算、一位一位写。
-   *
-   * ⚠️ 只翻「有做过的治疗事实」的患者。一条都没有的患者本来就不该有行；
-   *   曾经有、后来事实全被作废的，由画像重算那条路删（`want` 为空 ⇒ 全删）。
-   * @param onBatch 每批结束报一次进度（CLI 打日志用）
-   */
-  async backfill(
-    opts: { batchSize?: number; onBatch?: (p: { patients: number; written: number }) => void } = {},
-  ): Promise<{ patients: number; written: number }> {
-    const batchSize = opts.batchSize ?? 500;
-    let cursor = '00000000-0000-0000-0000-000000000000';
-    let patients = 0;
-    let written = 0;
-    for (;;) {
-      const ids = await this.prisma.$queryRaw<{ patient_id: string }[]>`
-        SELECT DISTINCT patient_id FROM patient_facts
-         WHERE type = 'treatment_record' AND kind = 'actual'
-           AND status IN ('active', 'fulfilled')
-           AND occurred_at IS NOT NULL
-           AND patient_id > ${cursor}::uuid
-         ORDER BY patient_id
-         LIMIT ${batchSize}`;
-      if (ids.length === 0) break;
-      const facts = await this.prisma.patientFact.findMany({
-        where: {
-          patientId: { in: ids.map((r) => r.patient_id) },
-          type: FactType.TREATMENT_RECORD,
-          kind: 'actual',
-          status: { in: ['active', 'fulfilled'] },
-        },
-        select: {
-          patientId: true, hostId: true, tenantId: true,
-          subjectId: true, type: true, kind: true, status: true, occurredAt: true, clinicId: true, content: true,
-        },
-      });
-      const byPatient = new Map<string, typeof facts>();
-      for (const f of facts) byPatient.set(f.patientId, [...(byPatient.get(f.patientId) ?? []), f]);
-      for (const [patientId, list] of byPatient) {
-        const first = list[0]!;
-        if (await this.refresh({ id: patientId, hostId: first.hostId, tenantId: first.tenantId }, list)) written += 1;
-      }
-      patients += ids.length;
-      cursor = ids[ids.length - 1]!.patient_id;
-      opts.onBatch?.({ patients, written });
-    }
-    this.logger.log(`patient_step_latest 回填完成:翻了 ${patients} 位患者,改了 ${written} 位`);
-    return { patients, written };
-  }
-}

apps/pac-service/src/modules/plan/engine/chain-composer.service.ts

@@ -912,7 +912,7 @@ function matchMilestoneSteps(
   }
   const matched: string[] = [];
   for (const step of milestone.steps) {
-    // ⭐ 单条判定收在 @pac/types 的 treatmentStepMatch —— 开放面的 steps、patient_step_latest 用同一个函数,
+    // ⭐ 单条判定收在 @pac/types 的 treatmentStepMatch —— 开放面的 steps 用同一个函数,
     //   ⛔ 别在这里再写一份词根（改一处就会「链上显示做过、按步骤查人却查不到」）。
     // ① 优先 treat_stages 精确匹配(PAC 标准 enum)
     // ② fallback:host 没填 stages → LegacyStepSubtypeKeywords 词根匹配 subtype

apps/pac-service/tests/open-appointment-purpose.spec.ts

@@ -25,7 +25,7 @@ describe('事实优先端点的 purpose —— 合规闸归 PAC', () => {
   const schema = strip(read('src/modules/open/open-patients.schema.ts'));
   /**
    * ⭐ 2026-09-15:两道闸从 `OpenAppointmentService` 收进 `OpenFactGate`，
-   *   预约窗口、事实窗口、步骤最近一次三个端点共用 —— 这里守的是**那一份**，外加「三个都真的调了它」。
+   *   预约窗口、事实窗口两个端点共用 —— 这里守的是**那一份**，外加「两个都真的调了它」。
    */
   const gate = strip(read('src/modules/open/open-fact-gate.service.ts'));
   const appointment = strip(read('src/modules/open/open-appointment.service.ts'));
@@ -33,8 +33,8 @@ describe('事实优先端点的 purpose —— 合规闸归 PAC', () => {
 
   it('⭐ purpose 是必填的两档枚举，而且只定义一次', () => {
     expect(schema).toMatch(/const Purpose = z\s*\.enum\(\[\s*'outreach',\s*'operations'\s*\]\)/);
-    // 三个事实优先的 schema 都用这一份
-    expect(schema.match(/purpose: Purpose,/g)?.length).toBe(3);
+    // 两个事实优先的 schema 都用这一份
+    expect(schema.match(/purpose: Purpose,/g)?.length).toBe(2);
     expect(schema).not.toMatch(/purpose:\s*z\./);
   });
 
@@ -80,11 +80,11 @@ describe('事实优先端点的 purpose —— 合规闸归 PAC', () => {
   });
 
   /**
-   * ⭐⭐ 三个端点都必须过同一道闸 —— ⛔ 谁都不许自己判范围、自己查 do_not_contact。
+   * ⭐⭐ 两个端点都必须过同一道闸 —— ⛔ 谁都不许自己判范围、自己查 do_not_contact。
    */
-  it('⭐⭐ 事实优先的三个端点都走 OpenFactGate，⛔ 不各写一份', () => {
+  it('⭐⭐ 事实优先的两个端点都走 OpenFactGate，⛔ 不各写一份', () => {
     expect(appointment.match(/this\.gate\.admit\(/g)?.length).toBe(1);
-    expect(windows.match(/this\.gate\.admit\(/g)?.length).toBe(2);
+    expect(windows.match(/this\.gate\.admit\(/g)?.length).toBe(1);
     for (const src of [appointment, windows]) {
       expect(src).not.toMatch(/getByIds|do_not_contact|deceased/);
       // 诊所交集同一份；交集为空直接回空
@@ -100,7 +100,7 @@ describe('事实优先端点的 purpose —— 合规闸归 PAC', () => {
   it('⭐ 游标仍然跟过滤前的最后一条 —— 加闸不改分页契约', () => {
     expect(appointment).toMatch(/const last = rows\[rows\.length - 1\]/);
     expect(appointment).toMatch(/nextCursor:\s*rows\.length === input\.limit/);
-    expect(windows.match(/const last = rows\[rows\.length - 1\]/g)?.length).toBe(2);
-    expect(windows.match(/nextCursor: rows\.length === input\.limit/g)?.length).toBe(2);
+    expect(windows.match(/const last = rows\[rows\.length - 1\]/g)?.length).toBe(1);
+    expect(windows.match(/nextCursor: rows\.length === input\.limit/g)?.length).toBe(1);
   });
 });

apps/pac-service/tests/open-fact-window.spec.ts

 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { treatmentStepsOf, treatmentStepMatch } from '@pac/types';
-import { OpenFactWindowSchema, OpenStepLatestWindowSchema, OpenAppointmentWindowSchema } from '../src/modules/open/open-patients.schema';
+import { OpenFactWindowSchema, OpenAppointmentWindowSchema } from '../src/modules/open/open-patients.schema';
 import { toOpenFact } from '../src/modules/open/open-fact';
-import { StepLatestService, type StepSourceFact } from '../src/modules/persona/step-latest.service';
 
 /**
- * ⭐⭐ 开放面 2026-09-15 扩的三件事:按时间窗取事实 / 治疗事实带 steps / 步骤最近一次。
+ * ⭐⭐ 开放面 2026-09-15 按时间窗取事实 / 治疗事实带 steps。
  *
- * ⚠️ 场景来自 friday-ai 的待办调研:诊后随访要「昨天给谁做了治疗」，周期维护要「上次洁牙在 N 个月前」。
+ * ⚠️ 场景来自 friday-ai 的待办调研:诊后随访要「昨天给谁做了治疗」。
  * ⚠️ 词根样本全部照本地库真实的 treatment_record 抄（category / subtype 实测取值），⛔ 不是凭想象造的。
  */
 
@@ -29,7 +28,6 @@ describe('契约 —— 没有安全默认值的字段就不给默认值', () =>
   test('⭐ host 必填(验签按它找钥匙,见 HmacVerifier.verifyRead)', () => {
     const { host: _host, ...noHost } = base;
     expect(() => OpenFactWindowSchema.parse({ ...noHost, types: ['treatment_record'], anchor: 'occurred' })).toThrow();
-    expect(() => OpenStepLatestWindowSchema.parse({ ...noHost, steps: ['professional_cleaning'] })).toThrow();
   });
 
   test('⭐ 事实窗口:types 必填且非空，anchor 必填（occurred / planned），purpose 必填', () => {
@@ -44,24 +42,7 @@ describe('契约 —— 没有安全默认值的字段就不给默认值', () =>
     expect(() => OpenFactWindowSchema.parse({ ...base, orgScope: [], types: ['treatment_record'], anchor: 'occurred' })).toThrow();
   });
 
-  test('⭐ 步骤最近一次:steps 必填且非空，purpose 必填；PAC ⛔ 不校验 step 取值（加新 step 不让老调用方 400）', () => {
-    expect(OpenStepLatestWindowSchema.parse({ ...base, steps: ['professional_cleaning', 'a_step_from_the_future'] }).steps).toHaveLength(2);
-    expect(() => OpenStepLatestWindowSchema.parse({ ...base, steps: [] })).toThrow();
-    const { purpose: _p, ...noPurpose } = base;
-    expect(() => OpenStepLatestWindowSchema.parse({ ...noPurpose, steps: ['professional_cleaning'] })).toThrow();
-  });
 
-  test('⚠️ 预约窗口的请求形状只多了 host（2026-09-21 读方改按宿主授权，调用方 friday-ai 同批改）', () => {
-    expect(Object.keys(OpenAppointmentWindowSchema.shape).sort()).toEqual(
-      ['clinicIds', 'cursor', 'from', 'host', 'limit', 'orgScope', 'purpose', 'tenantId', 'to'].sort(),
-    );
-  });
-
-  test('⭐⭐ 三个事实优先的端点都过 31 天窗口上限（同一个 assertWindow）', () => {
-    const ctl = strip(read('src/modules/open/open-patients.controller.ts'));
-    expect(ctl.match(/assertWindow\(from, to\);/g)?.length).toBe(3);
-    expect(ctl).toMatch(/span > 31 \* 24 \* 3600_000/);
-  });
 });
 
 describe('steps —— 跨宿主临床归一（单条口径）', () => {
@@ -126,62 +107,3 @@ describe('steps —— 跨宿主临床归一（单条口径）', () => {
     expect(strip(read('src/modules/open/open-fact-window.service.ts'))).toMatch(/\.\.\.toOpenFact\(r\)/);
   });
 });
-
-describe('步骤最近一次 —— 派生表的算法和查询语义', () => {
-  const fact = (over: Partial<StepSourceFact>): StepSourceFact => ({
-    subjectId: 'treatment_record:1',
-    type: 'treatment_record',
-    kind: 'actual',
-    status: 'fulfilled',
-    occurredAt: new Date('2025-06-01T02:00:00Z'),
-    clinicId: 'c1',
-    content: { category: 'periodontic', subtype: '洁牙' },
-    ...over,
-  });
-
-  test('⭐⭐ 每一步取最近一次；planned ⛔ 不算做过；作废的 ⛔ 不算；别的类型 ⛔ 不算', () => {
-    const got = StepLatestService.latestOf([
-      fact({ subjectId: 'treatment_record:old', occurredAt: new Date('2024-01-01T02:00:00Z') }),
-      fact({ subjectId: 'treatment_record:new', occurredAt: new Date('2025-06-01T02:00:00Z'), clinicId: 'c2' }),
-      // 「计划洁牙」—— ⛔ 不是洁过牙
-      fact({ subjectId: 'treatment_record:plan', kind: 'planned', occurredAt: new Date('2026-01-01T02:00:00Z') }),
-      fact({ subjectId: 'treatment_record:void', status: 'invalidated', occurredAt: new Date('2026-02-01T02:00:00Z') }),
-      fact({ subjectId: 'encounter_record:x', type: 'encounter_record', occurredAt: new Date('2026-03-01T02:00:00Z') }),
-      fact({ subjectId: 'treatment_record:f', content: { category: 'preventive', subtype: 'OHI,涂氟' }, occurredAt: new Date('2025-03-01T02:00:00Z') }),
-      fact({ subjectId: 'treatment_record:noTime', occurredAt: null }),
-    ]);
-    expect(got).toEqual([
-      { step: 'fluoride_application', lastAt: new Date('2025-03-01T02:00:00Z'), clinicId: 'c1', subjectId: 'treatment_record:f' },
-      { step: 'supragingival_scaling', lastAt: new Date('2025-06-01T02:00:00Z'), clinicId: 'c2', subjectId: 'treatment_record:new' },
-    ]);
-  });
-
-  test('⚠️ 同一时刻两条 ⇒ 结果稳定（取 subjectId 大的），⛔ 不随输入顺序变', () => {
-    const at = new Date('2025-06-01T02:00:00Z');
-    const a = fact({ subjectId: 'treatment_record:a', occurredAt: at });
-    const b = fact({ subjectId: 'treatment_record:b', occurredAt: at });
-    expect(StepLatestService.latestOf([a, b])[0]!.subjectId).toBe('treatment_record:b');
-    expect(StepLatestService.latestOf([b, a])[0]!.subjectId).toBe('treatment_record:b');
-  });
-
-  /**
-   * ⭐⭐⭐ 查询语义:**先按患者取这几步里最近的一次，再看它落不落在窗口里**。
-   * ⛔ 反过来（先按窗口圈、再按患者去重）会把「6 个月前洗过、上周又洗过」的人也捞进来 ——
-   *   周期维护恰恰要排除他们。按源码守:窗口条件必须在 DISTINCT ON 子查询**外面**。
-   */
-  test('⭐⭐⭐ 窗口条件在「最近一次」子查询外面', () => {
-    const svc = strip(read('src/modules/open/open-fact-window.service.ts'));
-    const seg = svc.slice(svc.indexOf('FROM patient_step_latest'));
-    const inner = seg.indexOf(') latest');
-    expect(inner).toBeGreaterThan(0);
-    expect(seg.indexOf('last_at >=')).toBeGreaterThan(inner);
-    expect(seg.slice(0, inner)).toMatch(/ORDER BY patient_id, last_at DESC/);
-  });
-
-  test('⭐ 画像重算顺路刷新 + 回填 CLI 用同一个算法', () => {
-    const persona = strip(read('src/modules/persona/persona.service.ts'));
-    expect(persona).toMatch(/this\.stepLatest\s*\.refresh\(patient, ctx\.factsByType\.get\(FactType\.TREATMENT_RECORD\) \?\? \[\]\)/);
-    const cli = strip(read('src/cli/backfill-step-latest.cli.ts'));
-    expect(cli).toMatch(/app\.get\(StepLatestService\)\.backfill\(/);
-  });
-});

apps/pac-service/tests/persona-watermark.spec.ts

 import { Test } from '@nestjs/testing';
-import { StepLatestService } from '../src/modules/persona/step-latest.service';
 import { PersonaService } from '../src/modules/persona/persona.service';
 import { PrismaService } from '../src/prisma/prisma.service';
 import { FeatureRegistry } from '../src/modules/persona/features/feature.registry';
@@ -163,8 +162,6 @@ async function build(o: Opts) {
       { provide: PrismaService, useValue: prisma },
       { provide: FeatureRegistry, useValue: stubRegistry(o.draft === undefined ? RFM() : o.draft) },
       { provide: PotentialTreatmentSelector, useValue: { selectForPatient: jest.fn().mockResolvedValue([]) } },
-      // patient_step_latest 顺路刷新 —— 与水位闸无关，这里只占位
-      { provide: StepLatestService, useValue: { refresh: jest.fn().mockResolvedValue(false) } },
     ],
   }).compile();
   return { svc: mod.get(PersonaService), calls, prisma };

docs/friday-ai-test-deployment.md

@@ -22,11 +22,7 @@
 
 本地调试账号由测试中转配置，日常 AI 发布不修改账号归属、不重启中转。已有 `.env` 和私钥继续使用，不用示例覆盖，也不重新生成密钥。
 
-首次发布 PAC 步骤查询接口、或后续调整治疗步骤口径时，PAC 发布后还须执行一次步骤汇总表 `patient_step_latest` 的回填并等待完成；日常 AI 升级跳过：
-
-```sh
-docker exec pac-pac-service-1 node dist/cli/backfill-step-latest.cli.js
-```
+2026-10-09 移除未启用的治疗步骤汇总能力：执行迁移后删除 `patient_step_latest`，无需回填。既有环境升级前备份该派生表，完成镜像构建后停止旧 PAC 后端，再执行迁移并启动新版；患者事实、画像和预约数据保留。历史建表迁移不修改。
 
 ## 2. 更新代码、准备私钥
 

packages/pac-client/src/client.spec.ts

@@ -116,27 +116,23 @@ describe('PacClient | orgScope 护栏', () => {
   });
 });
 
-describe('PacClient | 事实窗口 / 步骤最近一次（2026-09-15）', () => {
+describe('PacClient | 事实窗口（2026-09-15）', () => {
   const base = { host: 'jvs-dw', tenantId: 'ruier-grp', orgScope: ['clinic-1'], purpose: 'outreach' as const, from: '2026-06-23T00:00:00+08:00', to: '2026-06-24T00:00:00+08:00' };
 
   test('⭐ 打到对的路径，请求体原样发出（purpose / anchor / types 都带上）', async () => {
     const { impl, captured } = fakeFetch(ok({ items: [], nextCursor: null }));
     const c = make(impl);
     await c.getFactWindow({ ...base, types: ['treatment_record'], anchor: 'occurred' });
-    await c.getStepLatestWindow({ ...base, steps: ['professional_cleaning', 'supragingival_scaling'] });
     expect(captured.map((x) => x.url)).toEqual([
       'http://pac.test/pac/v1/open/patients/facts/window',
-      'http://pac.test/pac/v1/open/patients/steps/latest-window',
     ]);
     expect(JSON.parse(captured[0]!.body)).toMatchObject({ purpose: 'outreach', anchor: 'occurred', types: ['treatment_record'] });
-    expect(JSON.parse(captured[1]!.body)).toMatchObject({ steps: ['professional_cleaning', 'supragingival_scaling'] });
   });
 
-  test('⛔ 空 orgScope 两个都挡，不发请求', async () => {
+  test('⛔ 空 orgScope 挡住，不发请求', async () => {
     const { impl, captured } = fakeFetch(ok({ items: [], nextCursor: null }));
     const c = make(impl);
     await expect(c.getFactWindow({ ...base, orgScope: [], types: ['treatment_record'], anchor: 'occurred' })).rejects.toThrow(/orgScope 不能为空/);
-    await expect(c.getStepLatestWindow({ ...base, orgScope: [], steps: ['professional_cleaning'] })).rejects.toThrow(/orgScope 不能为空/);
     expect(captured).toHaveLength(0);
   });
 });

packages/pac-client/src/client.ts

@@ -11,8 +11,6 @@ import {
   type PacAppointmentWindowResponse,
   type PacFactWindowRequest,
   type PacFactWindowResponse,
-  type PacStepLatestWindowRequest,
-  type PacStepLatestWindowResponse,
   type PacOrgNode,
   type PacOrgNodesRequest,
 } from './types';
@@ -155,15 +153,6 @@ export class PacClient {
   }
 
   /**
-   * ⭐⭐ 「某几步最近一次落在窗口里」的患者(周期维护:上次洁牙 / 涂氟在 N 个月前)。
-   * ⚠️⚠️ **必须翻到 `nextCursor` 为 null 为止**,理由同 `getAppointmentWindow`。
-   */
-  async getStepLatestWindow(req: PacStepLatestWindowRequest): Promise<PacStepLatestWindowResponse> {
-    this.assertCoordinates(req);
-    return this.post<PacStepLatestWindowResponse>('/open/patients/steps/latest-window', req);
-  }
-
-  /**
    * ⭐ 这个集团在 PAC 里有哪些组织节点（集团 / 品牌 / 诊所）—— 管理员把自己的门店**对应**到 PAC 用。
    * ⚠️ 只有结构和名字，⛔ 没有患者数据，所以也没有 orgScope。
    */

packages/pac-client/src/index.ts

@@ -24,9 +24,6 @@ export {
   type PacFactWindowRequest,
   type PacFactWindowResponse,
   type PacWindowFact,
-  type PacStepLatestWindowRequest,
-  type PacStepLatestWindowResponse,
-  type PacStepLatest,
   type PacOrgNode,
   type PacOrgNodesRequest,
 } from './types';

packages/pac-client/src/types.ts

@@ -341,48 +341,6 @@ export interface PacFactWindowResponse {
   nextCursor: string | null;
 }
 
-/**
- * ⭐⭐ 「某几步最近一次落在窗口里」的患者 —— 周期维护(上次洁牙 / 涂氟在 N 个月前)。
- *
- * ⚠️⚠️ 语义是**每位患者在这几步里最近的那一次**落在 [from, to),
- *   ⛔ 不是「窗口里做过这几步」—— 后者会把之后又做过的人也捞进来。
- * ⚠️ 给几个 step 就按这几个里最近的算(洁牙在牙周类和预防类记法不同:
- *   `supragingival_scaling` 和 `professional_cleaning` 要一起传)。
- * ⚠️ 窗口最长 31 天;**必须翻到 `nextCursor` 为 null 为止**。
- * ⚠️ 要不要排除「已经有预约」是调用方自己的业务规则,PAC ⛔ 不管。
- */
-export interface PacStepLatestWindowRequest {
-  /** 宿主名,见 {@link PacSearchRequest.host} */
-  host: string;
-  tenantId: string;
-  orgScope: string[];
-  purpose: 'outreach' | 'operations';
-  /** PAC 标准 step key,1..16 个 */
-  steps: string[];
-  from: string;
-  to: string;
-  /** 只要最近那次在这几家诊所做的。⚠️ 再收窄,⛔ 不是放宽 */
-  clinicIds?: string[];
-  cursor?: string;
-  limit?: number;
-}
-
-export interface PacStepLatest {
-  patientId: string;
-  /** 给的几个 step 里,最近做的是哪一个 */
-  step: string;
-  /** 最近那次的时刻(ISO) */
-  lastAt: string;
-  clinicId: string | null;
-  /** 最近那次的治疗事实身份 —— 要看详情走 profile */
-  subjectId: string;
-}
-
-export interface PacStepLatestWindowResponse {
-  items: PacStepLatest[];
-  nextCursor: string | null;
-}
-
 /** `listOrgNodes` 的请求 —— ⚠️ 没有 orgScope:这里问的是结构，⛔ 不读患者 */
 export interface PacOrgNodesRequest {
   /** 宿主名，见 {@link PacSearchRequest.host} */

packages/types/src/canonical-codes.ts

@@ -1018,9 +1018,9 @@ export function lookupTreatmentMilestone(
  * ═══ 为什么放在这里 ═══════════════════════════════════════════════════════════
  *
  * 规则原来只长在 chain-composer 的 `matchMilestoneSteps` 里（给治疗链详情页用）。
- * 开放面要把 step 带给系统调用方、`patient_step_latest` 要按它物化 ——
- * 三处各写一份，改一个关键词就会出现「链上显示做过洁牙、按洁牙查人却查不到」。
- * ⇒ 单条判定收在这一个函数，三处都调它。
+ * 开放面也要把 step 带给系统调用方 ——
+ * 两处各写一份，改一个关键词就会出现「链上显示做过洁牙、按洁牙查人却查不到」。
+ * ⇒ 单条判定收在这一个函数，两处都调它。
  *
  * ═══ 口径（逐字等于 chain-composer 的两级匹配）═══════════════════════════════
  *