@tbox.cn/app-toolkit 0.2.0 → 0.4.0

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

@@ -1,5 +1,5 @@
 /**
- * DTO 全量（api.md §3 字段级单源落源——28 类型；演进 additive-only，铁律 #8）。
+ * DTO 全量（api.md §3 字段级单源落源——36 类型；演进 additive-only，铁律 #8）。
  * agtcodingbox / tbox-ai-coding 经 `import type` 消费（L2 DTO 单源——API 层零类型镜像）。
  * 词汇七概念：app / module / service / instance / provider / integration / resolution。
  * 弃用词汇清单见 api.md §3 尾（component/slot/scope/configMode/…——防复活）。
@@ -20,13 +20,15 @@ export type BindingLayer = 'app' | 'module' | 'service' | 'instance';
 
 // ===== 需求轴（GET /modules · 静态）=====
 
-/** 纯模块清单（无 services——卡片展开走 /modules/:m） */
+/** 纯模块清单（无 services——卡片展开走 /modules/:m）；provider 家族包不在清单
+ *  （供给/实施载体非可配置业务模块——供给轴归 /providers；判定 = install id / 包名
+ *  basename 去 scope 后 `provider-` 前缀；已装 provider 详情 GET /modules/:m 仍 200） */
 export interface ModulesView {
   modules: ModuleDeclaration[];
 }
 
 export interface ModuleDeclaration {
-  /** install id（packages/ 目录名 / .tbox/app.json entry.id） */
+  /** install id（packages/ 目录名 / .tbox/app.json entry.id）——恒业务模块（provider 家族不在本清单） */
   id: string;
   /** 包名 */
   name: string;
@@ -48,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）时在场——多域/零域/共享键无单键落点 */
@@ -62,6 +68,9 @@ export interface ModuleDetailView {
   serviceResolutions?: ServiceResolutionsView | null;
   /** v4.4 D32：include=integrationSchemas 层级富化（多域/零域/共享键/未绑定 → null） */
   integrationSchemas?: LayerIntegrationSchemas | null;
+  /** v4.6 D36：include=integrationFieldRegistry 集成字段注册表（null 语义镜像 integrationSchemas；
+   *  未知厂商/零足迹 → 非 null 空集 + unsupplied 回填——D37 轴参假想计算同此） */
+  integrationFieldRegistry?: IntegrationFieldRegistryView | null;
 }
 
 /** 模块域厂商绑定解析（v4.4 D34——静态文件事实；规则 ≡ 谓词 #7 域级，resolveDomainBinding 单源） */
@@ -82,6 +91,27 @@ export interface LayerIntegrationSchemas {
   services: Record<string, { configSchema: object | null }>;
 }
 
+/** v4.6 D36：集成字段注册表（层级表单服务端预计算——合并代数 R1/R2/R3 服务端单源；
+ *  消费 resolveLayerIntegrationSchemas 产物构造，禁旁路直取 serviceSchemas） */
+export interface IntegrationFieldRegistryView {
+  /** echo：本注册表计算口径（假想时 = 轴参值——D37） */
+  provider: string;
+  /** 作用域内 configSchema === null 的服务（UI「未提供参数模板」提示行） */
+  schemaless: string[];
+  /** module 轴 = demand − 该厂商供给（Set 去重保序）；app 轴恒 []（结构性：足迹 ⊆ 供给） */
+  unsupplied: string[];
+  /** 作用域内全部非 null schema 的 additionalProperties 均 ≠ false（聚合；空真） */
+  additionalPropertiesAllowed: boolean;
+  /** 逐 key 合并产物（首声明插入序 = scope 遍历序：app 字母序 / module demand 序） */
+  fields: Array<{
+    key: string;
+    /** null = 类型不可调和（R3/R2 异构/R1 enum 不等——冲突折叠，客户端 RawJson 保真） */
+    schema: object | null;
+    /** required 聚合 = sources.some(s => s.required)；conflict 字段照常聚合 */
+    sources: Array<{ service: string; required: boolean }>;
+  }>;
+}
+
 /** GET /app（应用静态视图：平台服务 + root 原值） */
 export interface AppView {
   /** 平台服务（v4.4 D29：服务词汇 − 模块占用——与模块 demand 同型 ServiceDemand[]；
@@ -93,6 +123,9 @@ export interface AppView {
   serviceResolutions?: ServiceResolutionsView | null;
   /** v4.4 D32：include=integrationSchemas 层级富化（root.provider 缺席 → null） */
   integrationSchemas?: LayerIntegrationSchemas | null;
+  /** v4.6 D36：include=integrationFieldRegistry 集成字段注册表（root.provider 缺席且无轴参 → null；
+   *  未知厂商/零足迹 → 非 null 空集——D37 轴参假想计算同此） */
+  integrationFieldRegistry?: IntegrationFieldRegistryView | null;
 }
 
 /** GET /services/:service（服务静态单体） */
@@ -103,6 +136,18 @@ export interface ServiceDetail extends ServiceDemand {
   integration: ServiceIntegrationNode | null;
   /** 供给该服务的厂商名单（catalog 静态切片——picker 数据源） */
   suppliedBy: string[];
+  /** v4.7 D38：include=integrationSchemas 生效绑定富化（三态：null 全链未绑定 /
+   *  绑定无可计算 schema / 含 schema；malformed 节点 → null——不放行域级联） */
+  integrationSchemas?: ServiceIntegrationSchemas | null;
+}
+
+/** 服务级生效绑定 schema（v4.7 D38 静态轴富化——零 contracts，永不 503；实例层无条件排除：
+ *  node 级口径 ≠ resolution 默认实例口径，api.md §4.4 注） */
+export interface ServiceIntegrationSchemas {
+  /** 生效厂商：显式（含内联声明名）?? domains[首段].provider ?? root.provider */
+  provider: string;
+  /** catalog 复合键（多 impl 声明序首个）> 内联 ref；miss（未知厂商/未供给/内联缺 ref）→ null（富化非门控） */
+  configSchema: object | null;
 }
 
 // ===== 求值轴 =====
@@ -246,6 +291,9 @@ export interface ProviderEntry {
   local: boolean;
   /** 供给声明来源包名 */
   owner: string;
+  /** B1 additive：厂商展示名（manifest 模块 meta——多包首声明；缺席 = undefined） */
+  title?: string;
+  description?: string;
 }
 
 /** GET /providers/:provider：供给足迹 */
@@ -253,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 };
     }
@@ -359,7 +413,8 @@ export interface SaveResult {
   written: boolean;
   /** 恒 false 当 dryRun / no-diff / 应用未运行（onApplied 协作点回填） */
   restartScheduled: boolean;
-  /** 触碰文件清单（dryRun 恒 []） */
+  /** 触碰清单；dryRun = 将触碰预览（D35——与同 body 真实写逐字对称，含凭据工件路径；
+   *  no-diff 早退 = 预览零触碰） */
   files: string[];
   /** 凭据工件（0..n；dryRun = 将创建的工件——确定性 stem 派生预览） */
   credentials: Array<{ stem: string; ref: string; overwrote: boolean }>;

package/src/factory.ts

@@ -19,7 +19,7 @@ import { loadModulesView, loadModuleDetailView } from './views/modules.js';
 import { loadAppView } from './views/app.js';
 import { loadServiceDetailView } from './views/service-detail.js';
 import { loadServiceResolutionsView, loadServiceResolutionDetail } from './views/service-resolutions.js';
-import { loadAppIntegrationSchemas, loadModuleIntegrationSchemas } from './views/integration-schemas.js';
+import { loadAppFormViews, loadModuleFormViews, loadServiceIntegrationSchemas } from './views/integration-schemas.js';
 import { loadCredentialsView } from './views/credentials.js';
 import { loadCredentialTypesView } from './views/credential-types.js';
 import type { WalkManifestsResult } from './assembly/walk-manifests.js';
@@ -42,7 +42,9 @@ import type {
 
 /**
  * createAppToolkit（C4 工厂；v4.4——24 方法 = 11 读（含 credentials/credential-types 双端点）
- * + 4 写 + 9 迁移面；loadApp/loadModule/loadProvider 增 include 选项）。
+ * + 4 写 + 9 迁移面；loadApp/loadModule/loadProvider 增 include 选项；v4.6——loadApp/loadModule
+ * += 轴向假想绑定选项（appProvider/moduleProvider，D37）；表单双投影经 formViews 单点装配；
+ * v4.7——loadService 增 include 选项（服务级生效绑定 schema 单体））。
  * AppToolkit = AppToolkitRead & AppToolkitWrite & AppToolkitInternals——
  * Read+Write = HTTP 直通面 additive 冻结（L1 端点↔方法 1:1，L3 命名镜像：Integration=节点级 /
  * Config=文件级）；Internals = CLI/doctor/桥消费（自由演进）。
@@ -63,11 +65,14 @@ export interface AppToolkitOptions {
   onApplied?: () => void;
 }
 
-/** include 协议白名单（v4.4 D30/P15——键名 = 产出字段名 1:1；per 端点；注册表 additive-only） */
+/** include 协议白名单（v4.4 D30/P15——键名 = 产出字段名 1:1；per 端点；注册表 additive-only；
+ *  v4.6 D36 += integrationFieldRegistry：app/module 三键，provider 轴不加——YAGNI；
+ *  v4.7 D38 += service 键——服务级生效绑定 schema） */
 const INCLUDE_WHITELIST = {
-  app: ['serviceResolutions', 'integrationSchemas'],
-  module: ['serviceResolutions', 'integrationSchemas'],
+  app: ['serviceResolutions', 'integrationSchemas', 'integrationFieldRegistry'],
+  module: ['serviceResolutions', 'integrationSchemas', 'integrationFieldRegistry'],
   provider: ['integrationSchemas'],
+  service: ['integrationSchemas'],
 } as const;
 
 /** include 校验（P15 单点在 toolkit 方法内——壳层仅解析可重复参数，零校验纪律不变）：
@@ -87,12 +92,35 @@ function validateInclude(kind: keyof typeof INCLUDE_WHITELIST, include?: string[
   return new Set(include);
 }
 
+/** 表单层 include 键（D37 轴参严检依据——serviceResolutions 不算） */
+const FORM_INCLUDE_KEYS = ['integrationSchemas', 'integrationFieldRegistry'] as const;
+
+/** v4.6 D37 轴参严检（400 先于 404——镜像输入校验先行）：非空轴参需与表单 include 键同现；
+ *  缺席/空串 ≡ 按实际配置解析（I3——不触发严检）；错轴参数由壳层按名读取，天然静默忽略。 */
+function assertAxisProviderUsable(
+  paramName: 'appProvider' | 'moduleProvider',
+  value: string | undefined,
+  include: ReadonlySet<string>,
+): void {
+  if (typeof value !== 'string' || value.length === 0) return;
+  if (!FORM_INCLUDE_KEYS.some((k) => include.has(k))) {
+    throw new AppToolkitError(
+      'VALIDATION_FAILED',
+      400,
+      `参数 ${paramName} 需与表单 include 键（${FORM_INCLUDE_KEYS.join('、')}）同现——轴参仅重定向表单层双投影`,
+      [paramName],
+    );
+  }
+}
+
 /** ── HTTP 直通面（11 读；L1 镜像律：方法名 = load + URL 资源段；query → 选项字段 L4）── */
 export interface AppToolkitRead {
   loadModules(): Promise<ModulesView>;
-  loadModule(moduleId: string, o?: { include?: string[] }): Promise<ModuleDetailView>;
-  loadApp(o?: { include?: string[] }): Promise<AppView>;
-  loadService(service: string): Promise<ServiceDetail>;
+  /** v4.6 D37：moduleProvider = 轴向假想绑定（缺席/空串 ≡ 按实际配置解析；需与表单 include 键同现） */
+  loadModule(moduleId: string, o?: { include?: string[]; moduleProvider?: string }): Promise<ModuleDetailView>;
+  /** v4.6 D37：appProvider = 轴向假想绑定（缺席/空串 ≡ 按实际配置解析；需与表单 include 键同现） */
+  loadApp(o?: { include?: string[]; appProvider?: string }): Promise<AppView>;
+  loadService(service: string, o?: { include?: string[] }): Promise<ServiceDetail>;
   loadServiceResolutions(services?: string[]): Promise<ServiceResolutionsView>;
   loadServiceResolution(service: string): Promise<ServiceResolutionDetail>;
   loadProviders(): Promise<ProvidersView>;
@@ -201,8 +229,9 @@ export function createAppToolkit(appDir: string, options: AppToolkitOptions = {}
     // v4.4 D31：门控与内嵌分离——静态方法零门控分支；include=serviceResolutions 按
     // evaluation && strictValidation 双条件装配（<0.9/形态异常 → null，永不 503——技术方案 §2.4：
     // 仅判 strictValidation 会被「严格面在场+求值面缺席」畸形包击穿）
-    async loadModule(moduleId: string, o?: { include?: string[] }): Promise<ModuleDetailView> {
+    async loadModule(moduleId: string, o?: { include?: string[]; moduleProvider?: string }): Promise<ModuleDetailView> {
       const include = validateInclude('module', o?.include); // ① 输入校验先行（400 先于 404）
+      assertAxisProviderUsable('moduleProvider', o?.moduleProvider, include); // ①' D37 轴参严检（先于 404）
       const contracts = await resolveContractsForApp(appDir);
       const snap = snapshot(contracts);
       const view = loadModuleDetailView(snap, moduleId); // ② MODULE_NOT_FOUND
@@ -212,13 +241,17 @@ export function createAppToolkit(appDir: string, options: AppToolkitOptions = {}
               loadServiceResolutionsView(snap, issues, view.services.map((s) => s.service)))
           : null; // module = demand 服务过滤（≡ 批量 ?service= 语义；issues 恒全量）
       }
-      if (include.has('integrationSchemas')) {
-        view.integrationSchemas = loadModuleIntegrationSchemas(snap, moduleId);
+      if (include.has('integrationSchemas') || include.has('integrationFieldRegistry')) {
+        // v4.6 D37：表单层双投影同源一次计算（双取单算 + I1——假想重定向天然同步）
+        const form = loadModuleFormViews(snap, moduleId, o?.moduleProvider);
+        if (include.has('integrationSchemas')) view.integrationSchemas = form.integrationSchemas;
+        if (include.has('integrationFieldRegistry')) view.integrationFieldRegistry = form.integrationFieldRegistry;
       }
       return view;
     },
-    async loadApp(o?: { include?: string[] }): Promise<AppView> {
+    async loadApp(o?: { include?: string[]; appProvider?: string }): Promise<AppView> {
       const include = validateInclude('app', o?.include);
+      assertAxisProviderUsable('appProvider', o?.appProvider, include); // D37 轴参严检（先于任何计算）
       const contracts = await resolveContractsForApp(appDir);
       const snap = snapshot(contracts);
       const view = loadAppView(snap);
@@ -227,14 +260,23 @@ export function createAppToolkit(appDir: string, options: AppToolkitOptions = {}
           ? await predicateIssues().then((issues) => loadServiceResolutionsView(snap, issues)) // app = 全量键集
           : null;
       }
-      if (include.has('integrationSchemas')) {
-        view.integrationSchemas = loadAppIntegrationSchemas(snap);
+      if (include.has('integrationSchemas') || include.has('integrationFieldRegistry')) {
+        const form = loadAppFormViews(snap, o?.appProvider); // 双取单算 + I1（同 loadModule）
+        if (include.has('integrationSchemas')) view.integrationSchemas = form.integrationSchemas;
+        if (include.has('integrationFieldRegistry')) view.integrationFieldRegistry = form.integrationFieldRegistry;
       }
       return view;
     },
-    async loadService(service: string) {
+    // v4.7 D38：include 镜像 loadModule 三段式——① 输入校验 400 先于 404 ② 视图 ③ 静态富化（永不 503）
+    async loadService(service: string, o?: { include?: string[] }): Promise<ServiceDetail> {
+      const include = validateInclude('service', o?.include);
       const contracts = await resolveContractsForApp(appDir);
-      return loadServiceDetailView(snapshot(contracts), service);
+      const snap = snapshot(contracts); // 单快照——detail 与 include 装配共享
+      const view = loadServiceDetailView(snap, service);
+      if (include.has('integrationSchemas')) {
+        view.integrationSchemas = loadServiceIntegrationSchemas(snap, service);
+      }
+      return view;
     },
     async loadServiceResolutions(services?: string[]) {
       const contracts = await resolveContractsForApp(appDir);

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';
@@ -85,7 +89,7 @@ export { loadAppView } from './views/app.js';
 export { loadServiceDetailView } from './views/service-detail.js';
 export { loadProvidersView, loadProviderDetailView, loadProviderServiceDetailView } from './views/providers.js';
 export { loadServiceResolutionsView, loadServiceResolutionDetail, resolveServiceSummary } from './views/service-resolutions.js';
-export { loadAppIntegrationSchemas, loadModuleIntegrationSchemas, resolveLayerIntegrationSchemas } from './views/integration-schemas.js';
+export { loadAppIntegrationSchemas, loadModuleIntegrationSchemas, loadServiceIntegrationSchemas, resolveLayerIntegrationSchemas } from './views/integration-schemas.js';
 export { echoForRef, loadCredentialsView } from './views/credentials.js';
 export { loadCredentialTypesView } from './views/credential-types.js';
 export type { ViewContext, ViewSnapshot } from './views/context.js';
@@ -94,7 +98,7 @@ export type { ViewContext, ViewSnapshot } from './views/context.js';
 export { createAppToolkit } from './factory.js';
 export type { AppToolkit, AppToolkitRead, AppToolkitWrite, AppToolkitInternals, AppToolkitOptions } from './factory.js';
 
-// ── DTO（api.md §3 字段级单源——34 类型；agtcodingbox/tbox-ai-coding import type 消费）──
+// ── DTO（api.md §3 字段级单源——36 类型；agtcodingbox/tbox-ai-coding import type 消费）──
 export type {
   ServiceStatus,
   BindingLayer,
@@ -104,8 +108,10 @@ export type {
   ModuleDetailView,
   AppView,
   ServiceDetail,
+  ServiceIntegrationSchemas,
   ProviderBinding,
   LayerIntegrationSchemas,
+  IntegrationFieldRegistryView,
   CredentialsView,
   CredentialBindingEcho,
   CredentialTypesView,

package/src/integrations/credentials.ts

@@ -141,7 +141,7 @@ export function reconcileOrphanCredentials(appDir: string): OrphanIssue[] {
     issues.push({
       severity: 'warning',
       code: 'ORPHANED_CREDENTIAL',
-      message: `config/credentials/${stem}.json 不再被引用（凭据文件保留，可手动清理）`,
+      message: `${stemToFilePath(stem)} 不再被引用（凭据文件保留，可手动清理）`,
     });
   }
   return issues;

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/predicate.ts

@@ -481,7 +481,8 @@ export function evaluateIntegrationServices(
   //   不应被 B 厂商判死。引用面（v3）= root.provider ∪ domains.*.provider ∪ 槽级（含内联
   //   .provider）——terse 化后槽级双字段退场，引用面不上移即静默漏检（N2）。
   //   保守跳过条件（无法确证即不判死——误报会阻断部署）：任一引用厂商 configSchema 文件缺失，
-  //   或被绑定但零 configSchema 声明（如 mock local 供给——无 schema 知识）。
+  //   或被绑定但零 configSchema 声明（如 local 供给未声明 configSchema——无 schema 知识。
+  //   注：provider-mock 0.3.0 起全槽带 schema，mock 绑定下本检查已生效）。
   if (vendorConfigKeys) {
     const referenced = new Set<string>();
     let schemaIncomplete = false;

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 };
+}