@tbox.cn/app-toolkit 0.4.0 → 0.5.0

package/src/assembly/walk-manifests.ts

@@ -9,7 +9,7 @@ import { readAppManifestFull, type NpmModuleEntry, type AppManifestFull } from '
  *
  * manifest 候选路径探测（packages/<id>/tbox.module.json 优先 → node_modules/<pkg>/tbox.module.json；
  * tbox-app dev 真身经 .tbox-dev.local/dev-manifest.json redirects 独立 catalog 通道直达）一次遍历同时产出：
- *   1. modules：已装模块清单（declared；demand meta title/description 透传）
+ *   1. modules：已装模块清单（declared；demand meta name/description 透传）
  *   2. catalog（富形态）：providers 嵌套（vendor→impl→entry，per-service {implementation, credentialType}
  *      保真——同厂商异构/多实现合法，D25/H1）+ 需求侧聚合
  *   3. serviceSchemas：per-service schema 复合键表——键 `${provider}\u0000${service}`（H2，同一服务
@@ -20,10 +20,12 @@ import { readAppManifestFull, type NpmModuleEntry, type AppManifestFull } from '
  *      ③ 候选自身 {service-slots.json, src/service-slots.json}（local/codegen 全量副本——
  *      mall 生成应用主形态，不依赖 install）；零缓存枚举，与 manifest 探测同机制；
  *      多行业 contracts-* 天然扩展 F8）；缺席 → []（退化 demanded ∪ configured）
- *   5. slotMeta：词汇 meta 节（per-service {title,description} 展示元数据——消费端兜底链
+ *   5. slotMeta：词汇 meta 节（per-service {name,description} 展示元数据——消费端兜底链
  *      词汇 > demand > id，views/context resolveServiceDisplay 单源）；多包发现序首声明胜出
  *      （与 catalog addSlots 同语义）；contracts-mall 词汇锁保证 mall 域全量覆盖；缺席 → {}
- *   6. domainKeyIssues：跨模块域键冲突 issue（两模块派生同一 domains 键——P13）
+ *   6. ownership：service → moduleId 归属表（v6——declare.owns 聚合；install id 键控；
+ *      双 owner 冲突 → declarationIssues OWNERSHIP_CONFLICT + 先声明胜出）
+ *   7. declarationIssues：声明面诊断（OWNERSHIP_CONFLICT / OLD_MANIFEST_KEY——P3 通道）
  *
  * **约束（D26；FX-3/F7 边界）**：目录枚举零缓存——readdir / node_modules 候选探测 / `.tbox/app.json` 读取 /
  * dev-manifest 读取每次执行（枚举输入保持 fresh——agent 装卸模块下一笔即见）；manifest/service-slots
@@ -32,6 +34,11 @@ import { readAppManifestFull, type NpmModuleEntry, type AppManifestFull } from '
  * 宽松解析语义（坏文件静默 + 重复键首声明保留）零改动。
  */
 
+/** 声明面诊断（v6 P3 通道——OWNERSHIP_CONFLICT / OLD_MANIFEST_KEY；error 级） */
+export type DeclarationIssue =
+  | { severity: 'error'; code: 'OWNERSHIP_CONFLICT'; message: string; module?: string }
+  | { severity: 'error'; code: 'OLD_MANIFEST_KEY'; message: string; module?: string };
+
 export interface WalkManifestsResult {
   /** declared 产物（install id + descriptor；demand meta 透传） */
   modules: WalkModuleInfo[];
@@ -41,15 +48,18 @@ export interface WalkManifestsResult {
   serviceSchemas: Record<string, { configSchema?: string; credentialSchema?: string; packageDir: string }>;
   /** 服务词汇 = 所有携带 service-slots.json 的已装契约包 `.slots` 键并集（缺席 → []） */
   vocabulary: string[];
-  /** 词汇 meta 节：per-service {title,description} 展示元数据（多包首声明胜出；缺席 → {}） */
+  /** 词汇 meta 节：per-service {name,description} 展示元数据（多包首声明胜出；缺席 → {}） */
   slotMeta: Record<string, SlotMeta>;
-  /** 跨模块域键冲突（P13——两模块的 service 集派生同一 domains 键） */
-  domainKeyIssues: Array<{ severity: 'warning'; code: 'DOMAIN_KEY_CONFLICT'; message: string; module?: string }>;
+  /** v6 服务归属表：service → moduleId（install id 键控——integrations modules 节键同轴；
+   *  双 owner 冲突 → declarationIssues + 先声明胜出；dev 通道以 manifest id 参与归属） */
+  ownership: Record<string, string>;
+  /** 声明面诊断（OWNERSHIP_CONFLICT / OLD_MANIFEST_KEY） */
+  declarationIssues: DeclarationIssue[];
 }
 
-/** 槽位展示元数据（service-slots.json meta 节元素——宽松提取，字段皆可选） */
+/** 槽位展示元数据（service-slots.json meta 节元素——宽松提取，字段皆可选；v7 词汇统一 title→name） */
 export interface SlotMeta {
-  title?: string;
+  name?: string;
   description?: string;
 }
 
@@ -69,11 +79,11 @@ function parseSlotsFile(raw: string): SlotsFile | null {
     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 { name, description } = entry as { name?: unknown; description?: unknown };
         const m: SlotMeta = {};
-        if (typeof title === 'string' && title.length > 0) m.title = title;
+        if (typeof name === 'string' && name.length > 0) m.name = name;
         if (typeof description === 'string' && description.length > 0) m.description = description;
-        if (m.title !== undefined || m.description !== undefined) meta[svc] = m;
+        if (m.name !== undefined || m.description !== undefined) meta[svc] = m;
       }
     }
     return { slots, meta };
@@ -94,15 +104,15 @@ export interface WalkModuleInfo {
 }
 
 /** 富形态供给条目：per-service {implementation, credentialType} 恒数组保真（H1）；
- *  title/description = 厂商展示元数据（strict manifest descriptor 透传——多包同厂商
- *  首声明胜出，与 owner 同语义；B1 walk 层传播） */
+ *  name/description = 厂商展示元数据（strict manifest descriptor 透传——多包同厂商
+ *  首声明胜出，与 owner 同语义；B1 walk 层传播；v7 词汇统一 title→name） */
 export interface WalkProviderEntry {
   provider: string;
   implementation: string;
   credentialType: string;
   owner: string;
-  /** 厂商展示名（manifest 模块 meta——多包首声明；缺席 = undefined） */
-  title?: string;
+  /** 厂商展示名（manifest name——多包首声明；缺席 = undefined） */
+  name?: string;
   description?: string;
   local?: boolean;
   configSchema?: string;
@@ -117,8 +127,8 @@ export interface WalkCatalog {
     {
       optional: boolean;
       defaults: Array<{ provider: string; implementation: string }>;
-      /** demand meta（title/description 首声明保留——模块 manifest demand 侧 additive） */
-      title?: string;
+      /** demand meta（name/description 首声明保留——模块 manifest demand 侧 additive；v7 title→name） */
+      name?: string;
       description?: string;
       owners: string[];
     }
@@ -126,25 +136,28 @@ export interface WalkCatalog {
   credentialTypes: Record<string, { owner: string; packageDir: string; credentialSchema?: string }>;
 }
 
-/** loose 允许的 contributes 局部结构（本地声明——解跨模块类型身份耦合，TS2719 防线） */
-interface LooseContributes {
+/** loose 允许的 declare 局部结构（本地声明——解跨模块类型身份耦合，TS2719 防线） */
+interface LooseDeclare {
   providers?: { slots?: ProviderSlotContrib[] };
-  services?: Array<{
+  consumes?: Array<{
     service: string;
     optional?: boolean;
     defaults?: Array<{ provider: string; implementation: string }>;
-    title?: string;
+    name?: string;
     description?: string;
   }>;
 }
 
-/** manifest 读取结果（判别联合——strict = 完整 descriptor；loose = 部分形态宽容提取） */
+/** manifest 读取结果（判别联合——strict = 完整 descriptor；loose = 部分形态宽容提取；
+ *  legacy = 旧键（v6 声明面 / v7 词汇统一，parseModuleDescriptor legacy 标志透传）——
+ *  拒 loose 静默兜底，定向 issue）。 */
 type ReadManifestResult =
-  | { kind: 'strict'; name: string; version: string; descriptor: ModuleDescriptor; contributes: ModuleDescriptor['contributes'] }
-  | { kind: 'loose'; name?: string; contributes: LooseContributes };
+  | { kind: 'strict'; id: string; version: string; descriptor: ModuleDescriptor; declare: ModuleDescriptor['declare'] }
+  | { kind: 'loose'; id?: string; declare: LooseDeclare }
+  | { kind: 'legacy'; detail: string };
 
-/** 读单文件 manifest（坏文件 → null；宽松——strict 解析失败但有 contributes → loose 兜底，
- *  保留旧 SDK loadProviderCatalog 对部分形态 manifest 的容忍语义，C3-5 桥等价性）。
+/** 读单文件 manifest（坏文件 → null；宽松——strict 解析失败但为新形态 declare → loose 兜底；
+ *  旧键 → legacy（定向 issue，静默兜底防线——单源 = parseModuleDescriptor legacy 标志）。
  *  FX-3（F7 边界）：**文件内容**经 file-cache（stat 指纹——外部写下一笔自愈）；目录枚举仍零缓存。 */
 function readManifestFile(file: string, cache?: FileCache): ReadManifestResult | null {
   const parse = (raw: string): ReadManifestResult | null => {
@@ -152,17 +165,19 @@ function readManifestFile(file: string, cache?: FileCache): ReadManifestResult |
       const parsedRaw: unknown = JSON.parse(raw);
       const parsed = parseModuleDescriptor(parsedRaw);
       if (parsed.ok) {
-        return { kind: 'strict', name: parsed.value.name, version: parsed.value.version, descriptor: parsed.value, contributes: parsed.value.contributes };
+        return { kind: 'strict', id: parsed.value.id, version: parsed.value.version, descriptor: parsed.value, declare: parsed.value.declare };
       }
-      // loose 兜底：strict 拒（部分形态 manifest——如仅 contributes）但有 contributes → 宽松提取
-      if (parsedRaw && typeof parsedRaw === 'object' && 'contributes' in parsedRaw) {
-        const obj = parsedRaw as { name?: unknown; contributes?: ModuleDescriptor['contributes'] };
+      // 旧键（v6/v7）：parseModuleDescriptor 已定向检测（legacy 标志）——拒 loose 静默兜底
+      if (parsed.legacy) return { kind: 'legacy', detail: parsed.errors.join('; ') };
+      // loose 兜底：strict 拒（部分形态 manifest——如仅 declare）但有新形态 declare → 宽松提取
+      if (parsedRaw && typeof parsedRaw === 'object' && 'declare' in parsedRaw) {
+        const obj = parsedRaw as { id?: unknown; declare?: LooseDeclare };
         return {
           kind: 'loose',
-          ...(typeof obj.name === 'string' ? { name: obj.name } : {}),
-          contributes: {
-            providers: (obj.contributes as LooseContributes | undefined)?.providers,
-            services: (obj.contributes as LooseContributes | undefined)?.services,
+          ...(typeof obj.id === 'string' ? { id: obj.id } : {}),
+          declare: {
+            providers: obj.declare?.providers,
+            consumes: obj.declare?.consumes,
           },
         };
       }
@@ -283,10 +298,9 @@ export function walkManifests(appDir: string, cache?: FileCache): WalkManifestsR
   const modules: WalkModuleInfo[] = [];
   const catalog: WalkCatalog = { providers: {}, services: {}, credentialTypes: {} };
   const serviceSchemas: WalkManifestsResult['serviceSchemas'] = {};
-  const domainKeyIssues: WalkManifestsResult['domainKeyIssues'] = [];
+  const declarationIssues: WalkManifestsResult['declarationIssues'] = [];
+  const ownership: Record<string, string> = {};
   const seen = new Set<string>();
-  /** 域键 → 首个声明模块（P13 冲突检测） */
-  const domainOwners = new Map<string, string>();
 
   const addSlots = (slots: readonly ProviderSlotContrib[], owner: string, packageDir: string, modMeta?: SlotMeta): void => {
     for (const slot of slots) {
@@ -301,7 +315,7 @@ export function walkManifests(appDir: string, cache?: FileCache): WalkManifestsR
           implementation: slot.implementation,
           credentialType: slot.credentialType,
           owner,
-          ...(modMeta?.title ? { title: modMeta.title } : {}),
+          ...(modMeta?.name ? { name: modMeta.name } : {}),
           ...(modMeta?.description ? { description: modMeta.description } : {}),
           ...(slot.local ? { local: true } : {}),
           ...(slot.configSchema ? { configSchema: slot.configSchema } : {}),
@@ -328,10 +342,48 @@ 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;
+    manifest.kind === 'strict' ? { name: manifest.descriptor.name, description: manifest.descriptor.description } : undefined;
+
+  /** v6 归属聚合：declare.owns → ownership 表（先声明胜出；冲突 → OWNERSHIP_CONFLICT）。
+   *  owner 键 = install id（integrations modules 节键同轴——npmModules 通道 = entry.id、
+   *  packages/dev 通道 = manifest id）。 */
+  const addOwns = (services: readonly string[], owner: string): void => {
+    for (const service of services) {
+      const first = ownership[service];
+      if (first === undefined) {
+        ownership[service] = owner;
+      } else if (first !== owner) {
+        declarationIssues.push({
+          severity: 'error',
+          code: 'OWNERSHIP_CONFLICT',
+          module: owner,
+          message: `服务 ${service} 归属冲突：${first} 与 ${owner} 均声明 owns（先声明 ${first} 胜出）——修正 manifest declare.owns 互斥`,
+        });
+      }
+    }
+  };
 
-  const addServiceNeed = (
-    need: { service: string; optional?: boolean; defaults?: Array<{ provider: string; implementation: string }>; title?: string; description?: string },
+  /** 旧键 legacy manifest → 定向 issue（N1：拒 loose 静默兜底）。 */
+  const pushLegacyIssue = (manifest: ReadManifestResult, module: string): void => {
+    if (manifest.kind !== 'legacy') return;
+    declarationIssues.push({
+      severity: 'error',
+      code: 'OLD_MANIFEST_KEY',
+      module,
+      message: `${module}：${manifest.detail}`,
+    });
+  };
+
+  /** declare 提取（strict/loose 双形态统一视图；legacy → null） */
+  const declareOf = (manifest: ReadManifestResult): LooseDeclare | null =>
+    manifest.kind === 'strict'
+      ? manifest.declare
+      : manifest.kind === 'loose'
+        ? manifest.declare
+        : null;
+
+  const addServiceConsume = (
+    need: { service: string; optional?: boolean; defaults?: Array<{ provider: string; implementation: string }>; name?: string; description?: string },
     owner: string,
   ): void => {
     const optional = need.optional !== false;
@@ -353,22 +405,10 @@ export function walkManifests(appDir: string, cache?: FileCache): WalkManifestsR
     catalog.services[need.service] = {
       optional,
       defaults: [...defaults],
-      ...(need.title ? { title: need.title } : {}),
+      ...(need.name ? { name: need.name } : {}),
       ...(need.description ? { description: need.description } : {}),
       owners: [owner],
     };
-    // P13 域键冲突检测（首声明占用；跨模块冲突 → issue）
-    const domain = need.service.includes('.') ? need.service.slice(0, need.service.indexOf('.')) : need.service;
-    const firstOwner = domainOwners.get(domain);
-    if (firstOwner === undefined) domainOwners.set(domain, owner);
-    else if (firstOwner !== owner) {
-      domainKeyIssues.push({
-        severity: 'warning',
-        code: 'DOMAIN_KEY_CONFLICT',
-        module: owner,
-        message: `域键 ${domain} 被多模块声明（${firstOwner} 与 ${owner}）——domains 换算歧义（P13）`,
-      });
-    }
   };
 
   // 通道 1：npmModules 登记（packages/<id> 本地优先 → node_modules/<pkg>）
@@ -377,36 +417,46 @@ export function walkManifests(appDir: string, cache?: FileCache): WalkManifestsR
     const local = join(appDir, 'packages', entry.id);
     const nm = join(appDir, 'node_modules', ...entry.package.split('/'));
     const manifest = readManifestFile(join(local, 'tbox.module.json'), cache) ?? readManifestFile(join(nm, 'tbox.module.json'), cache);
+    if (manifest?.kind === 'legacy') {
+      pushLegacyIssue(manifest, entry.id);
+      seen.add(entry.id); // 防重复报
+      continue;
+    }
     if (!manifest) continue;
     seen.add(entry.id);
     const dir = existsSync(join(local, 'tbox.module.json')) ? local : nm;
-    const contributes = manifest.contributes;
+    const declare = declareOf(manifest);
     // loose 形态（部分 manifest）不进 modules 清单（descriptor 缺名不可装配化）——仅 catalog 聚合（旧语义等价）
     if (manifest.kind === 'strict') {
       modules.push({ id: entry.id, dir, pkg: entry.mode === 'sdk' ? entry.package : `@app/${entry.id}`, descriptor: manifest.descriptor });
     }
-    const slots = contributes.providers?.slots ?? [];
+    const slots = declare?.providers?.slots ?? [];
     if (slots.length) addSlots(slots, entry.package, dir, modMetaOf(manifest));
-    const needs = contributes.services ?? [];
-    if (needs.length) {
-      for (const need of needs) {
-        addServiceNeed(need, entry.package);
-      }
-    }
+    const consumes = declare?.consumes ?? [];
+    for (const need of consumes) addServiceConsume(need, entry.package);
+    // v6 归属：owner 键 = install id（integrations modules 节同轴）
+    const owns = manifest.kind === 'strict' ? manifest.descriptor.declare.owns : [];
+    if (owns.length) addOwns(owns.map((o) => o.service), entry.id);
   }
 
   // 通道 1.5：tbox-app dev manifest 真身（catalog-only——聚合宽/声明窄不变量：dev 模块
-  // 永不进 modules 清单，防 sync 污染受跟踪装配文件；登记真源优先（seen 按模块名去重））
+  // 永不进 modules 清单，防 sync 污染受跟踪装配文件；登记真源优先（seen 按模块名去重））。
+  // v6：归属以 manifest id 参与（dev 会话的 modules 集成位键同轴——N3 聚合宽/声明窄）。
   for (const { pkg, dir } of readDevManifestRedirects(appDir)) {
     const manifest = readManifestFile(join(dir, 'tbox.module.json'), cache);
-    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, modMetaOf(manifest));
-    const needs = manifest.contributes.services ?? [];
-    if (needs.length) {
-      for (const need of needs) addServiceNeed(need, pkg);
+    if (manifest?.kind === 'legacy') {
+      pushLegacyIssue(manifest, pkg);
+      continue;
     }
+    if (!manifest?.id || seen.has(manifest.id)) continue;
+    seen.add(manifest.id);
+    const declare = declareOf(manifest);
+    const slots = declare?.providers?.slots ?? [];
+    if (slots.length) addSlots(slots, pkg, dir, modMetaOf(manifest));
+    const consumes = declare?.consumes ?? [];
+    for (const need of consumes) addServiceConsume(need, pkg);
+    const owns = manifest.kind === 'strict' ? manifest.descriptor.declare.owns : [];
+    if (owns.length) addOwns(owns.map((o) => o.service), manifest.id);
   }
 
   // 通道 2：packages/* 约定发现（本地模块——npmModules 未登记形态，如手工放入的本地模块）
@@ -422,22 +472,25 @@ export function walkManifests(appDir: string, cache?: FileCache): WalkManifestsR
       if (seen.has(name)) continue;
       const dir = join(packagesDir, name);
       const manifest = readManifestFile(join(dir, 'tbox.module.json'), cache);
+      if (manifest?.kind === 'legacy') {
+        pushLegacyIssue(manifest, name);
+        seen.add(name);
+        continue;
+      }
       if (!manifest) continue;
-      const modName = manifest.name ?? name;
-      if (seen.has(modName)) continue;
-      seen.add(modName);
-      const contributes = manifest.contributes;
+      const modId = manifest.id ?? name;
+      if (seen.has(modId)) continue;
+      seen.add(modId);
+      const declare = declareOf(manifest);
       if (manifest.kind === 'strict') {
-        modules.push({ id: modName, dir, pkg: `@app/${modName}`, descriptor: manifest.descriptor });
-      }
-      const slots = contributes.providers?.slots ?? [];
-      if (slots.length) addSlots(slots, `@app/${modName}`, dir, modMetaOf(manifest));
-      const needs = contributes.services ?? [];
-      if (needs.length) {
-        for (const need of needs) {
-          addServiceNeed(need, `@app/${modName}`);
-        }
+        modules.push({ id: modId, dir, pkg: `@app/${modId}`, descriptor: manifest.descriptor });
       }
+      const slots = declare?.providers?.slots ?? [];
+      if (slots.length) addSlots(slots, `@app/${modId}`, dir, modMetaOf(manifest));
+      const consumes = declare?.consumes ?? [];
+      for (const need of consumes) addServiceConsume(need, `@app/${modId}`);
+      const owns = manifest.kind === 'strict' ? manifest.descriptor.declare.owns : [];
+      if (owns.length) addOwns(owns.map((o) => o.service), modId);
     }
   }
 
@@ -452,7 +505,7 @@ export function walkManifests(appDir: string, cache?: FileCache): WalkManifestsR
     }
   }
 
-  return { modules, catalog, serviceSchemas, vocabulary: [...vocabulary].sort(), slotMeta, domainKeyIssues };
+  return { modules, catalog, serviceSchemas, vocabulary: [...vocabulary].sort(), slotMeta, ownership, declarationIssues };
 }
 
 // ── CLI collectDeclared 迁入（C5——声明集合 + 双端入口探测 + declaration.moduleId 提取）──
@@ -514,7 +567,7 @@ export function collectDeclaredModules(appDir: string): DeclaredModuleInfo[] {
   for (const mod of walk.modules) {
     const mode = modeById.get(mod.id) ?? 'local';
     const hasServerEntry = probeModuleObjectExport(mod.dir, 'server', 'serverModule');
-    const c = mod.descriptor.contributes;
+    const c = mod.descriptor.declare;
     declared.push({
       id: mod.id,
       pkg: mode === 'sdk' ? mod.pkg : `@app/${mod.id}`,

package/src/core/contracts-expected.ts

@@ -13,11 +13,11 @@ import type {
  */
 
 export interface EvaluationExports {
-  /** 求值单源（TIER0；v3 显式激活 vs v4 通配语义随应用版本） */
+  /** 求值单源（TIER0；v3 显式激活 vs v4 通配语义随应用版本；v6 第五参 ownerOf） */
   resolveEffectiveService: typeof resolveEffectiveService;
   /** 供给查表派生（谓词 #12 与视图供给轴共用输入） */
   buildSupplyLookup: typeof buildSupplyLookup;
-  /** service → 首点段域前缀（谓词 #14 域键匹配） */
+  /** service → 首点段域前缀（v6 deprecated——级联键控退役，仅词汇组织消费） */
   moduleDomainOf: typeof moduleDomainOf;
   /** 部署实例注册表归一（默认实例委托——null → '*' 通配口径） */
   normalizeInstances: typeof normalizeInstances;

package/src/core/contracts-resolver.ts

@@ -38,13 +38,16 @@ export interface ResolvedContracts {
   evaluation: boolean;
   /** 严格 zod 面可用（parseIntegrationsConfig 在场——≥0.9 门控判据） */
   strictValidation: boolean;
+  /** v6 形状标记在场（OWNERSHIP_BINDING_V6——modules[owner] 绑定形状支持；标记门 P1：
+   *  v5 contracts + v6 toolkit 偏斜 → 503 第四分支，防静默忽略 ownerOf） */
+  ownershipBindingV6: boolean;
   /** 动态 import 产物（命名导出子集——Partial<EvaluationExports>） */
   module: ResolvedModule;
   /** 解析诊断（N1 构建指引 message 三分支的输入：未安装 / 版本 <0.9 / 源码态未构建） */
   notes: string[];
 }
 
-/** 求值面必需具名导出（在场 → evaluation: true） */
+/** 求值面必需具名导出（在场 → evaluation: true；moduleDomainOf v6 deprecated 但仍在发布面） */
 const EVALUATION_EXPORT_NAMES = [
   'resolveEffectiveService',
   'buildSupplyLookup',
@@ -56,10 +59,14 @@ const EVALUATION_EXPORT_NAMES = [
 /** 严格校验面具名导出（在场 → strictValidation: true；0.9+） */
 const STRICT_EXPORT_NAME = 'parseIntegrationsConfig';
 
+/** v6 形状标记导出（在场 → ownershipBindingV6: true；判据先例 = STRICT_EXPORT_NAME 出口在场性） */
+const OWNERSHIP_MARKER_NAME = 'OWNERSHIP_BINDING_V6';
+
 const UNRESOLVED: ResolvedContracts = {
   version: null,
   evaluation: false,
   strictValidation: false,
+  ownershipBindingV6: false,
   module: {},
   notes: [],
 };
@@ -203,10 +210,14 @@ async function probeCandidate(
     const mod = (await import(pathToFileURL(probeFile).href + versionQuery)) as Record<string, unknown>;
     const evaluation = EVALUATION_EXPORT_NAMES.every((name) => mod[name] !== undefined);
     const strictValidation = mod[STRICT_EXPORT_NAME] !== undefined;
+    // v6 形状标记（出口在场性——判据先例 STRICT_EXPORT_NAME）；缺席时不在此 push note
+    // （503 文案归 factory assertContractsUsable 门控单点——P1）
+    const ownershipBindingV6 = mod[OWNERSHIP_MARKER_NAME] === true;
     return {
       version,
       evaluation,
       strictValidation,
+      ownershipBindingV6,
       module: mod as ResolvedModule,
       notes: evaluation
         ? []

package/src/core/module-schema.ts

@@ -1,16 +1,30 @@
 import { z } from 'zod';
 
 /**
- * tbox.module.json schema v1（001 §3.6 字段名，003 §4.1 schema v1 定版）。
+ * tbox.module.json schema v1（001 §3.6 字段名，003 §4.1 schema v1 定版；v6 声明面翻转）。
  * app-toolkit 单一校验源（自 CLI module-schema.ts 迁入；CLI 经 re-export 消费）。
  *
  * 迁移改造（ai-build C2-5）：
  * - resourceNeedContribSchema 的 type 由 `z.enum(RESOURCE_TYPE_IDS)` 放宽为 `z.string()`——
  *   词汇校验移谓词、经 contracts 动态解析取 RESOURCE_TYPE_IDS（比静态 enum 更忠实应用版本）；
- * - demand meta additive：serviceNeedContribSchema 增 title?/description?（服务展示元数据，
+ * - demand meta additive：serviceConsumeContribSchema 增 name?/description?（服务展示元数据，
  *   manifest demand 侧 additive 扩展，catalog 聚合顺带携带——api.md ServiceDemand 对齐）；
  * - 安全钉子（H9b）：provider 名与 instance id 进凭据 stem 派生，字符集 pattern
  *   `/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/` 为第一道防线（stem 派生处另有断言防线——纵深防御）。
+ *
+ * v6 声明面翻转（integrations v6 所有权模型）：
+ * - `contributes` → `declare`（声明/行为分离——owns/consumes 语义对仗）；
+ * - `declare.services` → `declare.consumes`（无向"服务" → 消费关系，多对多）；
+ * - += `declare.owns`：薄数组（strictObject 单键——互斥事实无元数据；元数据恒在
+ *   consumes 防双数组漂移）。服务归属唯一真源；双 owner = walk OWNERSHIP_CONFLICT；
+ * - 旧键 `contributes` / `declare.services`：parseModuleDescriptor 定向检测（N1——
+ *   报错含三路径升级指引，拒 loose 静默兜底）。
+ *
+ * v7 词汇统一（标识/展示名分轴，对齐实例轴 DeploymentInstance {id, name}）：
+ * - 根键 `name` → `id`（标识键：唯一、寻址）；根键 `title` → `name`（展示名：中文、可选）；
+ * - `declare.consumes[].title` → `name`（demand meta 同步跟随）；
+ * - 旧键 parseModuleDescriptor 定向检测（legacy? 标志——walk 据此拒 loose 兜底、
+ *   CLI sync 据此拒装配改写）。
  */
 
 /** 输入字符集（安全钉子①）：provider 名 / instanceId 恒经此 pattern（进凭据 stem 派生的输入） */
@@ -39,7 +53,7 @@ export const moduleDependencySchema = z.object({
   required: z.boolean().default(true),
 });
 
-/** provider 供给槽声明（integrations v2：contributes.providers.slots 元素；
+/** provider 供给槽声明（integrations v2：declare.providers.slots 元素；
  *  provider = 厂商名（catalog 嵌套第一轴）、implementation = 'id@version'（第二轴）） */
 export const providerSlotContribSchema = z.object({
   service: z.string(),
@@ -51,8 +65,8 @@ export const providerSlotContribSchema = z.object({
   credentialSchema: z.string().optional(),
 });
 
-/** 服务需求槽声明（contributes.services 元素；业务模块声明消费——catalog 需求侧聚合源） */
-export const serviceNeedContribSchema = z.object({
+/** 服务消费槽声明（declare.consumes 元素；业务模块声明消费——catalog 需求侧聚合源） */
+export const serviceConsumeContribSchema = z.object({
   service: z.string(),
   optional: z.boolean().default(true),
   defaults: z
@@ -64,11 +78,19 @@ export const serviceNeedContribSchema = z.object({
     )
     .default([]),
   // demand meta additive（api.md ServiceDemand）：服务展示元数据，缺席 UI 回退 service id
-  title: z.string().optional(),
+  // （v7 词汇统一：title → name）
+  name: z.string().optional(),
   description: z.string().optional(),
 });
 
-/** 资源需求声明（contributes.resources 元素；type 放宽为 string——词汇校验移谓词经 resolver 取词表） */
+/** 服务归属声明（declare.owns 元素；v6 薄形状——互斥事实无元数据，strict 单键防双数组漂移） */
+export const serviceOwnContribSchema = z
+  .object({
+    service: z.string(),
+  })
+  .strict();
+
+/** 资源需求声明（declare.resources 元素；type 放宽为 string——词汇校验移谓词经 resolver 取词表） */
 export const resourceNeedContribSchema = z.object({
   id: z.string(),
   type: z.string(),
@@ -77,9 +99,10 @@ export const resourceNeedContribSchema = z.object({
 export const moduleDescriptorSchema = z
   .object({
     schemaVersion: z.number().default(1),
-    name: z.string(),
-    // 模块级 meta additive（B1）：展示名/描述——回退归视图层（title ?? name / ''），schema 不灌值
-    title: z.string().optional(),
+    // v7 词汇统一（标识/展示名分轴）：id = 标识键（唯一、寻址，键 = install id 规约形态）；
+    // name = 展示名（中文、可选）——回退归视图层（name ?? id），schema 不灌值
+    id: z.string(),
+    name: z.string().optional(),
     description: z.string().optional(),
     version: z.string().default('0.0.0'),
     kind: z.enum(['platform', 'business', 'third-party']).default('business'),
@@ -94,7 +117,7 @@ export const moduleDescriptorSchema = z
         defaultMode: z.enum(['hybrid', 'sdk', 'codegen', 'local']).default('codegen'),
       })
       .default({}),
-    contributes: z
+    declare: z
       .object({
         handlers: z.array(z.string()).default([]),
         tools: z.array(z.string()).default([]),
@@ -107,7 +130,8 @@ export const moduleDescriptorSchema = z
             slots: z.array(providerSlotContribSchema).default([]),
           })
           .default({}),
-        services: z.array(serviceNeedContribSchema).default([]),
+        owns: z.array(serviceOwnContribSchema).default([]),
+        consumes: z.array(serviceConsumeContribSchema).default([]),
         resources: z.array(resourceNeedContribSchema).default([]),
       })
       .default({}),
@@ -123,14 +147,63 @@ export const moduleDescriptorSchema = z
 export type ModuleDescriptor = z.infer<typeof moduleDescriptorSchema>;
 export type CardContrib = z.infer<typeof cardContribSchema>;
 export type ProviderSlotContrib = z.infer<typeof providerSlotContribSchema>;
-export type ServiceNeedContrib = z.infer<typeof serviceNeedContribSchema>;
+export type ServiceConsumeContrib = z.infer<typeof serviceConsumeContribSchema>;
+export type ServiceOwnContrib = z.infer<typeof serviceOwnContribSchema>;
 export type ResourceNeedContrib = z.infer<typeof resourceNeedContribSchema>;
 
 export type ParseModuleResult =
   | { ok: true; value: ModuleDescriptor }
-  | { ok: false; errors: string[] };
+  | { ok: false; errors: string[]; legacy?: true };
+
+/** 旧键检测（N1）：命中 → 定向错误（含三路径升级指引），不走 loose 静默兜底。
+ *  v6 分支：声明面翻转键（contributes / declare.services）；v7 分支：词汇统一翻转键
+ *  （标识 `name`→`id`、展示名 `title`→`name`）。doctor descriptor-schema 规则以错误文本
+ *  「已更名」嗅探透传 OLD_MANIFEST_KEY——新增分支消息必须保持该词。 */
+function legacyManifestKeys(raw: unknown): string[] {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return [];
+  const errors: string[] = [];
+  const obj = raw as Record<string, unknown>;
+  if ('contributes' in obj) {
+    errors.push(
+      '(root): manifest 旧键 `contributes` 已更名 `declare`（v6 声明面）——' +
+        'codegen 副本经 `module update --source` 重新生成 / sdk 模式升级模块包 / 手改两键',
+    );
+  }
+  const declare = obj.declare;
+  if (declare && typeof declare === 'object' && !Array.isArray(declare)
+    && 'services' in (declare as Record<string, unknown>)) {
+    errors.push(
+      'declare: manifest 旧键 `declare.services` 已更名 `declare.consumes`（消费关系定向化）——' +
+        '同上三路径升级',
+    );
+  }
+  // v7 词汇统一（标识/展示名分轴）：`name`→`id`（标识）、`title`→`name`（展示）。
+  // 判据以 `id` 在场性消解同名键歧义：无 id 有 name = v6 旧态；有 id 有 title = 半迁移。
+  if (!('id' in obj) && 'name' in obj) {
+    errors.push(
+      '(root): manifest 标识键 `name` 已更名 `id`（v7 词汇统一）——' +
+        'codegen 副本经 `module update --source` 重新生成 / sdk 模式升级模块包 / 手改两键',
+    );
+  }
+  const declareObj = declare && typeof declare === 'object' && !Array.isArray(declare)
+    ? (declare as Record<string, unknown>)
+    : undefined;
+  const consumeHasTitle = Array.isArray(declareObj?.consumes)
+    && (declareObj.consumes as unknown[]).some(
+      (c) => c !== null && typeof c === 'object' && 'title' in (c as Record<string, unknown>),
+    );
+  if ('title' in obj || consumeHasTitle) {
+    errors.push(
+      '(root): manifest 展示名键 `title` 已更名 `name`（v7 词汇统一；declare.consumes[].title 同步改 name）——'
+        + '同上三路径升级',
+    );
+  }
+  return errors;
+}
 
 export function parseModuleDescriptor(raw: unknown): ParseModuleResult {
+  const legacy = legacyManifestKeys(raw);
+  if (legacy.length > 0) return { ok: false, errors: legacy, legacy: true };
   const result = moduleDescriptorSchema.safeParse(raw);
   if (result.success) return { ok: true, value: result.data };
   return {