@tbox.cn/app-toolkit 0.4.0 → 0.5.0

package/src/integrations/predicate.ts

@@ -15,19 +15,24 @@
  *   IMPL_WITHOUT_PROVIDER        #5/#13 error    impl-only（implementation 缺 provider 绑定组头）
  *   INLINE_PROVIDER_INVALID      #5     error    内联厂商声明超受控形状（槽级/实例级）
  *   SCHEMA_FILE_MISSING          #6     error    credentialType schema 引用不存在
- *   DOMAIN_CONFIG_INVALID        #7     error    root/domains 死配置（键 ∉ 引用厂商 schema properties；
+ *   DOMAIN_CONFIG_INVALID        #7     error    root/modules 死配置（键 ∉ 引用厂商 schema properties；
  *                                                api.md DOMAIN_CONFIG_UNUSED 行预留 warning 级，
  *                                                现行为 error 恒等旧谓词——doctor 门控等价）
  *   INSTANCE_KEY_NOT_REGISTERED  #8     error    ByInstance 键/实例键 ∉ 注册表白名单
  *   REALM_SWITCH_HINT            #9     warning  实现覆盖跨厂商（凭据域切换确认）
  *   WILDCARD_ALIGNMENT           #10    warning  通配形态齐步提示
  *   MULTI_INSTANCE_NO_DEFAULT    v4     warning  多实例无 defaultInstanceId（无 scope 访问落全局会话）
- *   VENDOR_NOT_INSTALLED         #11    error    root/domains 厂商未命中已装供给
+ *   VENDOR_NOT_INSTALLED         #11    error    root/modules 厂商未命中已装供给
  *   BINDING_UNRESOLVED           #12    error    绑定不可解析（resolveEffectiveService 求值失败）
- *   DOMAIN_KEY_UNMATCHED         #14    warning  domains 键 ∉ 匹配域集（typo）
+ *   IMPL_WITHOUT_PROVIDER        #5/#13 error    impl-only（implementation 缺 provider 绑定组头）
  *   RESOURCE_TYPE_UNKNOWN        #15    error    modules 资源节 type ∉ 词汇表
  *   RESOURCE_NOT_DECLARED        #16    warning  资源键/资源 id ∉ 模块声明集
+ *   MODULE_CONFIG_DEAD           v6     error    modules[m]（未安装 ∨ owns=0）携带 provider/config
+ *                                                （统一吸收原「#16 升级」特例——P2 一码一义）
+ *   GLOBAL_FIELD_UNDECLARED      #17    warning  全局层键过 #7 但 ∉ 引用厂商 x-tbox-global 并集（G 批；
+ *                                                零声明厂商整体跳过——#7 同遍历双判定，P4）
  *   ORPHANED_CREDENTIAL          写后对账 warning  凭据文件不再被引用（toolkit 写路径产出，非本谓词）
+ *   （v6 退役：DOMAIN_KEY_UNMATCHED #14——domains 键随归属模型退场）
  *
  * 输入形状（调用方负责装载）：
  * - integrations：config/integrations.json 解析产物（宽松 Record 透传——严格 zod 校验归模板 loader）
@@ -44,28 +49,31 @@
  *    继承绑定（槽级 provider 缺席）经 effective 求值取厂商——supplies 在场时）
  * #5 实例 impl-only 禁止 + 覆盖命中供给（含槽级内联形状；provider-only = 派生位，合法）
  * #6 manifest configSchema/credentialSchema 引用文件存在性（内联与 manifest 绑定同查）
- * #7 root/domains 死配置：root.config/configByInstance/domains[d].config 键 ⊆ 引用厂商（并集）
- *    各槽 schema properties——引用面 = root.provider ∪ domains.*.provider ∪ 槽级（terse 化防退化）
+ * #7 root/modules 死配置：root.config/configByInstance/modules[m].config 键 ⊆ 引用厂商（并集）
+ *    各槽 schema properties——引用面 = root.provider ∪ modules.*.provider ∪ 槽级（terse 化防退化）；
+ *    modules 层 per-module 生效厂商 = resolveModuleBinding 单源（≡ modules[m].provider ?? root.provider）
  * #8 ByInstance/实例键 ∈ malls 白名单（v4：源 = root instances 注册表 ids——参考表在场时
- *    激活；'**' 通配键豁免；注册表缺席 → 跳过；domains 键 = 域前缀非 instanceId，不适用）
+ *    激活；'**' 通配键豁免；注册表缺席 → 跳过；modules 键 = install id 非 instanceId，不适用）
  * #9 实现覆盖跨厂商提示（realm switch——凭据域切换确认）
- * #11 root/domains 厂商未命中已装供给（vendor 集合 = suppliedProviders 键前缀展开）
+ * #11 root/modules 厂商未命中已装供给（vendor 集合 = suppliedProviders 键前缀展开）
  * #12 绑定可解析性：逐 (service, instanceId) 经 contracts resolveEffectiveService 求值
- *     （级联单源复用，谓词零级联实现），binding-unresolved → error（supplies 缺席 → 跳过）
+ *     （级联单源复用，谓词零级联实现；v6 ownerOf=ownership 显式参透传），binding-unresolved → error
  * #13 槽级/实例级 impl-only（implementation 需伴随 provider——provider 是绑定组头；
  *     zod 之外的第二道防线——doctor 读裸 JSON）
- * #14 domains 键 ∈ 匹配域集（已配置槽 ∪ 需求声明的 moduleDomainOf 并集；typo → warning）
- * #15-#16 modules 资源节对账（v5）：type ∉ RESOURCE_TYPE_IDS → error（裸 JSON 预启动反馈）；
- *     键 ∉ 已装模块 id 集 / 资源 id ∉ 模块 manifest contributes.resources 声明集（声明非空时）
- *     → warning（moduleResourceNeeds 缺席 → 需求面检查跳过，M3 降级先例）
+ * MODULE_CONFIG_DEAD：modules[m] 携带 provider/config 且（m ∉ installedModuleIds ∨ ownership
+ *     无任何 service 归属 m）→ error（键级 #16 warning 与本检查可同节点共发——键级 vs 值级不同断言面）
+ * #17（G 批）：与 #7 同遍历双判定（P4）——键 ∈ schema properties 但 ∉ x-tbox-global 并集 →
+ *     warning；引用厂商零全局声明（集空/缺席）→ 该厂商键整体跳过；检查序在 MODULE_CONFIG_DEAD 后
+ * #15-#16 modules 资源节对账（v5 延续）：type ∉ RESOURCE_TYPE_IDS → error；键 ∉ 已装模块 id 集 /
+ *     资源 id ∉ 模块 manifest declare.resources 声明集 → warning
  */
 import type { EvaluationExports } from '../core/contracts-expected.js';
-import { resolveDomainBinding } from './domain-binding.js';
+import { resolveModuleBinding } from './module-binding.js';
 
 /** contracts 注入面（resolver 装配产物运行时视图 = EvaluationExports 求值子集） */
 export type PredicateContracts = Pick<
   EvaluationExports,
-  'resolveEffectiveService' | 'buildSupplyLookup' | 'moduleDomainOf' | 'normalizeInstances' | 'RESOURCE_TYPE_IDS'
+  'resolveEffectiveService' | 'buildSupplyLookup' | 'normalizeInstances' | 'RESOURCE_TYPE_IDS'
 >;
 
 /** 派生查表形状（contracts buildSupplyLookup 产物；结构等价 TIER0 SupplyLookup——谓词零 contracts 静态依赖） */
@@ -74,7 +82,6 @@ export type SupplyLookup = Record<string, readonly string[]>;
 export interface IntegrationServicePredicateInput {
   integrations: {
     provider?: string;
-    domains?: Record<string, { provider?: string; config?: Record<string, unknown> }>;
     config?: Record<string, unknown>;
     configByInstance?: Record<string, Record<string, unknown>>;
     credentialRef?: string;
@@ -93,8 +100,8 @@ export interface IntegrationServicePredicateInput {
     instances?: Array<{ id: string; name?: string; attributes?: Record<string, unknown> }>;
     /** v4 默认实例（normalizeInstances 解析语义：显式 ?? 单候选唯一解） */
     defaultInstanceId?: string | null;
-    /** v5 模块资源绑定（modules 节——宽松透传；严格 zod 归模板 loader） */
-    modules?: Record<string, { resources?: Record<string, { type?: unknown }> }>;
+    /** v6 模块集成位（modules 节三键——宽松透传；严格 zod 归模板 loader） */
+    modules?: Record<string, { provider?: string; config?: Record<string, unknown>; resources?: Record<string, { type?: unknown }> }>;
   };
   /** 已声明供给（`${vendor}\u0000${implementation}` → 槽集合；credentialType 供 #2/#6 绑定侧对齐） */
   suppliedProviders: Record<string, { services: string[]; owner: string; credentialType?: string }>;
@@ -102,12 +109,20 @@ export interface IntegrationServicePredicateInput {
   demandedServices: Record<string, { optional: boolean; owners: string[] }>;
   /** 派生查表（buildSupplyLookup 产物；缺席 → #12 跳过 + #2 继承绑定不查 credentialType） */
   supplies?: SupplyLookup;
+  /** v6 服务归属表（walk.ownership——#12 ownerOf 透传 + MODULE_CONFIG_DEAD owns=0 判据；
+   *  缺席 = 归属面不可判 → MODULE_CONFIG_DEAD 退化为仅「未安装」分支） */
+  ownership?: Record<string, string>;
+  /** v6 已装模块 id 集（.tbox/app.json entry.id ∪ packages/ 目录名；缺席 → 「未安装」分支跳过） */
+  installedModuleIds?: ReadonlySet<string>;
   /** malls 白名单（deployments 控制面 extract；缺席 → ByInstance 键检查跳过） */
   malls?: string[];
   /** credentialType → schema 文件引用缺失（manifest 声明指向缺失文件；#6） */
   credentialSchemaMissing?: Record<string, boolean>;
   /** 厂商 → 槽 schema properties 键集（#7 用；调用方从 manifest configSchema 引用解析） */
   vendorConfigKeys?: Record<string, Set<string>>;
+  /** G 批：厂商 → x-tbox-global 标记键集（#17 用；#7 同循环收集——零新增 IO）；
+   *  缺席/空集 = 该厂商零声明 → #17 对其键整体跳过 */
+  vendorGlobalConfigKeys?: Record<string, Set<string>>;
   /** 厂商 → configSchema 引用文件缺失（#7 跳过该厂商——无 schema 不能判死配置） */
   vendorConfigSchemaMissing?: Record<string, boolean>;
   /** 凭据文件缺失（#1：credentialRef stem → 档内 credentials/<stem>.json 在场；域中立注入） */
@@ -116,7 +131,7 @@ export interface IntegrationServicePredicateInput {
   credentialFileType?: Record<string, string | undefined>;
   /** #9：实现覆盖跨厂商提示位（CLI 侧组装） */
   realmSwitchHints?: string[];
-  /** v5：已装模块 id → manifest contributes.resources 声明 id 集（值空集 = 无声明，资源级跳过；
+  /** v5：已装模块 id → manifest declare.resources 声明 id 集（值空集 = 无声明，资源级跳过；
    *  缺席 = 无需求面信息——键未知/资源未声明检查跳过，type 检查恒跑） */
   moduleResourceNeeds?: Record<string, ReadonlySet<string>>;
 }
@@ -189,7 +204,7 @@ export function evaluateIntegrationServices(
 ): IntegrationServiceIssue[] {
   const issues: IntegrationServiceIssue[] = [];
   const contracts = input.contracts;
-  const { integrations, suppliedProviders, demandedServices, supplies, malls, credentialSchemaMissing, vendorConfigKeys, vendorConfigSchemaMissing, credentialFileMissing, credentialFileType, realmSwitchHints, moduleResourceNeeds } = input;
+  const { integrations, suppliedProviders, demandedServices, supplies, malls, credentialSchemaMissing, vendorConfigKeys, vendorGlobalConfigKeys, vendorConfigSchemaMissing, credentialFileMissing, credentialFileType, realmSwitchHints, moduleResourceNeeds, ownership, installedModuleIds } = input;
 
   // #8 白名单索引（malls 缺席 → 跳过 ByInstance 键检查）
   const mallsIndex = malls ? new Set(malls) : undefined;
@@ -230,10 +245,11 @@ export function evaluateIntegrationServices(
     }
     const ct = (service.provider as Record<string, unknown> | undefined)?.credentialType;
     if (typeof ct === 'string') return ct;
-    // v3 继承绑定：effective 求值取 (provider, implementation)（supplies 在场才可判）
+    // v3 继承绑定：effective 求值取 (provider, implementation)（supplies 在场才可判；
+    // v6 ownerOf=ownership 显式参——modules 层绑定纳入求值）
     if (!supplies) return undefined;
     const sk = instanceId ?? Object.keys(service.instances ?? {})[0] ?? '';
-    const r = contracts.resolveEffectiveService(integrations as never, serviceId, sk, supplies);
+    const r = contracts.resolveEffectiveService(integrations as never, serviceId, sk, supplies, ownership);
     if (r.status !== 'ok' || typeof r.effective.provider !== 'string') return undefined;
     return suppliedProviders[providerKey(r.effective.provider, r.effective.implementation)]?.credentialType;
   };
@@ -415,18 +431,18 @@ export function evaluateIntegrationServices(
     }
   }
 
-  // #11：root/domains 厂商存在性（继承层声明必须命中已装供给——vendor 集合 = 供给键前缀展开；
+  // #11：root/modules 厂商存在性（继承层声明必须命中已装供给——vendor 集合 = 供给键前缀展开；
   //   槽级内联声明不在本检查范围——F5 先声明后实施闭环归 #2/#6 形状检查）
   for (const [where, vendor] of [
     ['root', integrations.provider],
-    ...Object.entries(integrations.domains ?? {}).map(([d, cfg]): [string, string | undefined] => [`domains.${d}`, cfg?.provider]),
+    ...Object.entries(integrations.modules ?? {}).map(([m, cfg]): [string, string | undefined] => [`modules.${m}`, cfg?.provider]),
   ] as Array<[string, string | undefined]>) {
     if (typeof vendor !== 'string' || vendor.length === 0) continue;
     if (!installedVendors.has(vendor)) {
       issues.push({
         severity: 'error',
         code: 'VENDOR_NOT_INSTALLED',
-        module: where.startsWith('domains.') ? where.slice('domains.'.length) : undefined,
+        module: where.startsWith('modules.') ? where.slice('modules.'.length) : undefined,
         message: `integrations: ${where} provider ${vendor} 未命中已装供给——装对应 provider 包或 provider use 改绑`,
       });
     }
@@ -434,12 +450,13 @@ export function evaluateIntegrationServices(
 
   // #12：绑定可解析性（级联单源复用 contracts resolveEffectiveService——谓词零级联实现；
   //   supplies 缺席 → 整体跳过，M3 降级兼容 F5 页面无 catalog 形态。
-  //   v4：instances 键缺席槽 = 通配激活——以 '' 探测求值（继承链可解析性仍需覆盖））
+  //   v4：instances 键缺席槽 = 通配激活——以 '' 探测求值（继承链可解析性仍需覆盖）；
+  //   v6：ownership 作 ownerOf 显式参透传——modules 层绑定/配置纳入求值与 fail-visible）
   if (supplies) {
     for (const [serviceId, service] of Object.entries(integrations.services)) {
       const instanceIds = service.instances ? Object.keys(service.instances) : [''];
       for (const instanceId of instanceIds) {
-        const r = contracts.resolveEffectiveService(integrations as never, serviceId, instanceId, supplies);
+        const r = contracts.resolveEffectiveService(integrations as never, serviceId, instanceId, supplies, ownership);
         if (r.status === 'binding-unresolved') {
           issues.push({ severity: 'error', code: 'BINDING_UNRESOLVED', service: serviceId, instance: instanceId || undefined, message: `integrations: ${r.message}` });
         }
@@ -459,30 +476,40 @@ export function evaluateIntegrationServices(
     }
   }
 
-  // #14：domains 键 ∈ 匹配域集（已配置槽 ∪ 需求声明的 moduleDomainOf 并集；
-  //   typo 域 = 永不生效的静默死配置 → warning 级，staged 域（先行声明）不告警）
-  const matchedDomains = new Set<string>([
-    ...Object.keys(integrations.services).map((s) => contracts.moduleDomainOf(s)),
-    ...Object.keys(demandedServices).map((s) => contracts.moduleDomainOf(s)),
-  ]);
-  for (const d of Object.keys(integrations.domains ?? {})) {
-    if (!matchedDomains.has(d)) {
+  // MODULE_CONFIG_DEAD（v6）：modules[m] 携带 provider/config 且（未安装 ∨ owns=0）→ error。
+  // 统一定义吸收原「#16 升级」特例（P2 一码一义）；与 #16 可同节点共发（键级 vs 值级不同断言面）。
+  // 依赖面双保险：installedModuleIds/ownership 缺席 → 对应分支跳过（谓词纯函数——面信息由调用方喂）。
+  for (const [moduleId, cfg] of Object.entries(integrations.modules ?? {})) {
+    const carriesBinding = cfg?.provider !== undefined || cfg?.config !== undefined;
+    if (!carriesBinding) continue;
+    const notInstalled = installedModuleIds ? !installedModuleIds.has(moduleId) : false;
+    let ownsCount = 0;
+    if (ownership) {
+      for (const owner of Object.values(ownership)) if (owner === moduleId) ownsCount += 1;
+    }
+    const ownsUnknown = ownership === undefined;
+    if (notInstalled || (!ownsUnknown && ownsCount === 0)) {
+      const why = notInstalled ? '未安装（键 = install id）' : '未声明任何 owns（无模块级配置位）';
       issues.push({
-        severity: 'warning',
-        code: 'DOMAIN_KEY_UNMATCHED',
-        module: d,
-        message: `integrations: domains.${d} 无对应槽位或需求声明（域前缀拼写错误？——键 = 槽位 id 点分前缀）`,
+        severity: 'error',
+        code: 'MODULE_CONFIG_DEAD',
+        module: moduleId,
+        message: `integrations: modules.${moduleId} 携带 provider/config 但模块${why}（MODULE_CONFIG_DEAD——模块级集成位作用于 declare.owns 服务，改 declare.owns 或删除该节点）`,
       });
     }
   }
 
-  // #7：root/domains 死配置 —— root.config/configByInstance/domains[d].config 键 ⊆ 引用厂商
+  // #7：root/modules 死配置 —— root.config/configByInstance/modules[m].config 键 ⊆ 引用厂商
   //   （跨厂商取并集）各槽 schema properties 键集。并集语义：混布部署中属 A 厂商的 root 键
-  //   不应被 B 厂商判死。引用面（v3）= root.provider ∪ domains.*.provider ∪ 槽级（含内联
-  //   .provider）——terse 化后槽级双字段退场，引用面不上移即静默漏检（N2）。
+  //   不应被 B 厂商判死。引用面（v3 延续 + v6 面）= root.provider ∪ modules.*.provider ∪
+  //   槽级（含内联 .provider）——terse 化后槽级双字段退场，引用面不上移即静默漏检（N2）。
   //   保守跳过条件（无法确证即不判死——误报会阻断部署）：任一引用厂商 configSchema 文件缺失，
   //   或被绑定但零 configSchema 声明（如 local 供给未声明 configSchema——无 schema 知识。
-  //   注：provider-mock 0.3.0 起全槽带 schema，mock 绑定下本检查已生效）。
+  //   注：provider-mock 0.5.0 起零 configSchema（保守跳过）；config 检查对 mocktest 绑定
+  //   生效（全槽 schema——2026-09-20 拆分迁入 provider-mocktest）。
+  // #17（G 批，与 #7 同遍历双判定 P4）：键 ∈ schema properties 但 ∉ 该层生效厂商
+  //   x-tbox-global 并集 → GLOBAL_FIELD_UNDECLARED warning；生效厂商零声明（集空/缺席）→
+  //   整体跳过（零声明厂商不告警）。检查序：#7 判定先行，过 #7 才进 #17（N5）。
   if (vendorConfigKeys) {
     const referenced = new Set<string>();
     let schemaIncomplete = false;
@@ -494,7 +521,7 @@ export function evaluateIntegrationServices(
       if (vendorConfigSchemaMissing?.[vendor]) schemaIncomplete = true;
     };
     noteVendor(integrations.provider);
-    for (const cfg of Object.values(integrations.domains ?? {})) noteVendor(cfg?.provider);
+    for (const cfg of Object.values(integrations.modules ?? {})) noteVendor(cfg?.provider);
     for (const slot of Object.values(integrations.services)) {
       const inline = slot.provider as Record<string, unknown> | undefined;
       noteVendor(typeof slot.provider === 'string' ? slot.provider : inline?.provider as string | undefined);
@@ -502,7 +529,10 @@ export function evaluateIntegrationServices(
     if (referenced.size > 0 && !schemaIncomplete) {
       const allowed = new Set<string>();
       for (const v of referenced) for (const k of vendorConfigKeys[v] ?? []) allowed.add(k);
-      const checkLayer = (layer: Record<string, unknown> | undefined, where: string, allowedKeys?: Set<string>): void => {
+      // 全局并集（root 层）：引用厂商 x-tbox-global 键并集；空 = 全体零声明 → root 层 #17 跳过
+      const globalUnion = new Set<string>();
+      for (const v of referenced) for (const k of vendorGlobalConfigKeys?.[v] ?? []) globalUnion.add(k);
+      const checkLayer = (layer: Record<string, unknown> | undefined, where: string, allowedKeys?: Set<string>, globalKeys?: Set<string>): void => {
         for (const [k] of Object.entries(layer ?? {})) {
           if (!(allowedKeys ?? allowed).has(k)) {
             issues.push({
@@ -510,24 +540,34 @@ export function evaluateIntegrationServices(
               code: 'DOMAIN_CONFIG_INVALID',
               message: `integrations: ${where} 键 ${k} 不在引用厂商（${[...referenced].join('/')}）任何槽 schema properties 内（死配置）`,
             });
+          } else if (globalKeys && globalKeys.size > 0 && !globalKeys.has(k)) {
+            // #17：过 #7 但未声明全局——仅表单收窄提示（已配置值全链保全，解析不拒）
+            issues.push({
+              severity: 'warning',
+              code: 'GLOBAL_FIELD_UNDECLARED',
+              message: `integrations: ${where} 键 ${k} 过 schema 校验但未声明 x-tbox-global（不进应用/模块全局表单；已配置值照常生效——如需全局编辑请在 provider schema 标记）`,
+            });
           }
         }
       };
-      checkLayer(integrations.config, 'root.config');
-      for (const [k, v] of Object.entries(integrations.configByInstance ?? {})) checkLayer(v, `root.configByInstance[${k}]`);
-      // 域级 config：键 ⊆ 该域生效厂商 schema（resolveDomainBinding 单源——v4.4 F1 等价重构，
-      // 语义 ≡ 现状 domains[d].provider ?? root.provider）——生效厂商缺席（全走槽级覆盖）→
-      // 用全局并集；生效厂商 schema 缺失 → 跳过该域
-      for (const [d, cfg] of Object.entries(integrations.domains ?? {})) {
+      checkLayer(integrations.config, 'root.config', undefined, globalUnion);
+      for (const [k, v] of Object.entries(integrations.configByInstance ?? {})) {
+        checkLayer(v, `root.configByInstance[${k}]`, undefined, globalUnion);
+      }
+      // 模块层 config：键 ⊆ 该模块生效厂商 schema（resolveModuleBinding 单源——v6 语义
+      // ≡ modules[m].provider ?? root.provider）——生效厂商缺席（全走槽级覆盖）→
+      // 用全局并集；生效厂商 schema 缺失 → 跳过该模块
+      for (const [m, cfg] of Object.entries(integrations.modules ?? {})) {
         if (!cfg?.config) continue;
-        const domainVendor = resolveDomainBinding(integrations, d).provider ?? undefined;
-        if (domainVendor === undefined) {
-          checkLayer(cfg.config, `domains.${d}.config`);
+        const moduleVendor = resolveModuleBinding(integrations as never, m).provider ?? undefined;
+        if (moduleVendor === undefined) {
+          checkLayer(cfg.config, `modules.${m}.config`, undefined, globalUnion);
           continue;
         }
-        const vendorKeys = vendorConfigKeys[domainVendor];
-        if (!vendorKeys || vendorConfigSchemaMissing?.[domainVendor]) continue;
-        checkLayer(cfg.config, `domains.${d}.config`, new Set(vendorKeys));
+        const vendorKeys = vendorConfigKeys[moduleVendor];
+        if (!vendorKeys || vendorConfigSchemaMissing?.[moduleVendor]) continue;
+        const vendorGlobals = vendorGlobalConfigKeys?.[moduleVendor];
+        checkLayer(cfg.config, `modules.${m}.config`, new Set(vendorKeys), vendorGlobals);
       }
     }
   }
@@ -585,7 +625,7 @@ export function evaluateIntegrationServices(
           severity: 'warning',
           code: 'RESOURCE_NOT_DECLARED',
           module: moduleId,
-          message: `integrations: modules.${moduleId}.resources.${resourceId} 未被模块 manifest contributes.resources 声明`,
+          message: `integrations: modules.${moduleId}.resources.${resourceId} 未被模块 manifest declare.resources 声明`,
         });
       }
     }

package/src/integrations/prune-bindings.ts

@@ -6,7 +6,6 @@ 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';
@@ -16,14 +15,16 @@ import { evaluateAppIntegrationIssues } from './evaluate-app.js';
  *
  * 不变式：**删除判据 ≡ doctor integration-services 报错判据（构造性同源）**——消费 doctor 同一
  * 共享求值器 evaluateAppIntegrationIssues 的结构化 issue，code 白名单
- * {VENDOR_NOT_INSTALLED, BINDING_UNRESOLVED} + 守卫（绑定引用链候选 provider ∈ installedVendors
- * 即保留，排除活厂商错配）→ 删除域严格 = "供给载体消亡"。
+ * {VENDOR_NOT_INSTALLED, BINDING_UNRESOLVED, MODULE_CONFIG_DEAD} + 守卫（绑定引用链候选
+ * provider ∈ installedVendors 即保留，排除活厂商错配）→ 删除域严格 = "供给载体消亡"。
+ * v6：模块卸载 → modules[m] **整节点确定性清理**（provider+config+resources——D4：
+ * 模块消亡清理 vs 集成位编辑保全不矛盾；MODULE_CONFIG_DEAD 为判据源）。
  *
  * 由此推论（均已实证）：需求侧孤儿绑定（demand 消失、供给在场）保留——doctor 判其合法；用户
  * 预配置绑定受保护；一次 remove 自愈全文件历史死债；凭据类 issue（CREDENTIAL_FILE_MISSING 等）
  * 刻意不进白名单，原样保留。
  *
- * 写侧三防线（镜像 write core）：N1 归一化（空模块节点删 domains 键）→ parseIntegrationsConfig
+ * 写侧三防线（镜像 write core）：归一化（空节点删键）→ parseIntegrationsConfig
  * 严格校验（失败弃写）→ writeAtomic。凭据孤儿只报告不清理（D9——与 DELETE 管线现行为一致）。
  * 全空（无任何存活绑定）→ 删文件——ensureMockBindings（缺席即生成）在重装供给时再生闭环。
  *
@@ -43,7 +44,6 @@ export interface PruneResult {
 /** 宽松形状（谓词输入同族子集——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;
@@ -102,7 +102,9 @@ export async function pruneIntegrationBindings(appDir: string): Promise<PruneRes
     return { removed: [], orphanCredentials: [], skipped: 'predicate-unavailable' };
   }
 
-  const installedVendors = new Set(Object.keys(walkManifests(appDir).catalog.providers));
+  const walk = walkManifests(appDir);
+  const installedVendors = new Set(Object.keys(walk.catalog.providers));
+  const walkOwnership = walk.ownership;
   const next = structuredClone(raw) as PruneDoc;
   next.services ??= {};
   const removed: string[] = [];
@@ -111,24 +113,42 @@ export async function pruneIntegrationBindings(appDir: string): Promise<PruneRes
     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
+        // v6：modules[owner].provider 死厂商 → 整节点删除前提下的 provider 键清理；
+        // 仅 provider（无 config/resources）→ 节点删除（N1 归一）
+        const modulesNode = (next.modules ?? {}) as Record<string, Record<string, unknown>>;
+        const node = modulesNode[issue.module];
+        if (node?.provider) {
+          removed.push(`modules.${issue.module}.provider=${String(node.provider)}`);
+          delete node.provider;
+          if (Object.keys(node).length === 0) delete next.modules![issue.module]; // 归一
         }
       } else if (next.provider) {
         removed.push(`root.provider=${next.provider}`);
         delete next.provider;
       }
+    } else if (issue.code === 'MODULE_CONFIG_DEAD' && issue.module) {
+      // v6 D4：模块卸载 → modules[m] 整节点确定性清理（provider+config+resources）
+      const modulesNode = (next.modules ?? {}) as Record<string, Record<string, unknown>>;
+      if (modulesNode[issue.module]) {
+        const node = modulesNode[issue.module];
+        const parts = [
+          node.provider !== undefined ? 'provider' : undefined,
+          node.config !== undefined ? 'config' : undefined,
+          node.resources !== undefined ? 'resources' : undefined,
+        ].filter(Boolean);
+        removed.push(`modules.${issue.module}（${parts.join('+')} 整节点）`);
+        delete next.modules![issue.module];
+      }
     } else if (issue.code === 'BINDING_UNRESOLVED' && issue.service) {
       const s = next.services[issue.service];
       if (!s) continue;
-      // 守卫：引用链任一候选 ∈ installedVendors → 活厂商错配，保留（doctor 报错语义不变）
+      // 守卫：引用链任一候选 ∈ installedVendors → 活厂商错配，保留（doctor 报错语义不变；
+      // v6 引用链 = 实例级/槽级/modules[ownerOf]/root 四层）
+      const owner = walkOwnership[issue.service];
       const candidates = [
         issue.instance ? providerOf(s.instances?.[issue.instance]?.provider) : undefined,
         providerOf(s.provider),
-        providerOf(next.domains?.[domainOfService(issue.service)]?.provider),
+        owner !== undefined ? providerOf((next.modules as Record<string, { provider?: unknown }> | undefined)?.[owner]?.provider) : undefined,
         providerOf(next.provider),
       ].filter((v): v is string => typeof v === 'string');
       if (candidates.some((v) => installedVendors.has(v))) continue;
@@ -151,7 +171,6 @@ export async function pruneIntegrationBindings(appDir: string): Promise<PruneRes
   // 全空判定先行（**先于严格校验**——空文档 `{}` 缺必填 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 &&

package/src/integrations/write.ts

@@ -19,8 +19,9 @@ import {
 import type { IntegrationServiceIssue } from './predicate.js';
 import { checkInstanceKeys } from './predicate.js';
 import { isKnownService } from './read.js';
-import { displayOwnerName, moduleDomainWritable } from './domain-binding.js';
+import { moduleOwnershipWritable } from './module-binding.js';
 import { AppToolkitError } from '../core/errors.js';
+import { MODULE_INTEGRATION_NODE_KEYS } from '../dto.js';
 
 /**
  * 写核心（C3-4 write；FX-1c 管线重排——F3 九步定序 + D-B2 语义 + F4 输入扩位）：
@@ -231,7 +232,8 @@ export interface WriteCore {
   warmup(): Promise<void>;
   /** PUT /app/integration（root 节点全集） */
   applyApp(node: Record<string, unknown>, opts?: WriteOptions): SaveResult;
-  /** PUT /modules/:module/integration（domains 换算；N1 {} 删域键；v4.4 D34 写守卫单源） */
+  /** PUT /modules/:module/integration（v6 modules[owner] 集成位；键集纪律见 MODULE_INTEGRATION_NODE_KEYS；
+   *  N1 {} 清 provider/config 保 resources；moduleOwnershipWritable 写守卫单源） */
   applyModule(moduleId: string, node: Record<string, unknown>, opts?: WriteOptions): SaveResult;
   /** PUT /services/:service/integration（整节点含 instances map；N3 {} 不归一化；v4.4 A2 身份判据） */
   applyService(service: string, node: Record<string, unknown>, opts?: WriteOptions): SaveResult;
@@ -336,7 +338,7 @@ export function createWriteCore(appDir: string, opts: WriteCoreOptions = {}): Wr
           message: 'config/integrations.json 缺席——已物化骨架（写时自动初始化；R13 语义翻转提示）',
         });
       }
-      // root 全量替换（D14 无例外语义）：缺席根键删除（services/domains/modules 域不在根键集——随 base 保留），
+      // root 全量替换（D14 无例外语义）：缺席根键删除（services/modules 域不在根键集——随 base 保留；v6 domains 键已退役），
       // node 全键置入（未知键交严格 zod 拒——fail-visible；B10：原实现 spread+merge 残留 stale 根键）
       const next: Record<string, unknown> = { ...base };
       for (const k of APP_INTEGRATION_NODE_KEYS) if (!(k in node)) delete next[k];
@@ -370,37 +372,27 @@ export function createWriteCore(appDir: string, opts: WriteCoreOptions = {}): Wr
 
     applyModule(moduleId: string, node: Record<string, unknown>, writeOpts: WriteOptions = {}): SaveResult {
       assertSafeNames(node, 'root');
-      // D34 写守卫（v4.4，moduleDomainWritable 单源）：404（模块在册）→ 400（多域/零域/共享键
-      // 三分支）→ 既有管线。守卫先于 no-op 短路——多域/零域/共享键模块 PUT {} 清域同 400
-      // （「写路径拒绝歧义操作」含清除；P13/P17）。
-      const { modules, catalog } = walkManifests(appDir, cache);
+      // v6 写守卫（moduleOwnershipWritable 单源）：404（模块在册）→ 400（zero-ownership——
+      // 模块级集成位作用于 declare.owns 服务，零归属模块无配置位）→ 既有管线。
+      // 守卫先于 no-op 短路——零归属模块 PUT {} 清位同 400（「写路径拒绝歧义操作」含清除）。
+      const { modules, catalog, ownership } = walkManifests(appDir, cache);
       const mod = modules.find((m) => m.id === moduleId);
       if (!mod) {
         throw new AppToolkitError('MODULE_NOT_FOUND', 404, `模块 ${moduleId} 非已装模块`);
       }
-      const w = moduleDomainWritable({ modules, catalog }, mod);
+      const w = moduleOwnershipWritable({ modules, catalog, ownership }, mod);
       if (!w.writable) {
-        if (w.reason === 'multi-domain') {
-          throw new AppToolkitError(
-            'VALIDATION_FAILED',
-            400,
-            `模块 ${moduleId} 跨 ${w.domainKeys.length} 个域（${w.domainKeys.join('、')}）——模块级统一配置仅支持单域模块，请按服务级配置（编辑各服务行）`,
-          );
-        }
-        if (w.reason === 'zero-domain') {
-          throw new AppToolkitError('VALIDATION_FAILED', 400, `模块 ${moduleId} 无服务需求声明，无域配置位`);
-        }
         throw new AppToolkitError(
           'VALIDATION_FAILED',
           400,
-          `域键 ${w.domainKey} 由 ${w.coOwners.map((o) => displayOwnerName(modules, o)).join('、')} 共用——写通道拒绝歧义操作，请按服务级配置`,
+          `模块 ${moduleId} 未声明任何 declare.owns——无模块级配置位（模块级 provider/config 作用于归属服务）`,
         );
       }
-      const domainKey = w.domainKey;
       const issues: IntegrationServiceIssue[] = [];
       const current = loadConfig(appDir, cache);
+      // N2 语义（v6）：空节点 = 清 provider/config 两键，resources 随既有节点保全；
+      // 文件缺席 + 空节点 = no-op（幂等）
       if (current === null && Object.keys(node).length === 0) {
-        // 空文件清空域 = no-op（N1 幂等）
         return { written: false, restartScheduled: false, files: [], credentials: [], issues };
       }
       if (current === null) {
@@ -411,15 +403,39 @@ export function createWriteCore(appDir: string, opts: WriteCoreOptions = {}): Wr
         });
       }
       const base: Record<string, unknown> = current ?? { services: {} };
-      const domains = { ...((base.domains as Record<string, unknown>) ?? {}) };
-      const next: Record<string, unknown> = { ...base, domains };
-      // N1：模块节点 {} → 删 domains[键]（清域）；其余 = 域键全量替换
-      if (Object.keys(node).length === 0) delete domains[domainKey];
-      else domains[domainKey] = { ...node };
+      const modulesNode = { ...((base.modules as Record<string, unknown>) ?? {}) };
+      const existing = { ...((modulesNode[moduleId] as Record<string, unknown> | undefined) ?? {}) };
+      // 键集纪律：node 内仅接受 MODULE_INTEGRATION_NODE_KEYS 成员（未知键交严格 zod 拒——fail-visible）
+      for (const k of Object.keys(node)) {
+        if (!(MODULE_INTEGRATION_NODE_KEYS as readonly string[]).includes(k)) {
+          throw new AppToolkitError(
+            'VALIDATION_FAILED',
+            400,
+            `模块集成位仅接受 ${MODULE_INTEGRATION_NODE_KEYS.join('/')} 键（收到 ${k}）`,
+            [k],
+          );
+        }
+      }
+      // 全量替换（键集内）：缺席键删除；空对象/空串值 = 删除（≡ 缺席——模块节点不留空键）；
+      // PUT {} = 清 provider/config，resources 恒随 existing 保全（N2：清集成位不杀资源绑定）
+      const nextNode: Record<string, unknown> = { ...existing };
+      for (const k of MODULE_INTEGRATION_NODE_KEYS) {
+        const v = node[k];
+        const isEmptyish = v === undefined || v === null || v === ''
+          || (typeof v === 'object' && !Array.isArray(v) && Object.keys(v as object).length === 0);
+        if (isEmptyish) delete nextNode[k];
+        else nextNode[k] = v;
+      }
+      if (Object.keys(nextNode).length === 0) {
+        delete modulesNode[moduleId];
+      } else {
+        modulesNode[moduleId] = nextNode;
+      }
+      const next: Record<string, unknown> = { ...base, modules: modulesNode };
       if (deepEqual(current, next)) {
         return { written: false, restartScheduled: false, files: [], credentials: [], issues };
       }
-      runStrictValidation(next, issues, `domains.${domainKey}.`);
+      runStrictValidation(next, issues, `modules.${moduleId}.`);
       issues.push(...registryCheck(next));
       return finalize(next, [], issues, writeOpts.dryRun);
     },

package/src/views/app.ts

@@ -5,21 +5,21 @@ import { moduleOccupiedServices, resolveServiceDisplay, type ViewSnapshot } from
 /**
  * 应用静态投影（views/app；C4；FX-1c B10——root 节点投影修；v4.4 D29——services 双端点同型）。
  * /app = 平台服务 + root 节点原值（纯静态）：services = 服务词汇 − 模块占用
- * （ServiceDemand[]——平台条目 required 恒 false、title/description 缺席，D29）；
+ * （ServiceDemand[]——平台条目 required 恒 false、name/description 缺席，D29）；
  * 平台服务状态不在此（→ /service-resolutions）；模块服务不在此（→ /modules/:m）。
  * integration = **root 节点投影**（APP_INTEGRATION_NODE_KEYS——D21/L1：GET 预填 ≡ PUT body；
- * 文件另含 services/domains/modules 域键，不进 root 节点投影——原实现整文件透传，
+ * 文件另含 services/modules 域键，不进 root 节点投影——原实现整文件透传，
  * PUT 回会级联写回域键）；文件缺席 = null，文件在场 → 投影对象（可为空）。
  */
 
 export function loadAppView(snapshot: ViewSnapshot): AppView {
   const occupied = moduleOccupiedServices(snapshot.walk);
-  // 平台条目展示名走链（B1）：词汇 meta > demand meta > id——title 恒发（id 兜底内聚）
+  // 平台条目展示名走链（B1）：词汇 meta > demand meta > id——name 恒发（id 兜底内聚）
   const services: ServiceDemand[] = snapshot.walk.vocabulary
     .filter((s) => !occupied.has(s))
     .map((s) => {
       const display = resolveServiceDisplay(snapshot.walk, s);
-      return { service: s, title: display.title, ...(display.description !== undefined ? { description: display.description } : {}), required: false };
+      return { service: s, name: display.name, ...(display.description !== undefined ? { description: display.description } : {}), required: false };
     });
   const config = snapshot.integrations;
   let integration: AppView['integration'] = null;