@tbox.cn/app-toolkit 0.3.0 → 0.5.0

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/mock-bindings.ts

@@ -29,7 +29,7 @@ export function ensureMockBindings(appDir: string): MockBindingsResult {
   }
   const slots: Array<{ service: string; provider: string; implementation: string }> = [];
   for (const mod of walkManifests(appDir).modules) {
-    for (const slot of mod.descriptor.contributes.providers?.slots ?? []) {
+    for (const slot of mod.descriptor.declare.providers?.slots ?? []) {
       if (slot.local !== true) continue;
       slots.push({ service: slot.service, provider: slot.provider, implementation: slot.implementation });
     }

package/src/integrations/module-binding.ts

@@ -0,0 +1,60 @@
+import { walkManifests, type WalkCatalog, type WalkManifestsResult, type WalkModuleInfo } from '../assembly/walk-manifests.js';
+
+/**
+ * 模块级联绑定单源（integrations v6 所有权模型——原 domain-binding.ts v4.4 F1/F3 重写）。
+ * integrations 层落位依据：谓词（同层）/ 写核（同层）/ views（下层可向上 import）三向消费
+ * 的唯一公共下层；import 前缀 guard 覆盖。
+ *
+ * 知识锚（module-tab note 单源锚表，v6 形态）：
+ *   模块级联（值 + 层） = resolveModuleBinding —— 谓词 #7（per-module 生效厂商 ≡
+ *                        `modules[m].provider ?? root.provider`）/ deriveBindingLayer 模块级段 /
+ *                        buildInheritance module 段 / binding（单数）
+ *   归属表             = walk.ownership（单源聚合产物；buildOwnershipMap 桥直通——
+ *                        registry 显式参 / 谓词 / 写守卫 / views 四消费方零第二实现）
+ *   来源层四层推导     = deriveBindingLayer（views/service-resolutions，模块级段改调本文件）
+ *   写通道可用性       = moduleOwnershipWritable —— configEditable 读标志 / applyModule 400 守卫
+ *                        共用（owns>0 唯一判据——多域归属合法化、共享键/多域判据随 D34 退役）
+ */
+
+/** 归属表构建（walk 单源直通——sdk 桥 re-export 消费；appDir 直入对齐 loadProviderCatalog
+ *  桥工效——模板装配第六行：`ownerOf: buildOwnershipMap(appDir)`）。 */
+export function buildOwnershipMap(appDir: string): Record<string, string> {
+  return walkManifests(appDir).ownership;
+}
+
+/** 模块级联绑定解析（值 + 来源层）：provider 取非空字符串（模块级优先 → root 兜底；空串 = 缺席）。
+ *  layer：modules[moduleId].provider 声明 → 'module'；root 兜底 → 'app'；双缺 → null（binding 双缺诚实态）。 */
+export function resolveModuleBinding(
+  config: Record<string, unknown> | null,
+  moduleId: string,
+): { provider: string | null; layer: 'module' | 'app' | null } {
+  const moduleProvider = (config?.modules as Record<string, { provider?: unknown }> | undefined)?.[moduleId]?.provider;
+  if (typeof moduleProvider === 'string' && moduleProvider.length > 0) {
+    return { provider: moduleProvider, layer: 'module' };
+  }
+  const rootProvider = config?.provider;
+  if (typeof rootProvider === 'string' && rootProvider.length > 0) {
+    return { provider: rootProvider, layer: 'app' };
+  }
+  return { provider: null, layer: null };
+}
+
+/** 模块集成位可写性（v6 判别联合——configEditable 读标志与 applyModule 写守卫共用单源）：
+ *  owns>0 唯一判据（D34 多域/shared-key 判据随 v6 退役——服务归属唯一真源 = declare.owns）。 */
+export type ModuleOwnershipWritability =
+  | { writable: true; ownedServices: string[] }
+  | { writable: false; reason: 'zero-ownership'; ownedServices: [] };
+
+export function moduleOwnershipWritable(
+  _walk: Pick<WalkManifestsResult, 'modules' | 'catalog' | 'ownership'>,
+  mod: WalkModuleInfo,
+): ModuleOwnershipWritability {
+  const ownedServices = (mod.descriptor.declare.owns ?? []).map((o) => o.service).sort();
+  if (ownedServices.length === 0) return { writable: false, reason: 'zero-ownership', ownedServices: [] };
+  return { writable: true, ownedServices };
+}
+
+/** 供给足迹（该厂商全部供给服务并集——应用级 integrationSchemas 作用域，D32） */
+export function providerFootprint(catalog: WalkCatalog, provider: string): string[] {
+  return [...new Set(Object.values(catalog.providers[provider] ?? {}).flatMap((e) => e.services))].sort();
+}

package/src/integrations/predicate-io.ts

@@ -27,21 +27,26 @@ export interface PredicateIoInputs {
   credentialSchemaMissing: Record<string, boolean>;
   /** #7：厂商 → configSchema properties 键集并集 */
   vendorConfigKeys: Record<string, Set<string>>;
+  /** #17（G 批）：厂商 → x-tbox-global 标记键集（与 vendorConfigKeys 同循环收集——零新增 IO） */
+  vendorGlobalConfigKeys: Record<string, Set<string>>;
   /** #7：厂商 → configSchema 引用缺失（跳过该厂商死配置判定） */
   vendorConfigSchemaMissing: Record<string, boolean>;
   /** #9：实现覆盖跨厂商提示文案（已成形——谓词直投） */
   realmSwitchHints: string[];
   /** #8：root instances 注册表 ids（在场才传；缺席 → 键检查跳过） */
   malls?: string[];
-  /** #15-#16：已装模块 id → manifest contributes.resources 声明 id 集 */
+  /** #15-#16：已装模块 id → manifest declare.resources 声明 id 集 */
   moduleResourceNeeds: Record<string, ReadonlySet<string>>;
 }
 
-/** 装配全产物（= PredicateIoInputs + 供给/需求聚合——喂 evaluateIntegrationServices 的
+/** 装配全产物（= PredicateIoInputs + 供给/需求/归属聚合——喂 evaluateIntegrationServices 的
  *  非 contracts/integrations 入参全集，两消费方 spread 直投，零各自组装） */
 export interface PredicateAssembly extends PredicateIoInputs {
   suppliedProviders: Record<string, { services: string[]; owner: string; credentialType?: string }>;
   demandedServices: Record<string, { optional: boolean; owners: string[] }>;
+  /** v6：服务归属表 + 已装模块 id 集（MODULE_CONFIG_DEAD / #12 ownerOf 透传） */
+  ownership?: Record<string, string>;
+  installedModuleIds?: ReadonlySet<string>;
 }
 
 /** stem → env 键（kebab → UPPER_SNAKE；与 SDK/provider-secret env 兜底同公式） */
@@ -95,19 +100,30 @@ export function buildPredicateAssembly(
     demandedServices[service] = { optional: entry.optional, owners: [...entry.owners] };
   }
 
-  // ── #6/#7 schema 档案 + #15/#16 需求面（manifest 引用 → 存在性 + 键集；双通道）──
+  // ── #6/#7/#17 schema 档案 + #15/#16 需求面（manifest 引用 → 存在性 + 键集；双通道）──
   const vendorConfigKeys: Record<string, Set<string>> = {};
+  const vendorGlobalConfigKeys: Record<string, Set<string>> = {};
   const vendorConfigSchemaMissing: Record<string, boolean> = {};
   const credentialSchemaMissing: Record<string, boolean> = {};
   const moduleResourceNeeds: Record<string, ReadonlySet<string>> = {};
   for (const mod of walk.modules) {
-    moduleResourceNeeds[mod.id] = new Set((mod.descriptor.contributes.resources ?? []).map((r) => r.id));
-    for (const slot of mod.descriptor.contributes.providers?.slots ?? []) {
+    moduleResourceNeeds[mod.id] = new Set((mod.descriptor.declare.resources ?? []).map((r) => r.id));
+    for (const slot of mod.descriptor.declare.providers?.slots ?? []) {
       if (slot.configSchema) {
         const schema = readJsonOrNull(join(mod.dir, slot.configSchema));
         if (schema) {
           const bucket = (vendorConfigKeys[slot.provider] ??= new Set<string>());
+          const globalBucket = (vendorGlobalConfigKeys[slot.provider] ??= new Set<string>());
           for (const k of collectPropertyKeys(schema)) bucket.add(k);
+          // G 批：x-tbox-global 标记键同循环收集（properties[k]['x-tbox-global'] === true）
+          const props = schema.properties;
+          if (props && typeof props === 'object' && !Array.isArray(props)) {
+            for (const [k, v] of Object.entries(props as Record<string, unknown>)) {
+              if (v && typeof v === 'object' && (v as Record<string, unknown>)['x-tbox-global'] === true) {
+                globalBucket.add(k);
+              }
+            }
+          }
         } else {
           vendorConfigSchemaMissing[slot.provider] = true;
         }
@@ -191,9 +207,14 @@ export function buildPredicateAssembly(
     credentialFileType,
     credentialSchemaMissing,
     vendorConfigKeys,
+    vendorGlobalConfigKeys,
     vendorConfigSchemaMissing,
     realmSwitchHints,
     moduleResourceNeeds,
     ...(mallIds.length > 0 ? { malls: mallIds } : {}),
+    // v6：归属面（MODULE_CONFIG_DEAD 判据 + #12 ownerOf 透传——walk 单源直取；
+    // installed 并入归属方——dev 通道模块 manifest id ∉ walk.modules，聚合宽/声明窄 N3）
+    ownership: walk.ownership,
+    installedModuleIds: new Set([...walk.modules.map((m) => m.id), ...new Set(Object.values(walk.ownership))]),
   };
 }

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 声明`,
         });
       }
     }