@tbox.cn/app-toolkit 0.3.0 → 0.4.0

package/src/assembly/walk-manifests.ts

@@ -15,9 +15,15 @@ import { readAppManifestFull, type NpmModuleEntry, type AppManifestFull } from '
  *   3. serviceSchemas：per-service schema 复合键表——键 `${provider}\u0000${service}`（H2，同一服务
  *      多厂商供给各自 schema 零碰撞）；多 impl 同 (provider, service) 异 schema → 声明序首个
  *   4. vocabulary：所有携带 service-slots.json 的已装契约包该文件 `.slots` 键并集（fs 直读、
- *      `$comment` 忽略；探测链 = readdir(<候选>/node_modules/@tbox.cn) 过滤携带该文件的包——
- *      零缓存枚举，与 manifest 探测同机制；多行业 contracts-* 天然扩展 F8）；缺席 → []（退化 demanded ∪ configured）
- *   5. domainKeyIssues：跨模块域键冲突 issue（两模块派生同一 domains 键——P13）
+ *      `$comment` 忽略；探测三跳 = ① <候选>/node_modules/@tbox.cn/<pkg>/service-slots.json（包根）
+ *      ② 同包 src/service-slots.json（发布包 src 附带 / 模板 shim 链接）
+ *      ③ 候选自身 {service-slots.json, src/service-slots.json}（local/codegen 全量副本——
+ *      mall 生成应用主形态，不依赖 install）；零缓存枚举，与 manifest 探测同机制；
+ *      多行业 contracts-* 天然扩展 F8）；缺席 → []（退化 demanded ∪ configured）
+ *   5. slotMeta：词汇 meta 节（per-service {title,description} 展示元数据——消费端兜底链
+ *      词汇 > demand > id，views/context resolveServiceDisplay 单源）；多包发现序首声明胜出
+ *      （与 catalog addSlots 同语义）；contracts-mall 词汇锁保证 mall 域全量覆盖；缺席 → {}
+ *   6. domainKeyIssues：跨模块域键冲突 issue（两模块派生同一 domains 键——P13）
  *
  * **约束（D26；FX-3/F7 边界）**：目录枚举零缓存——readdir / node_modules 候选探测 / `.tbox/app.json` 读取 /
  * dev-manifest 读取每次执行（枚举输入保持 fresh——agent 装卸模块下一笔即见）；manifest/service-slots
@@ -35,10 +41,48 @@ export interface WalkManifestsResult {
   serviceSchemas: Record<string, { configSchema?: string; credentialSchema?: string; packageDir: string }>;
   /** 服务词汇 = 所有携带 service-slots.json 的已装契约包 `.slots` 键并集（缺席 → []） */
   vocabulary: string[];
+  /** 词汇 meta 节：per-service {title,description} 展示元数据（多包首声明胜出；缺席 → {}） */
+  slotMeta: Record<string, SlotMeta>;
   /** 跨模块域键冲突（P13——两模块的 service 集派生同一 domains 键） */
   domainKeyIssues: Array<{ severity: 'warning'; code: 'DOMAIN_KEY_CONFLICT'; message: string; module?: string }>;
 }
 
+/** 槽位展示元数据（service-slots.json meta 节元素——宽松提取，字段皆可选） */
+export interface SlotMeta {
+  title?: string;
+  description?: string;
+}
+
+/** 词汇文件单次解析产物（slots 与 meta 同源同读——防双读漂移） */
+interface SlotsFile {
+  slots: string[];
+  meta: Record<string, SlotMeta>;
+}
+
+/** 词汇文件解析（宽松：坏文件/缺 slots 数组 → null；meta 非对象条目/无有效字段跳过） */
+function parseSlotsFile(raw: string): SlotsFile | null {
+  try {
+    const parsed = JSON.parse(raw) as { slots?: unknown; meta?: unknown };
+    if (!Array.isArray(parsed.slots)) return null;
+    const slots = parsed.slots.filter((s): s is string => typeof s === 'string');
+    const meta: Record<string, SlotMeta> = {};
+    if (parsed.meta && typeof parsed.meta === 'object' && !Array.isArray(parsed.meta)) {
+      for (const [svc, entry] of Object.entries(parsed.meta as Record<string, unknown>)) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) continue;
+        const { title, description } = entry as { title?: unknown; description?: unknown };
+        const m: SlotMeta = {};
+        if (typeof title === 'string' && title.length > 0) m.title = title;
+        if (typeof description === 'string' && description.length > 0) m.description = description;
+        if (m.title !== undefined || m.description !== undefined) meta[svc] = m;
+      }
+    }
+    return { slots, meta };
+  } catch {
+    /* 宽松：坏文件跳过 */
+    return null;
+  }
+}
+
 export interface WalkModuleInfo {
   /** install id（packages/ 目录名 / npmModules entry.id） */
   id: string;
@@ -49,12 +93,17 @@ export interface WalkModuleInfo {
   descriptor: ModuleDescriptor;
 }
 
-/** 富形态供给条目：per-service {implementation, credentialType} 恒数组保真（H1） */
+/** 富形态供给条目：per-service {implementation, credentialType} 恒数组保真（H1）；
+ *  title/description = 厂商展示元数据（strict manifest descriptor 透传——多包同厂商
+ *  首声明胜出，与 owner 同语义；B1 walk 层传播） */
 export interface WalkProviderEntry {
   provider: string;
   implementation: string;
   credentialType: string;
   owner: string;
+  /** 厂商展示名（manifest 模块 meta——多包首声明；缺席 = undefined） */
+  title?: string;
+  description?: string;
   local?: boolean;
   configSchema?: string;
   credentialSchema?: string;
@@ -174,10 +223,15 @@ function readDevManifestRedirects(appDir: string): DevManifestRedirect[] {
   }
 }
 
-/** 契约包发现链：readdir(node_modules/@tbox.cn) 过滤携带 service-slots.json 的包（目录枚举零缓存，F8；
- *  FX-3：slots 文件**内容**经 file-cache） */
-function discoverContractPackages(appDir: string, cache?: FileCache): Array<{ dir: string; slots: string[] }> {
-  const found: Array<{ dir: string; slots: string[] }> = [];
+/** 契约包发现链（探测三跳——词汇源真实布局全覆盖，B0）：候选集（appDir、apps/*、packages/*）×
+ *  ① node_modules/@tbox.cn/<pkg>/service-slots.json（包根——夹具/旧布局）
+ *  ② 同包 src/service-slots.json（发布包 src 随 files 附带 / 模板 shim 链接到仓库源 src/）
+ *  ③ 候选自身 {service-slots.json, src/service-slots.json}（local/codegen 全量副本——mall 生成应用
+ *     主形态，stage rewriteExportsToSrc 展开后永驻 packages/*，不依赖 install）
+ *  同包双在场（异常态）root 优先。slots 与 meta 单次解析同产（目录枚举零缓存，F8；
+ *  FX-3：文件**内容**经 file-cache）。 */
+function discoverContractPackages(appDir: string, cache?: FileCache): Array<{ dir: string; slots: string[]; meta: Record<string, SlotMeta> }> {
+  const found: Array<{ dir: string; slots: string[]; meta: Record<string, SlotMeta> }> = [];
   const candidates: Array<string> = [appDir];
   for (const sub of ['apps', 'packages']) {
     const parent = join(appDir, sub);
@@ -191,7 +245,12 @@ function discoverContractPackages(appDir: string, cache?: FileCache): Array<{ di
     }
   }
   const seenRoots = new Set<string>();
+  const addDiscovered = (dir: string, file: string): void => {
+    const parsed = cache ? cache.read(file, parseSlotsFile) : parseSlotsFile(readFileSync(file, 'utf8'));
+    if (parsed !== null && parsed !== undefined) found.push({ dir, slots: parsed.slots, meta: parsed.meta });
+  };
   for (const dir of candidates) {
+    // 跳 1/2：node_modules 位（包根 → src——显式安装真源优先）
     const scopeDir = join(dir, 'node_modules', '@tbox.cn');
     if (!existsSync(scopeDir)) continue;
     let names: string[] = [];
@@ -204,19 +263,16 @@ function discoverContractPackages(appDir: string, cache?: FileCache): Array<{ di
       const pkgDir = join(scopeDir, name);
       if (seenRoots.has(pkgDir)) continue;
       seenRoots.add(pkgDir);
-      const slotsFile = join(pkgDir, 'service-slots.json');
-      if (!existsSync(slotsFile)) continue;
-      const parseSlots = (raw: string): string[] | null => {
-        try {
-          const parsed = JSON.parse(raw) as { slots?: unknown };
-          if (Array.isArray(parsed.slots)) return parsed.slots.filter((s): s is string => typeof s === 'string');
-        } catch {
-          /* 宽松：坏文件跳过 */
-        }
-        return null;
-      };
-      const slots = cache ? cache.read(slotsFile, parseSlots) : parseSlots(readFileSync(slotsFile, 'utf8'));
-      if (slots !== null && slots !== undefined) found.push({ dir: pkgDir, slots });
+      const rootFile = join(pkgDir, 'service-slots.json');
+      const srcFile = join(pkgDir, 'src', 'service-slots.json');
+      if (existsSync(rootFile)) addDiscovered(pkgDir, rootFile);
+      else if (existsSync(srcFile)) addDiscovered(pkgDir, srcFile);
+    }
+  }
+  // 跳 3：候选自身（local/codegen 全量副本形态——后置于 nm 位：真源 > 副本，meta 首声明序随此）
+  for (const dir of candidates) {
+    for (const file of [join(dir, 'service-slots.json'), join(dir, 'src', 'service-slots.json')]) {
+      if (existsSync(file)) addDiscovered(dir, file);
     }
   }
   return found;
@@ -232,7 +288,7 @@ export function walkManifests(appDir: string, cache?: FileCache): WalkManifestsR
   /** 域键 → 首个声明模块（P13 冲突检测） */
   const domainOwners = new Map<string, string>();
 
-  const addSlots = (slots: readonly ProviderSlotContrib[], owner: string, packageDir: string): void => {
+  const addSlots = (slots: readonly ProviderSlotContrib[], owner: string, packageDir: string, modMeta?: SlotMeta): void => {
     for (const slot of slots) {
       // 富形态：per-service {implementation, credentialType} 保真（同厂商多 impl 合法——声明序）
       const vendorSlots = (catalog.providers[slot.provider] ??= {});
@@ -245,6 +301,8 @@ export function walkManifests(appDir: string, cache?: FileCache): WalkManifestsR
           implementation: slot.implementation,
           credentialType: slot.credentialType,
           owner,
+          ...(modMeta?.title ? { title: modMeta.title } : {}),
+          ...(modMeta?.description ? { description: modMeta.description } : {}),
           ...(slot.local ? { local: true } : {}),
           ...(slot.configSchema ? { configSchema: slot.configSchema } : {}),
           ...(slot.credentialSchema ? { credentialSchema: slot.credentialSchema } : {}),
@@ -268,6 +326,10 @@ export function walkManifests(appDir: string, cache?: FileCache): WalkManifestsR
     }
   };
 
+  /** 厂商展示元数据（strict manifest descriptor 透传——loose 形态无 descriptor → undefined） */
+  const modMetaOf = (manifest: ReadManifestResult): SlotMeta | undefined =>
+    manifest.kind === 'strict' ? { title: manifest.descriptor.title, description: manifest.descriptor.description } : undefined;
+
   const addServiceNeed = (
     need: { service: string; optional?: boolean; defaults?: Array<{ provider: string; implementation: string }>; title?: string; description?: string },
     owner: string,
@@ -324,7 +386,7 @@ export function walkManifests(appDir: string, cache?: FileCache): WalkManifestsR
       modules.push({ id: entry.id, dir, pkg: entry.mode === 'sdk' ? entry.package : `@app/${entry.id}`, descriptor: manifest.descriptor });
     }
     const slots = contributes.providers?.slots ?? [];
-    if (slots.length) addSlots(slots, entry.package, dir);
+    if (slots.length) addSlots(slots, entry.package, dir, modMetaOf(manifest));
     const needs = contributes.services ?? [];
     if (needs.length) {
       for (const need of needs) {
@@ -340,14 +402,14 @@ export function walkManifests(appDir: string, cache?: FileCache): WalkManifestsR
     if (!manifest?.name || seen.has(manifest.name)) continue;
     seen.add(manifest.name);
     const slots = manifest.contributes.providers?.slots ?? [];
-    if (slots.length) addSlots(slots, pkg, dir);
+    if (slots.length) addSlots(slots, pkg, dir, modMetaOf(manifest));
     const needs = manifest.contributes.services ?? [];
     if (needs.length) {
       for (const need of needs) addServiceNeed(need, pkg);
     }
   }
 
-  // 通道 2：packages/* 约定发现（本地模块——npmModules 未登记形态，如模板天气模块）
+  // 通道 2：packages/* 约定发现（本地模块——npmModules 未登记形态，如手工放入的本地模块）
   const packagesDir = join(appDir, 'packages');
   if (existsSync(packagesDir)) {
     let entries: string[] = [];
@@ -369,7 +431,7 @@ export function walkManifests(appDir: string, cache?: FileCache): WalkManifestsR
         modules.push({ id: modName, dir, pkg: `@app/${modName}`, descriptor: manifest.descriptor });
       }
       const slots = contributes.providers?.slots ?? [];
-      if (slots.length) addSlots(slots, `@app/${modName}`, dir);
+      if (slots.length) addSlots(slots, `@app/${modName}`, dir, modMetaOf(manifest));
       const needs = contributes.services ?? [];
       if (needs.length) {
         for (const need of needs) {
@@ -379,13 +441,18 @@ export function walkManifests(appDir: string, cache?: FileCache): WalkManifestsR
     }
   }
 
-  // 产物 4：服务词汇（契约包 service-slots.json 并集——零缓存枚举）
+  // 产物 4/5：服务词汇 + 词汇 meta（契约包 service-slots.json 并集——零缓存枚举；
+  // meta 多包发现序首声明胜出，与 catalog addSlots 同语义）
   const vocabulary = new Set<string>();
+  const slotMeta: Record<string, SlotMeta> = {};
   for (const pkg of discoverContractPackages(appDir, cache)) {
     for (const s of pkg.slots) vocabulary.add(s);
+    for (const [svc, m] of Object.entries(pkg.meta)) {
+      if (slotMeta[svc] === undefined) slotMeta[svc] = m;
+    }
   }
 
-  return { modules, catalog, serviceSchemas, vocabulary: [...vocabulary].sort(), domainKeyIssues };
+  return { modules, catalog, serviceSchemas, vocabulary: [...vocabulary].sort(), slotMeta, domainKeyIssues };
 }
 
 // ── CLI collectDeclared 迁入（C5——声明集合 + 双端入口探测 + declaration.moduleId 提取）──

package/src/core/env-expansion.ts

@@ -1,21 +1,23 @@
 /**
  * 配置 JSON 环境变量占位展开（纯数据形态——自 app-sdk env-expansion.ts 迁入改造）。
  *
- * 语法（与 SDK 版语义逐字一致，共享向量 test-fixtures/env-expansion-cases.json 防漂移）：
- *   ${NAME}     占位引用；NAME 限定 [A-Z][A-Z0-9_]*（UPPER_SNAKE，最小化与正文 `${...}` 误碰）
- *   $${NAME}   转义为字面量 ${NAME}（原样保留一次 $）
+ * 语法（语义真源 = 本文件 + 共享向量 test-fixtures/env-expansion-cases.json 防漂移）：
+ *   ${NAME}        占位引用；NAME 限定 [A-Z][A-Z0-9_]*（UPPER_SNAKE，最小化与正文 `${...}` 误碰）
+ *   ${NAME:def}    POSIX 风格缺省值：NAME 未设置时用 def（字面量，不二次展开）；设置时空串也算「已设置」
+ *   $${NAME}      转义为字面量 ${NAME}（原样保留一次 $）
  *
  * 语义（评审 N1 钉死，壳层各自包装 throw/report）：
  *   - 单遍非递归：env 值内若含 `${OTHER}` 不被二次展开（注入防线）；String.replace 回调形态天然单遍。
+ *     默认值内含 `${...}` 同样不展开（POSIX 同限）；默认值含 `}` 不支持（同 POSIX 同限——正则 [^}] 截断）。
  *   - 值经 JSON 字符串转义注入；不做数值/布尔强制转换。
- *   - **本版为纯数据返回形态** `{ text?: string; missing: string[] }`——缺变量不 throw，
+ *   - **本版为纯数据返回形态** `{ text?: string; missing: string[] }`——缺变量（无缺省值时）不 throw，
  *     由壳层（CLI doctor 壳 / app-sdk 桥 throw 壳 / 沙箱宿主）决定 fail-fast 还是降级：
  *     SDK 桥壳 missing 非空即 throw（错误文案逐字等价 SDK 旧版）；CLI 壳同款。
  *   - 无 ${ 的文本快速路径：text 原文返回，零替换零开销。
  */
 
-/** 占位匹配：$ 或 $$ 后接 {[A-Z][A-Z0-9_]*}（$$ 形态同匹配，展开期判首字符去留） */
-const ENV_VAR_RE = /\$\$?\{([A-Z][A-Z0-9_]*)\}/g;
+/** 占位匹配：$ 或 $$ 后接 {NAME} 或 {NAME:default}（$$ 形态同匹配，展开期判首字符去留） */
+const ENV_VAR_RE = /\$\$?\{([A-Z][A-Z0-9_]*)(?::-([^}]*))?\}/g;
 
 /** JSON 字符串字面量转义（值 → 可直接置于 "..." 内的安全文本）——
  * 基于 JSON.stringify 切片：引号/反斜杠/控制字符（\b/\n/\r/\t/\f）转义语义与 JSON 精确一致 */
@@ -37,14 +39,14 @@ export function expandEnvVars(
 ): EnvExpansionResult {
   const missing: string[] = [];
   // 单遍替换：回调返回值不回扫（非递归语义；$${} 转义在回调内消去一个 $）
-  const out = text.replace(ENV_VAR_RE, (raw, name: string) => {
+  const out = text.replace(ENV_VAR_RE, (raw, name: string, fallback?: string) => {
     if (raw.startsWith('$$')) return raw.slice(1);
     const v = env[name];
-    if (v === undefined) {
-      missing.push(name);
-      return raw; // 占位保留（纯数据形态：missing 上报，不 throw）
-    }
-    return jsonEscape(v);
+    if (v !== undefined) return jsonEscape(v);
+    // ${NAME:def}：NAME 未设置 → 缺省值（字面量；空串默认 = 显式空值语义）
+    if (fallback !== undefined) return jsonEscape(fallback);
+    missing.push(name);
+    return raw; // 占位保留（纯数据形态：missing 上报，不 throw）
   });
   if (missing.length > 0) return { missing };
   return { text: out, missing: [] };

package/src/core/module-schema.ts

@@ -78,6 +78,9 @@ export const moduleDescriptorSchema = z
   .object({
     schemaVersion: z.number().default(1),
     name: z.string(),
+    // 模块级 meta additive（B1）：展示名/描述——回退归视图层（title ?? name / ''），schema 不灌值
+    title: z.string().optional(),
+    description: z.string().optional(),
     version: z.string().default('0.0.0'),
     kind: z.enum(['platform', 'business', 'third-party']).default('business'),
     risk: z

package/src/dto.ts

@@ -50,6 +50,10 @@ export interface ServiceDemand {
 
 /** GET /modules/:module（模块静态一站式 · PUT 读对偶） */
 export interface ModuleDetailView {
+  /** B1 additive：模块 meta 展示名（manifest title；视图层兜底 name——恒有值） */
+  title: string;
+  /** B1 additive：模块 meta 描述（manifest description；兜底 ''） */
+  description: string;
   /** v4.4 D34：demand 服务首段去重（排序；1..N；零域 = []） */
   domainKeys: string[];
   /** domains[换算键] 节点原值；未配置 = null；v4.4 D34：仅单域（writable）时在场——多域/零域/共享键无单键落点 */
@@ -287,6 +291,9 @@ export interface ProviderEntry {
   local: boolean;
   /** 供给声明来源包名 */
   owner: string;
+  /** B1 additive：厂商展示名（manifest 模块 meta——多包首声明；缺席 = undefined） */
+  title?: string;
+  description?: string;
 }
 
 /** GET /providers/:provider：供给足迹 */
@@ -294,12 +301,18 @@ export interface ProviderDetail {
   provider: string;
   local: boolean;
   owner: string;
+  /** B1 additive：厂商展示名（同 ProviderEntry——首声明透传） */
+  title?: string;
+  description?: string;
   /** per (provider, service) 保真，同厂商异构合法；★ implementations 恒数组（H1——
    *  多元素 = 升级窗口，UI 出 impl 选择器，PUT 显式钉版） */
   services: Record<
     string,
     {
       implementations: Array<{ implementation: string; credentialType: string }>;
+      /** B1 additive：服务展示名（resolveServiceDisplay——词汇 > demand > id；恒发） */
+      title?: string;
+      description?: string;
       /** v4.4 F5：include=integrationSchemas 切换态批量（纯 config——凭据结构归 /credential-types） */
       integrationSchemas?: { configSchema: object | null };
     }

package/src/index.ts

@@ -56,6 +56,10 @@ export type {
 // ── 谓词装配单源（FX-2b/F1：CLI doctor 规则与 toolkit 工厂同装配面——双通道 walkManifests）──
 export { buildPredicateAssembly, refToEnvKey } from './integrations/predicate-io.js';
 export type { PredicateAssembly, PredicateIoInputs } from './integrations/predicate-io.js';
+// ── 应用级求值单源（cli-remove-prune-and-new：doctor integration-services 与 prune 同一求值）──
+export { evaluateAppIntegrationIssues } from './integrations/evaluate-app.js';
+export { pruneIntegrationBindings } from './integrations/prune-bindings.js';
+export type { PruneResult } from './integrations/prune-bindings.js';
 
 // ── assembly 层（目录知识——walkManifests 四产物 + catalog 双形态 + 组合单体装配）──
 export { walkManifests } from './assembly/walk-manifests.js';

package/src/integrations/evaluate-app.ts

@@ -0,0 +1,41 @@
+import type { ResolvedContracts } from '../core/contracts-resolver.js';
+import { walkManifests } from '../assembly/walk-manifests.js';
+import { loadProviderCatalog } from '../assembly/provider-catalog.js';
+import { buildPredicateAssembly } from './predicate-io.js';
+import {
+  evaluateIntegrationServices,
+  type IntegrationServiceIssue,
+  type PredicateContracts,
+  type SupplyLookup,
+} from './predicate.js';
+
+/**
+ * 应用级 integrations 求值（cli-remove-prune-and-new D2.4）：doctor integration-services 规则内
+ * "装配+求值"序列的单源抽取（FX-2b/F1 轨迹延续——此前 buildPredicateAssembly 已单源，本函数
+ * 将 walk→supplies→assembly→evaluate 全序列收口）。
+ *
+ * 消费方：
+ * - doctor integration-services 规则（外壳保留：stale 防线/文件读取/env 展开/形状守卫/分级投射）
+ * - pruneIntegrationBindings（prune 判据 ≡ doctor 判据的构造性同源载体）
+ *
+ * 契约：调用方须先 `resolveContractsForApp` 并确保 `strictValidation`（本函数不再分级门控——
+ * doctor 的 warning/error 升级指引与 prune 的 skip 语义分属两消费方，不收口）。
+ */
+export async function evaluateAppIntegrationIssues(
+  appDir: string,
+  integrations: Record<string, unknown>,
+  contracts: ResolvedContracts,
+  env: Readonly<Record<string, string | undefined>> = process.env,
+): Promise<IntegrationServiceIssue[]> {
+  const module = contracts.module as PredicateContracts;
+  const walk = walkManifests(appDir);
+  const supplies: SupplyLookup = module.buildSupplyLookup(loadProviderCatalog(appDir) as never);
+  const assembly = buildPredicateAssembly(appDir, walk, integrations, env);
+
+  return evaluateIntegrationServices({
+    contracts: module,
+    integrations: integrations as never,
+    supplies,
+    ...assembly,
+  });
+}

package/src/integrations/prune-bindings.ts

@@ -0,0 +1,186 @@
+import { existsSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import type { ResolvedContracts } from '../core/contracts-resolver.js';
+import { resolveContractsForApp } from '../core/contracts-resolver.js';
+import { expandEnvVars } from '../core/env-expansion.js';
+import { writeAtomic } from '../core/fskit.js';
+import { walkManifests } from '../assembly/walk-manifests.js';
+import { readIntegrationsConfig } from './read.js';
+import { domainOfService } from './domain-binding.js';
+import { isControlledInlineProvider } from './predicate.js';
+import { reconcileOrphanCredentials } from './credentials.js';
+import { evaluateAppIntegrationIssues } from './evaluate-app.js';
+
+/**
+ * integrations.json 死绑定清理（cli-remove-prune-and-new D2 核心件）。
+ *
+ * 不变式：**删除判据 ≡ doctor integration-services 报错判据（构造性同源）**——消费 doctor 同一
+ * 共享求值器 evaluateAppIntegrationIssues 的结构化 issue，code 白名单
+ * {VENDOR_NOT_INSTALLED, BINDING_UNRESOLVED} + 守卫（绑定引用链候选 provider ∈ installedVendors
+ * 即保留，排除活厂商错配）→ 删除域严格 = "供给载体消亡"。
+ *
+ * 由此推论（均已实证）：需求侧孤儿绑定（demand 消失、供给在场）保留——doctor 判其合法；用户
+ * 预配置绑定受保护；一次 remove 自愈全文件历史死债；凭据类 issue（CREDENTIAL_FILE_MISSING 等）
+ * 刻意不进白名单，原样保留。
+ *
+ * 写侧三防线（镜像 write core）：N1 归一化（空模块节点删 domains 键）→ parseIntegrationsConfig
+ * 严格校验（失败弃写）→ writeAtomic。凭据孤儿只报告不清理（D9——与 DELETE 管线现行为一致）。
+ * 全空（无任何存活绑定）→ 删文件——ensureMockBindings（缺席即生成）在重装供给时再生闭环。
+ *
+ * 最佳努力语义：谓词不可用（contracts 未安装/降级、env 缺失、求值 throw）→ skipped 返回 +
+ * 文件原样，绝不阻断 remove 本体。
+ */
+
+export interface PruneResult {
+  /** 被清除的绑定节点描述（remove 日志行，如 'root.provider=mock' / 'services.member.account'） */
+  removed: string[];
+  /** 孤儿凭据（D9 只报告不清理——reconcileOrphanCredentials 产物 message） */
+  orphanCredentials: string[];
+  /** 跳过原因（正常路径 undefined；not-configured = integrations.json 缺席，兼容态零动作） */
+  skipped?: 'predicate-unavailable' | 'validation-failed' | 'not-configured';
+}
+
+/** 宽松形状（谓词输入同族子集——doctor 读裸 JSON 先例，严格 zod 归模板 loader） */
+interface PruneDoc {
+  provider?: string;
+  domains?: Record<string, { provider?: string; config?: Record<string, unknown> }>;
+  config?: Record<string, unknown>;
+  configByInstance?: Record<string, Record<string, unknown>>;
+  credentialRef?: string;
+  credentialRefByInstance?: Record<string, string>;
+  instances?: Array<{ id: string }>;
+  defaultInstanceId?: string | null;
+  modules?: Record<string, unknown>;
+  services?: Record<
+    string,
+    {
+      provider?: string | Record<string, unknown>;
+      implementation?: unknown;
+      config?: Record<string, unknown>;
+      credentialRef?: string;
+      instances?: Record<string, { enabled?: boolean; provider?: unknown; implementation?: unknown; credentialRef?: string }>;
+    }
+  >;
+}
+
+/** 候选 provider 字符串提取（string 直取；受控内联对象取 .provider；其余 undefined） */
+function providerOf(v: unknown): string | undefined {
+  if (typeof v === 'string') return v.length > 0 ? v : undefined;
+  if (v && typeof v === 'object' && isControlledInlineProvider(v)) {
+    const p = (v as { provider: string }).provider;
+    return p.length > 0 ? p : undefined;
+  }
+  return undefined;
+}
+
+export async function pruneIntegrationBindings(appDir: string): Promise<PruneResult> {
+  const file = join(appDir, 'config', 'integrations.json');
+  const raw = readIntegrationsConfig(appDir);
+  if (raw === null) return { removed: [], orphanCredentials: [], skipped: 'not-configured' };
+
+  const contracts: ResolvedContracts = await resolveContractsForApp(appDir);
+  if (!contracts.strictValidation) {
+    return { removed: [], orphanCredentials: [], skipped: 'predicate-unavailable' };
+  }
+
+  // env 展开（tolerant——doctor 走 fail-fast 外壳，prune 缺变量即降级跳过）
+  let integrations: Record<string, unknown>;
+  try {
+    const expanded = expandEnvVars(JSON.stringify(raw), process.env);
+    if (expanded.missing.length > 0 || expanded.text === undefined) {
+      return { removed: [], orphanCredentials: [], skipped: 'predicate-unavailable' };
+    }
+    integrations = JSON.parse(expanded.text) as Record<string, unknown>;
+  } catch {
+    return { removed: [], orphanCredentials: [], skipped: 'predicate-unavailable' };
+  }
+
+  let issues;
+  try {
+    issues = await evaluateAppIntegrationIssues(appDir, integrations, contracts, process.env);
+  } catch {
+    return { removed: [], orphanCredentials: [], skipped: 'predicate-unavailable' };
+  }
+
+  const installedVendors = new Set(Object.keys(walkManifests(appDir).catalog.providers));
+  const next = structuredClone(raw) as PruneDoc;
+  next.services ??= {};
+  const removed: string[] = [];
+
+  for (const issue of issues) {
+    if (issue.severity !== 'error') continue;
+    if (issue.code === 'VENDOR_NOT_INSTALLED') {
+      if (issue.module) {
+        const d = next.domains?.[issue.module];
+        if (d?.provider) {
+          removed.push(`domains.${issue.module}.provider=${d.provider}`);
+          delete d.provider;
+          if (Object.keys(d).length === 0) delete next.domains![issue.module]; // N1
+        }
+      } else if (next.provider) {
+        removed.push(`root.provider=${next.provider}`);
+        delete next.provider;
+      }
+    } else if (issue.code === 'BINDING_UNRESOLVED' && issue.service) {
+      const s = next.services[issue.service];
+      if (!s) continue;
+      // 守卫：引用链任一候选 ∈ installedVendors → 活厂商错配，保留（doctor 报错语义不变）
+      const candidates = [
+        issue.instance ? providerOf(s.instances?.[issue.instance]?.provider) : undefined,
+        providerOf(s.provider),
+        providerOf(next.domains?.[domainOfService(issue.service)]?.provider),
+        providerOf(next.provider),
+      ].filter((v): v is string => typeof v === 'string');
+      if (candidates.some((v) => installedVendors.has(v))) continue;
+      if (issue.instance) {
+        const inst = s.instances;
+        if (!inst || !(issue.instance in inst)) continue;
+        delete inst[issue.instance];
+        removed.push(`services.${issue.service}.instances.${issue.instance}`);
+        if (Object.keys(inst).length === 0) delete s.instances;
+        if (Object.keys(s).length === 0) delete next.services[issue.service];
+      } else {
+        delete next.services[issue.service];
+        removed.push(`services.${issue.service}`);
+      }
+    }
+  }
+  if (Object.keys(next.services).length === 0) delete next.services;
+  if (removed.length === 0) return { removed, orphanCredentials: [] };
+
+  // 全空判定先行（**先于严格校验**——空文档 `{}` 缺必填 services 键必然被 zod 拒；删文件免校验）
+  const empty =
+    !next.provider &&
+    Object.keys(next.domains ?? {}).length === 0 &&
+    Object.keys(next.services ?? {}).length === 0 &&
+    Object.keys(next.config ?? {}).length === 0 &&
+    Object.keys(next.configByInstance ?? {}).length === 0 &&
+    !next.credentialRef &&
+    Object.keys(next.credentialRefByInstance ?? {}).length === 0 &&
+    (next.instances ?? []).length === 0 &&
+    next.defaultInstanceId == null &&
+    Object.keys(next.modules ?? {}).length === 0;
+
+  // ④ 严格校验（仅非空文档——services 为 schema 必填键，全服务剪除的存活文档补空 record 归一）
+  if (!empty) {
+    next.services ??= {};
+    if (typeof contracts.module.parseIntegrationsConfig === 'function') {
+      try {
+        contracts.module.parseIntegrationsConfig(next as never);
+      } catch {
+        return { removed: [], orphanCredentials: [], skipped: 'validation-failed' };
+      }
+    }
+  }
+
+  // ⑤⑥ 写 + 孤儿报告（D9）；空 → 删文件（ensureMockBindings 重装再生闭环）
+  let orphanCredentials: string[] = [];
+  if (empty) {
+    if (existsSync(file)) rmSync(file, { force: true });
+  } else {
+    writeAtomic(file, `${JSON.stringify(next, null, 2)}\n`);
+  }
+  orphanCredentials = reconcileOrphanCredentials(appDir).map((o) => o.message);
+
+  return { removed, orphanCredentials };
+}

package/src/views/app.ts

@@ -1,6 +1,6 @@
 import type { AppView, ServiceDemand } from '../dto.js';
 import { APP_INTEGRATION_NODE_KEYS } from '../dto.js';
-import { moduleOccupiedServices, type ViewSnapshot } from './context.js';
+import { moduleOccupiedServices, resolveServiceDisplay, type ViewSnapshot } from './context.js';
 
 /**
  * 应用静态投影（views/app；C4；FX-1c B10——root 节点投影修；v4.4 D29——services 双端点同型）。
@@ -14,9 +14,13 @@ import { moduleOccupiedServices, type ViewSnapshot } from './context.js';
 
 export function loadAppView(snapshot: ViewSnapshot): AppView {
   const occupied = moduleOccupiedServices(snapshot.walk);
+  // 平台条目展示名走链（B1）：词汇 meta > demand meta > id——title 恒发（id 兜底内聚）
   const services: ServiceDemand[] = snapshot.walk.vocabulary
     .filter((s) => !occupied.has(s))
-    .map((s) => ({ service: s, required: false }));
+    .map((s) => {
+      const display = resolveServiceDisplay(snapshot.walk, s);
+      return { service: s, title: display.title, ...(display.description !== undefined ? { description: display.description } : {}), required: false };
+    });
   const config = snapshot.integrations;
   let integration: AppView['integration'] = null;
   if (config) {

package/src/views/context.ts

@@ -65,3 +65,23 @@ export function suppliedByVendors(catalog: WalkCatalog, service: string): string
   }
   return vendors.sort();
 }
+
+/** 服务展示名解析结果（title 恒有值——id 兜底内聚） */
+export interface ServiceDisplay {
+  title: string;
+  description?: string;
+}
+
+/**
+ * 服务展示名单源（B1）：词汇 meta（slotMeta——contracts-mall 词汇锁保证 mall 域覆盖）
+ * > demand meta（catalog.services——域外槽兜底；首声明聚合）> service id。逐字段回落——
+ * 词汇条目仅含 description 时 demand title 仍可达（外部契约包部分 meta 前向容错）。
+ * 四视图唯一消费点（/modules/:m services、/app 平台条目、/services/:s、/providers/:p services）。
+ */
+export function resolveServiceDisplay(walk: WalkManifestsResult, service: string): ServiceDisplay {
+  const vocab = walk.slotMeta[service];
+  const demand = walk.catalog.services[service];
+  const title = vocab?.title ?? demand?.title ?? service;
+  const description = vocab?.description ?? demand?.description;
+  return { title, ...(description !== undefined ? { description } : {}) };
+}