@tbox.cn/app-toolkit 0.6.0 → 0.7.0

package/src/core/errors.ts

@@ -36,8 +36,15 @@ export class AppToolkitError extends Error {
 /** CONTRACTS_NOT_RESOLVED message（N1 构建指引——api.md 错误信封示例）。
  *  P-4：notes 优先——resolver 在全部不可解析路径均已 push 携带操作指引的 notes（导入失败/
  *  产物缺失/未安装/<0.9 升级）；现行 version===null 分支会把 notes 内细分指引吞成通用文案。
- *  三分支保留为兜底（防御性——正常路径 notes 恒非空）。 */
-export function contractsNotResolvedMessage(contracts: { version: string | null; strictValidation: boolean; notes: readonly string[] }): string {
+ *  分支保留为兜底（防御性——正常路径 notes 恒非空）。
+ *  v7：+= ownershipBindingV6 分支（标记门第四分支单源化——写门控 assertContractsUsable 与
+ *  读求值轴降级 statusMessage 共用同一文案；可选参向后兼容）。 */
+export function contractsNotResolvedMessage(contracts: {
+  version: string | null;
+  strictValidation: boolean;
+  notes: readonly string[];
+  ownershipBindingV6?: boolean;
+}): string {
   if (contracts.notes.length > 0) {
     return contracts.notes[0];
   }
@@ -47,6 +54,9 @@ export function contractsNotResolvedMessage(contracts: { version: string | null;
   if (!contracts.strictValidation) {
     return `contracts ${contracts.version} 无严格校验面（需 ≥0.9.0）——升级应用 @tbox.cn/app-contracts 依赖后可用`;
   }
+  if (contracts.ownershipBindingV6 === false) {
+    return `contracts ${contracts.version ?? '(版本未知)'} 不支持 v6 modules 绑定形状（OWNERSHIP_BINDING_V6 标记缺席）——升级应用 @tbox.cn/app-contracts 依赖后可用`;
+  }
   // 版本达标但解析态异常（notes 携带细分——导入拒绝/产物缺失）
   return 'contracts workspace 源码态未构建——执行 pnpm --filter @tbox.cn/app-contracts build 后重试';
 }

package/src/dto.ts

@@ -12,13 +12,17 @@
 
 // ===== 词汇基线 =====
 
-/** contracts 求值五态原样（EffectiveServiceResolution.status） */
+/** contracts 求值五态原样（EffectiveServiceResolution.status）+ 视图轴降级态
+ *  （evaluation-unavailable——toolkit 视图独有，非 contracts 求值产物：contracts 不可用
+ *  （未安装/无严格面/v6 标记缺席）时读求值轴不再 503，改投静态骨架 + 本态标记；
+ *  消费方按非 ok 态渲染，statusMessage 携带 N1 分支指引） */
 export type ServiceStatus =
   | 'ok'
   | 'service-not-configured'
   | 'instance-not-found'
   | 'instance-disabled'
-  | 'binding-unresolved';
+  | 'binding-unresolved'
+  | 'evaluation-unavailable';
 
 /** 四配置层（instance 为 map 字段层） */
 export type BindingLayer = 'app' | 'module' | 'service' | 'instance';

package/src/factory.ts

@@ -18,7 +18,13 @@ import { loadViewSnapshotSync } from './views/context.js';
 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 {
+  loadServiceResolutionsView,
+  loadServiceResolutionDetail,
+  loadServiceResolutionsDegradeView,
+  loadServiceResolutionDegradeDetail,
+  contractsEvaluable,
+} from './views/service-resolutions.js';
 import { loadAppFormViews, loadModuleFormViews, loadServiceIntegrationSchemas, loadServiceFieldRegistry } from './views/integration-schemas.js';
 import { loadCredentialsView } from './views/credentials.js';
 import { loadCredentialTypesView } from './views/credential-types.js';
@@ -51,11 +57,13 @@ import type {
  * Read+Write = HTTP 直通面 additive 冻结（L1 端点↔方法 1:1，L3 命名镜像：Integration=节点级 /
  * Config=文件级）；Internals = CLI/doctor/桥消费（自由演进）。
  *
- * **门控断言单点（policy at edge）**：求值（2）+ 写（4）+ ensureMockBindings / writeIntegrationsConfig /
- * evaluateIntegrationServices 入口 assertContractsUsable——strictValidation === false → 503
- * CONTRACTS_NOT_RESOLVED；静态方法不门控（永不 503——铁律 #3）；**include 装配为条件分支非门控**
- * （D31——serviceResolutions 按 evaluation && strictValidation 双条件装配，<0.9/形态异常 → null，
- * 静态端点永不 503；integrationSchemas 纯静态轴零 contracts）；integrations/ views/ 机制层保持纯函数。
+ * **门控断言单点（policy at edge——v7 读求值轴退役后范围 = 写 + 迁移面）**：写（4）+
+ * ensureMockBindings / writeIntegrationsConfig / evaluateIntegrationServices 入口
+ * assertContractsUsable——strictValidation === false → 503 CONTRACTS_NOT_RESOLVED；静态方法不门控
+ * （永不 503——铁律 #3）；**读求值轴（loadServiceResolutions/loadServiceResolution 及 include 装配）
+ * v7 起不再 503**——contracts 不可用 → 200 降级骨架（evaluation-unavailable，doctor 分级/D31 先例
+ * 对齐；依据链与裁决见 Agent Note evaluation-axis-degrade）；**include 装配为条件分支非门控**
+ * （D31 null 分支退役——三条件门 + 内嵌轴同步降级，四面统一骨架）；integrations/ views/ 机制层保持纯函数。
  *
  * 并发：进程内写串行（per-factory promise chain）+ 原子写 + 写后本实例缓存即刻失效（D26）。
  * onApplied（D7）：toolkit 判定「需要重启」（实际落盘且非 dryRun/no-diff）→ 调用一次 +
@@ -193,11 +201,8 @@ export function createAppToolkit(appDir: string, options: AppToolkitOptions = {}
       throw new AppToolkitError('CONTRACTS_NOT_RESOLVED', 503, contractsNotResolvedMessage(contracts));
     }
     if (!contracts.ownershipBindingV6) {
-      throw new AppToolkitError(
-        'CONTRACTS_NOT_RESOLVED',
-        503,
-        `contracts ${contracts.version ?? '(版本未知)'} 不支持 v6 modules 绑定形状（OWNERSHIP_BINDING_V6 标记缺席）——升级应用 @tbox.cn/app-contracts 依赖后可用`,
-      );
+      // v6 标记门第四分支（文案单源 = contractsNotResolvedMessage——降级轴 statusMessage 同源）
+      throw new AppToolkitError('CONTRACTS_NOT_RESOLVED', 503, contractsNotResolvedMessage(contracts));
     }
   }
 
@@ -263,10 +268,12 @@ export function createAppToolkit(appDir: string, options: AppToolkitOptions = {}
       const mod = resolveModuleKey(snap.walk, moduleId);
       const view = loadModuleDetailView(snap, mod.id);
       if (include.has('serviceResolutions')) {
-        view.serviceResolutions = contracts.evaluation && contracts.strictValidation
+        // v7：三条件门 + 内嵌轴同步降级（P14 (b) 四面统一骨架——D31 null 分支退役：
+        // include 请求了即恒返回视图；老消费方 null 分支保留为兼容死码）
+        view.serviceResolutions = contractsEvaluable(contracts)
           ? await predicateIssues().then((issues) =>
               loadServiceResolutionsView(snap, issues, view.services.map((s) => s.service)))
-          : null; // module = demand 服务过滤（≡ 批量 ?service= 语义；issues 恒全量）
+          : loadServiceResolutionsDegradeView(snap, contracts, view.services.map((s) => s.service)); // module = demand 服务过滤（≡ 批量 ?service= 语义）
       }
       if (include.has('integrationSchemas') || include.has('integrationFieldRegistry')) {
         // v4.6 D37：表单层双投影同源一次计算（双取单算 + I1——假想重定向天然同步）
@@ -283,9 +290,10 @@ export function createAppToolkit(appDir: string, options: AppToolkitOptions = {}
       const snap = snapshot(contracts);
       const view = loadAppView(snap);
       if (include.has('serviceResolutions')) {
-        view.serviceResolutions = contracts.evaluation && contracts.strictValidation
+        // v7：内嵌轴同步降级（同 loadModule——D31 null 退役，app = 全量键集）
+        view.serviceResolutions = contractsEvaluable(contracts)
           ? await predicateIssues().then((issues) => loadServiceResolutionsView(snap, issues)) // app = 全量键集
-          : null;
+          : loadServiceResolutionsDegradeView(snap, contracts);
       }
       if (include.has('integrationSchemas') || include.has('integrationFieldRegistry')) {
         const form = loadAppFormViews(snap, o?.appProvider); // 双取单算 + I1（同 loadModule）
@@ -316,15 +324,19 @@ export function createAppToolkit(appDir: string, options: AppToolkitOptions = {}
     },
     async loadServiceResolutions(services?: string[]) {
       const contracts = await resolveContractsForApp(appDir);
-      assertContractsUsable(contracts);
+      const snap = snapshot(contracts);
+      // v7 读求值轴降级门（policy-at-edge 读轴退役）：contracts 不可用 → 200 静态骨架 +
+      // evaluation-unavailable（fail-visible 保留在数据内；写路径 503 门控不变）
+      if (!contractsEvaluable(contracts)) return loadServiceResolutionsDegradeView(snap, contracts, services);
       const issues = await predicateIssues();
-      return loadServiceResolutionsView(snapshot(contracts), issues, services);
+      return loadServiceResolutionsView(snap, issues, services);
     },
     async loadServiceResolution(service: string) {
       const contracts = await resolveContractsForApp(appDir);
-      assertContractsUsable(contracts);
       const snap = snapshot(contracts);
       const serviceId = resolveServiceKey(snap.walk, configuredServiceKeys(snap), service);
+      // v7 降级门同批量端点（三条件与；降级单体携带声明实例枚举 + inheritance 静态投影）
+      if (!contractsEvaluable(contracts)) return loadServiceResolutionDegradeDetail(serviceId, snap, contracts);
       const issues = await predicateIssues();
       return loadServiceResolutionDetail(serviceId, snap, issues);
     },

package/src/index.ts

@@ -64,10 +64,10 @@ 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';
+export { walkManifests, discoverContractPackages } from './assembly/walk-manifests.js';
 // 双键寻址（v7 词汇统一——factory 七方法入口单点消费的解析 helper；纯参数式零 IO）
 export { resolveModuleKey, resolveServiceKey } from './assembly/resolve-key.js';
-export type { WalkManifestsResult, WalkModuleInfo, WalkCatalog, WalkProviderEntry, DeclarationIssue, SlotMeta } from './assembly/walk-manifests.js';
+export type { WalkManifestsResult, WalkModuleInfo, WalkCatalog, WalkProviderEntry, DeclarationIssue, SlotMeta, DiscoveredSlotSource } from './assembly/walk-manifests.js';
 export { readAppManifest, writeAppManifest, manifestPath } from './assembly/app-manifest.js';
 export type { AppManifest, NpmModuleEntry, ModuleMode } from './assembly/app-manifest.js';
 export { loadProviderCatalog, loadProviderCatalogRaw } from './assembly/provider-catalog.js';

package/src/views/service-resolutions.ts

@@ -10,7 +10,7 @@ import type {
   ServiceResolutionDetail,
   ServiceStatus,
 } from '../dto.js';
-import { AppToolkitError } from '../core/errors.js';
+import { AppToolkitError, contractsNotResolvedMessage } from '../core/errors.js';
 import { resolveModuleBinding } from '../integrations/module-binding.js';
 import type { ResolvedContracts } from '../core/contracts-resolver.js';
 import type { WalkCatalog } from '../assembly/walk-manifests.js';
@@ -83,6 +83,10 @@ function evaluateInstance(
     service,
     instanceId,
     supplies as never,
+    // v6 ownerOf：服务归属表（walk.ownership——buildOwnershipMap 同源产物）显式参。
+    // 缺席 + 文件含 modules 级绑定/配置 → contracts v6 fail-visible（binding-unresolved），
+    // root/modules 级联全断——视图轴与谓词轴同源透传，勿再遗漏（bug 复盘：fef9a71a 漏改点）。
+    snapshot.walk.ownership as Record<string, string>,
   );
   if (r.status === 'ok' && r.effective) {
     const raw: unknown = r.effective.provider;
@@ -124,6 +128,7 @@ function evaluationContracts(snapshot: ViewSnapshot) {
       service: string,
       instanceId: string,
       supplies?: never,
+      ownerOf?: Record<string, string>,
     ) => EffectiveResolutionShape;
     normalizeInstances: (input: unknown) => { instances: Array<{ id: string }>; defaultInstanceId: string | null };
     buildSupplyLookup: (catalog: unknown) => unknown;
@@ -205,18 +210,22 @@ function isSuppliedCheck(catalog: WalkCatalog, provider: string, service: string
   return isSupplied(catalog, provider, service);
 }
 
+/** 批量键集（求值轴/降级轴共用单源：服务词汇 ∪ 需求侧 ∪ 已配置） */
+function resolutionKeys(snapshot: ViewSnapshot): string[] {
+  const keys = new Set<string>([...snapshot.walk.vocabulary, ...Object.keys(snapshot.catalog.services)]);
+  const configured = (snapshot.integrations as { services?: Record<string, unknown> } | null)?.services ?? {};
+  for (const k of Object.keys(configured)) keys.add(k);
+  return [...keys].sort();
+}
+
 /** 批量求值（键集 = 服务词汇 ∪ 已配置；?service= 过滤语义——未知键缺席；issues 恒全量） */
 export function loadServiceResolutionsView(
   snapshot: ViewSnapshot,
   issues: IntegrationIssue[],
   filter?: string[],
 ): ServiceResolutionsView {
-  const keys = new Set<string>([...snapshot.walk.vocabulary, ...Object.keys(snapshot.catalog.services)]);
-  const configured = (snapshot.integrations as { services?: Record<string, unknown> } | null)?.services ?? {};
-  for (const k of Object.keys(configured)) keys.add(k);
-
   const resolutions: Record<string, ServiceResolutionEntry> = {};
-  for (const service of [...keys].sort()) {
+  for (const service of resolutionKeys(snapshot)) {
     if (filter && !filter.includes(service)) continue;
     resolutions[service] = resolveServiceSummary(service, snapshot);
   }
@@ -238,20 +247,12 @@ export function loadServiceResolutionDetail(
   });
 
   // P4 枚举规则：root 注册表 id 逐一 + 显式 '*' 条目（若在）；无注册表且节点通配激活 → 单 '*' 合成；
-  // 无注册表无节点 → []
+  // 无注册表无节点 → []（枚举单源 = enumerateInstanceIds——降级轴声明实例投影共用）
   const declaredIds = normalized.instances.map((i) => i.id);
   const slot = (snapshot.integrations as { services?: Record<string, { instances?: Record<string, unknown> }> } | null)
     ?.services?.[service];
   const slotKeys = slot?.instances ? Object.keys(slot.instances) : undefined;
-  let instanceIds: string[];
-  if (declaredIds.length > 0) {
-    instanceIds = [...declaredIds];
-    if (slotKeys?.includes('*')) instanceIds.push('*');
-  } else if (slotKeys !== undefined && slotKeys.length > 0) {
-    instanceIds = slotKeys.includes('*') ? ['*'] : slotKeys;
-  } else {
-    instanceIds = [];
-  }
+  const instanceIds = enumerateInstanceIds(slotKeys, declaredIds);
 
   // 默认实例口径（摘要 status = 默认实例求值——不重复头部；原 defaultEval 死代码已删 FX-2c）
 
@@ -267,7 +268,7 @@ export function loadServiceResolutionDetail(
   });
 
   // inheritance 四层（app → module → service → instance——effective 链声明位投影）
-  const inheritance = buildInheritance(snapshot, service);
+  const inheritance = buildInheritance(snapshot, service, normalized.defaultInstanceId ?? '*');
 
   const summary = resolveServiceSummary(service, snapshot);
   const resolution: ServiceResolution = {
@@ -283,24 +284,31 @@ export function loadServiceResolutionDetail(
   };
 }
 
+/** P4 实例枚举单源（求值轴/降级轴共用）：root 注册表 id 逐一 + 显式 '*' 条目（若在）；
+ *  无注册表且节点通配激活 → 单 '*' 合成；无注册表无节点 → []。 */
+function enumerateInstanceIds(slotKeys: string[] | undefined, declaredIds: string[]): string[] {
+  if (declaredIds.length > 0) {
+    const ids = [...declaredIds];
+    if (slotKeys?.includes('*')) ids.push('*');
+    return ids;
+  }
+  if (slotKeys !== undefined && slotKeys.length > 0) return slotKeys.includes('*') ? ['*'] : slotKeys;
+  return [];
+}
+
 /** inheritance 投影：四层各取该层声明 provider/implementation（缺席层 = 继承位，provider 缺席）。
- *  实例层 = **默认实例口径**（FX-2c 修——与摘要 status 同轴：normalizeInstances 委托解析
- *  defaultInstanceId ?? '*'；原实现取 Object.keys[0] 任意实例）。 */
+ *  实例层 = **默认实例口径**（FX-2c 修——与摘要 status 同轴）；defaultInstanceId 由调用方解析
+ *  （求值轴 = normalizeInstances 委托；降级轴 = 原始直读——本函数零 contracts 依赖，双轴共用单源）。 */
 function buildInheritance(
   snapshot: ViewSnapshot,
   service: string,
+  defaultInstanceId: string,
 ): ServiceResolution['inheritance'] {
   const integrations = snapshot.integrations as {
     provider?: string;
     services?: Record<string, { provider?: unknown; implementation?: string; instances?: Record<string, { provider?: string; implementation?: string }> }>;
   } | null;
   const slot = integrations?.services?.[service];
-  const cfg = snapshot.integrations as { instances?: unknown; defaultInstanceId?: unknown } | null;
-  const normalized = evaluationContracts(snapshot).normalizeInstances({
-    instances: cfg?.instances,
-    defaultInstanceId: cfg?.defaultInstanceId,
-  });
-  const defaultInstanceId = normalized.defaultInstanceId ?? '*';
   const defaultInstance = slot?.instances?.[defaultInstanceId] ?? slot?.instances?.['*'];
   // module 段消费 resolveModuleBinding 单源（v6——与 binding / 谓词 #7 同源；ownerOf=walk.ownership）
   const owner = snapshot.walk.ownership[service];
@@ -328,3 +336,83 @@ function buildInheritance(
 
 /** 谓词全量 issues 装配（写路径/求值轴共用——工厂经 evaluateIntegrationServices 装配后传入） */
 export type { IntegrationIssue };
+
+// ── 降级轴（v7——policy-at-edge 读求值轴退役）──
+// contracts 不可用（未安装 / 无严格面 / 求值面缺席 / v6 标记缺席）时，读求值轴不再 503，
+// 改投静态骨架（walk + integrations 纯文件投影，零 contracts 依赖）+ evaluation-unavailable 标记。
+// 依据链：doctor 分级先例（未安装 = warning 正常态）+ D31 include→null 先例；fail-visible 语义
+// 保留在数据内（status + statusMessage N1 分支文案），写路径与 internals 门控不变。
+
+/** 读求值轴可用判据（三条件与——降级门单源；写路径 assertContractsUsable 另有 503 语义，不复用） */
+export function contractsEvaluable(contracts: ResolvedContracts): boolean {
+  return contracts.evaluation && contracts.strictValidation && contracts.ownershipBindingV6;
+}
+
+/** 降级单条目（静态可算字段：module = owners 首 / required = OR 聚合；provider/layer 不投——
+ *  保持「求值产物」语义纯净，layer 单独在场违 D31 孤儿层口径） */
+function degradeEntry(snapshot: ViewSnapshot, service: string, message: string): ServiceResolutionEntry {
+  const demand = snapshot.catalog.services[service];
+  return {
+    status: 'evaluation-unavailable',
+    statusMessage: message,
+    ...(demand?.owners[0] !== undefined ? { module: demand.owners[0] } : {}),
+    ...(demand !== undefined ? { required: !demand.optional } : {}),
+  };
+}
+
+/** 批量降级视图（键集与求值轴同源 resolutionKeys；?service= 过滤语义一致；issues 恒 []——
+ *  谓词与求值同源缺席；声明面诊断走 declarationIssues 通道不在此混装） */
+export function loadServiceResolutionsDegradeView(
+  snapshot: ViewSnapshot,
+  contracts: ResolvedContracts,
+  filter?: string[],
+): ServiceResolutionsView {
+  const message = contractsNotResolvedMessage(contracts);
+  const resolutions: Record<string, ServiceResolutionEntry> = {};
+  for (const service of resolutionKeys(snapshot)) {
+    if (filter && !filter.includes(service)) continue;
+    resolutions[service] = degradeEntry(snapshot, service, message);
+  }
+  return { contracts: toContractsResolution(contracts), resolutions, issues: [] };
+}
+
+/** 单体降级视图（P14 extends 结构保证——摘要基 + instances 声明枚举 + inheritance 四层静态投影） */
+export function loadServiceResolutionDegradeDetail(
+  service: string,
+  snapshot: ViewSnapshot,
+  contracts: ResolvedContracts,
+): ServiceResolutionDetail {
+  const message = contractsNotResolvedMessage(contracts);
+  const resolution: ServiceResolution = {
+    ...degradeEntry(snapshot, service, message),
+    instances: degradeInstances(snapshot, service),
+    inheritance: buildInheritance(snapshot, service, degradeDefaultInstanceId(snapshot)),
+  };
+  return { contracts: toContractsResolution(contracts), resolution, issues: [] };
+}
+
+/** 声明实例投影（原始数据——root instances[].id ∪ slot 实例键，P4 枚举单源共用；
+ *  非 normalizeInstances 派生语义，单源不破）。逐实例同标记，statusMessage 不重复携带
+ *  （resolution 顶层已携带）。 */
+function degradeInstances(snapshot: ViewSnapshot, service: string): ResolvedInstance[] {
+  const slot = (snapshot.integrations as { services?: Record<string, { instances?: Record<string, unknown> }> } | null)
+    ?.services?.[service];
+  const cfg = snapshot.integrations as { instances?: unknown } | null;
+  const declaredIds = Array.isArray(cfg?.instances)
+    ? (cfg.instances as Array<{ id?: unknown }>)
+        .map((i) => (i && typeof i === 'object' ? i.id : undefined))
+        .filter((id): id is string => typeof id === 'string')
+    : [];
+  const slotKeys = slot?.instances ? Object.keys(slot.instances) : undefined;
+  return enumerateInstanceIds(slotKeys, declaredIds).map((id) => ({
+    instanceId: id,
+    status: 'evaluation-unavailable' as const,
+  }));
+}
+
+/** 降级默认实例口径（近似声明）：defaultInstanceId 原始直读，缺席 → '*' 通配位。
+ *  normalizeInstances 的「单候选唯一解」推导不可复制（求值面单源）——近似口径见 api 契约。 */
+function degradeDefaultInstanceId(snapshot: ViewSnapshot): string {
+  const cfg = snapshot.integrations as { defaultInstanceId?: unknown } | null;
+  return typeof cfg?.defaultInstanceId === 'string' && cfg.defaultInstanceId.length > 0 ? cfg.defaultInstanceId : '*';
+}

package/tests/dev-manifest-catalog.test.ts

@@ -119,7 +119,7 @@ describe('walkManifests · dev-manifest catalog 通道（聚合宽/声明窄）'
  * （local/codegen 全量副本——mall 生成应用主形态，不依赖 install）。
  * 修复前探测只扫包根 → 三形态全 miss（vocabulary 恒空）。
  */
-describe('walkManifests · 词汇探测三跳 + slotMeta（B0）', () => {
+describe('walkManifests · 词汇探测四跳 + slotMeta（B0；v7 += 跳⓪ config override 层）', () => {
   it('P1: nm 包根布局（跳①）→ vocabulary 命中；slotMeta 透传', () => {
     app = createTempApp('tbox-probe-');
     const store = join(app.appDir, '_store-a');
@@ -185,6 +185,44 @@ describe('walkManifests · 词汇探测三跳 + slotMeta（B0）', () => {
     expect(walk.slotMeta).toEqual({ 'e.f': { name: '甲' } }); // 空串 description 不入表（与 title 守卫对称）
   });
 
+  it('P6: 跳⓪ config override 层——meta per-service 覆盖真源 + 无键键穿透真源（首声明 = config 最前）', () => {
+    app = createTempApp('tbox-probe-');
+    const store = join(app.appDir, '_store-truth');
+    writeFakeContractsPackage(store, {
+      slots: ['a.b', 'c.d'],
+      meta: { 'a.b': { name: '真源甲' }, 'c.d': { name: '真源丙' } },
+    });
+    linkContracts(app.appDir, store, { subdir: 'apps/server' });
+    // 用户 override：只改名 a.b；c.d 不写（穿透真源）；e.f 仅快照声明（幻影语义由 doctor 报告）
+    writeFileSync(
+      join(app.appDir, 'config', 'service-slots.json'),
+      JSON.stringify({ $comment: { seededAt: 'x' }, slots: ['a.b', 'e.f'], meta: { 'a.b': { name: '用户改名甲' } } }),
+    );
+
+    const walk = walkManifests(app.appDir);
+    // 词汇并集：config ∪ 真源（config 不遮蔽真源新增）
+    expect(walk.vocabulary).toEqual(['a.b', 'c.d', 'e.f']);
+    // meta 覆盖：config 先声明胜出；未覆盖键穿透真源
+    expect(walk.slotMeta['a.b']).toEqual({ name: '用户改名甲' });
+    expect(walk.slotMeta['c.d']).toEqual({ name: '真源丙' });
+  });
+
+  it('P7: 跳⓪ 快照 meta 恒空（seed 形态）→ 真源 meta 恒穿透；$comment 键零解析影响', () => {
+    app = createTempApp('tbox-probe-');
+    const store = join(app.appDir, '_store-seed');
+    writeFakeContractsPackage(store, { slots: ['a.b'], meta: { 'a.b': { name: '真源甲' } } });
+    linkContracts(app.appDir, store, { subdir: 'apps/server' });
+    // seed-once 产物形态：slots 全量 + meta 空对象
+    writeFileSync(
+      join(app.appDir, 'config', 'service-slots.json'),
+      JSON.stringify({ $comment: { seededAt: '2026-09-21', slots: 1 }, slots: ['a.b'], meta: {} }),
+    );
+
+    const walk = walkManifests(app.appDir);
+    expect(walk.vocabulary).toEqual(['a.b']);
+    expect(walk.slotMeta['a.b']).toEqual({ name: '真源甲' }); // 空 meta 不夺覆盖权
+  });
+
   it('P6: 无契约包（退化态）→ vocabulary 空 + slotMeta 空（P9 退化路径语义锁）', () => {
     app = createTempApp('tbox-probe-');
     const walk = walkManifests(app.appDir);