@tbox.cn/app-toolkit 0.6.0 → 0.7.1

package/src/assembly/resolve-key.ts

@@ -28,9 +28,10 @@ export function resolveModuleKey(walk: WalkManifestsResult, key: string): WalkMo
   throw new AppToolkitError('MODULE_NOT_FOUND', 404, `模块 ${key} 非已装模块（id / 展示名均未命中）`);
 }
 
-/** 服务双键解析 → 真实 service id：服务键集（词汇 ∪ demand ∪ 供给足迹 ∪ configuredKeys）
+/** 服务双键解析 → 真实 service id：服务键集（词汇 ∪ demand ∪ 供给足迹 ∪ configuredKeys ∪ 归属）
  *  精确命中 → 展示名（slotMeta.name ?? catalog.services[].name）唯一命中 → 404。
- *  configuredKeys = 当前集成配置 services 节键集（调用方注入）。 */
+ *  configuredKeys = 当前集成配置 services 节键集（调用方注入）。
+ *  v6.1 += 归属键（walk.ownership——纯归属无词汇/demand/供给的 owns 合法，O6 对称）。 */
 export function resolveServiceKey(
   walk: WalkManifestsResult,
   configuredKeys: readonly string[],
@@ -50,6 +51,7 @@ export function resolveServiceKey(
     || Object.hasOwn(walk.catalog.services, key)
     || supplied.has(key)
     || configuredKeys.includes(key)
+    || Object.hasOwn(walk.ownership, key)
   ) {
     return key;
   }

package/src/assembly/walk-manifests.ts

@@ -238,15 +238,28 @@ function readDevManifestRedirects(appDir: string): DevManifestRedirect[] {
   }
 }
 
-/** 契约包发现链（探测三跳——词汇源真实布局全覆盖，B0）：候选集（appDir、apps/*、packages/*）×
- *  ① node_modules/@tbox.cn/<pkg>/service-slots.json（包根——夹具/旧布局）
- *  ② 同包 src/service-slots.json（发布包 src 随 files 附带 / 模板 shim 链接到仓库源 src/）
- *  ③ 候选自身 {service-slots.json, src/service-slots.json}（local/codegen 全量副本——mall 生成应用
- *     主形态，stage rewriteExportsToSrc 展开后永驻 packages/*，不依赖 install）
+/** 词汇源条目（via 标记供 doctor 幻影槽判定——config 快照 vs 真源；walkManifests 消费忽略此字段） */
+export interface DiscoveredSlotSource {
+  dir: string;
+  slots: string[];
+  meta: Record<string, SlotMeta>;
+  /** ⓪ config-override（应用级快照/override）｜①② package（node_modules 真源）｜③ local（候选自身副本） */
+  via: 'config-override' | 'package' | 'local';
+}
+
+/** 契约包发现链（探测四跳——词汇源真实布局全覆盖，B0；跳⓪ v7 新增）：
+ *  ⓪ <appDir>/config/service-slots.json（应用级 override 层——meta 首声明胜出 = 用户改名
+ *     per-service 覆盖；slots 并集 = 无依赖词汇引导快照。CLI seed-once 生成：仅 slots +
+ *     $comment 指纹，meta 恒空——真源 meta 恒可穿透，用户手写才生效）；
+ *  ① <候选>/node_modules/@tbox.cn/<pkg>/service-slots.json（包根）
+ *  ② 同包 src/service-slots.json（发布包 src 附带 / 模板 shim 链接）
+ *  ③ 候选自身 {service-slots.json, src/service-slots.json}（local/codegen 全量副本——
+ *     mall 生成应用主形态，stage rewriteExportsToSrc 展开后永驻 packages/*，不依赖 install）
+ *  词汇覆盖 = Set 并集（跳⓪ 不遮蔽真源新增）；meta = 发现序首声明胜出（跳⓪ 最前 = 覆盖权）。
  *  同包双在场（异常态）root 优先。slots 与 meta 单次解析同产（目录枚举零缓存，F8；
  *  FX-3：文件**内容**经 file-cache）。 */
-function discoverContractPackages(appDir: string, cache?: FileCache): Array<{ dir: string; slots: string[]; meta: Record<string, SlotMeta> }> {
-  const found: Array<{ dir: string; slots: string[]; meta: Record<string, SlotMeta> }> = [];
+export function discoverContractPackages(appDir: string, cache?: FileCache): DiscoveredSlotSource[] {
+  const found: DiscoveredSlotSource[] = [];
   const candidates: Array<string> = [appDir];
   for (const sub of ['apps', 'packages']) {
     const parent = join(appDir, sub);
@@ -260,10 +273,13 @@ function discoverContractPackages(appDir: string, cache?: FileCache): Array<{ di
     }
   }
   const seenRoots = new Set<string>();
-  const addDiscovered = (dir: string, file: string): void => {
+  const addDiscovered = (dir: string, file: string, via: DiscoveredSlotSource['via']): void => {
     const parsed = cache ? cache.read(file, parseSlotsFile) : parseSlotsFile(readFileSync(file, 'utf8'));
-    if (parsed !== null && parsed !== undefined) found.push({ dir, slots: parsed.slots, meta: parsed.meta });
+    if (parsed !== null && parsed !== undefined) found.push({ dir, slots: parsed.slots, meta: parsed.meta, via });
   };
+  // 跳⓪：应用级 override/引导快照（发现序最前——meta 覆盖权，词汇并集不遮蔽）
+  const overrideFile = join(appDir, 'config', 'service-slots.json');
+  if (existsSync(overrideFile)) addDiscovered(appDir, overrideFile, 'config-override');
   for (const dir of candidates) {
     // 跳 1/2：node_modules 位（包根 → src——显式安装真源优先）
     const scopeDir = join(dir, 'node_modules', '@tbox.cn');
@@ -280,14 +296,14 @@ function discoverContractPackages(appDir: string, cache?: FileCache): Array<{ di
       seenRoots.add(pkgDir);
       const rootFile = join(pkgDir, 'service-slots.json');
       const srcFile = join(pkgDir, 'src', 'service-slots.json');
-      if (existsSync(rootFile)) addDiscovered(pkgDir, rootFile);
-      else if (existsSync(srcFile)) addDiscovered(pkgDir, srcFile);
+      if (existsSync(rootFile)) addDiscovered(pkgDir, rootFile, 'package');
+      else if (existsSync(srcFile)) addDiscovered(pkgDir, srcFile, 'package');
     }
   }
   // 跳 3：候选自身（local/codegen 全量副本形态——后置于 nm 位：真源 > 副本，meta 首声明序随此）
   for (const dir of candidates) {
     for (const file of [join(dir, 'service-slots.json'), join(dir, 'src', 'service-slots.json')]) {
-      if (existsSync(file)) addDiscovered(dir, file);
+      if (existsSync(file)) addDiscovered(dir, file, 'local');
     }
   }
   return found;

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';
@@ -79,7 +83,7 @@ export interface ModuleDetailView {
   configEditable: boolean;
   /** 本模块 demand（declare.consumes；卡片展开 + 编辑器静态上下文自足） */
   services: ServiceDemand[];
-  /** v4.4 D31：include=serviceResolutions 内嵌（demand 服务过滤 ≡ 批量 ?service= 语义；<0.9/形态异常 → null——永不 503） */
+  /** v4.4 D31：include=serviceResolutions 内嵌（v6.1 键集 = owned ∪ demand 服务过滤 ≡ 批量 ?service= 语义；<0.9/形态异常 → null——永不 503） */
   serviceResolutions?: ServiceResolutionsView | null;
   /** v4.4 D32：include=integrationSchemas 层级富化（零归属/未绑定 → null） */
   integrationSchemas?: LayerIntegrationSchemas | null;
@@ -178,7 +182,7 @@ export interface ServiceIntegrationSchemas {
 export interface ServiceResolutionsView {
   /** P6 contracts echo（仅求值轴两端点携带） */
   contracts: ContractsResolution;
-  /** 键集 = 服务词汇 ∪ 已配置（模块/平台/孤儿全量） */
+  /** 键集 = 服务词汇 ∪ 已配置 ∪ 归属（v6.1 += 归属——owned 服务恒可求值；模块/平台/孤儿全量） */
   resolutions: Record<string, ServiceResolutionEntry>;
   /** 谓词全量（doctor 同源；恒全量——subset 消费方客户端过滤） */
   issues: IntegrationIssue[];
@@ -196,7 +200,8 @@ export interface ServiceResolutionEntry {
   layer?: BindingLayer;
   /** provider 在场时在场：(provider, service) ∈ 供给关系 */
   supplied?: boolean;
-  /** owner 模块 install id；平台服务/孤儿缺席 */
+  /** owner 模块 install id（v6.1 = walk.ownership 归属单源——install id 轴，与模块清单 id 恒可 join；
+   *  旧实现 demand owners[0] 为包名/@app 轴且漏 owned-not-consumed，已退役）；平台服务/孤儿缺席 */
   module?: string;
   /** demand echo（OR 聚合）；平台/孤儿恒 false；集成就绪判定单源（§7） */
   required?: boolean;

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,14 @@ 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
-          ? await predicateIssues().then((issues) =>
-              loadServiceResolutionsView(snap, issues, view.services.map((s) => s.service)))
-          : null; // module = demand 服务过滤（≡ 批量 ?service= 语义；issues 恒全量）
+        // v7：三条件门 + 内嵌轴同步降级（P14 (b) 四面统一骨架——D31 null 分支退役：
+        // include 请求了即恒返回视图；老消费方 null 分支保留为兼容死码）
+        // 过滤键 = owned ∪ demand（v6.1——v4.4 demand-only 遗留；owned 服务是模块页
+        // 集成面一半，mall-core 形态 owns>0/consumes=0 时 demand-only 内嵌恒空）
+        const resolutionFilter = [...new Set([...view.ownedServices, ...view.services.map((s) => s.service)])];
+        view.serviceResolutions = contractsEvaluable(contracts)
+          ? await predicateIssues().then((issues) => loadServiceResolutionsView(snap, issues, resolutionFilter))
+          : loadServiceResolutionsDegradeView(snap, contracts, resolutionFilter); // owned ∪ demand 服务过滤（≡ 批量 ?service= 语义）
       }
       if (include.has('integrationSchemas') || include.has('integrationFieldRegistry')) {
         // v4.6 D37：表单层双投影同源一次计算（双取单算 + I1——假想重定向天然同步）
@@ -283,9 +292,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 +326,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/integrations/predicate.ts

@@ -9,7 +9,8 @@
  * **code 枚举单源 = 本文件头映射表（additive-only；api.md §5 表与本表同步）**：
  *   CREDENTIAL_FILE_MISSING      #1     error    effective credentialRef 引用凭据文件不在场
  *   CREDENTIAL_TYPE_MISMATCH     #2     error    凭据文件 .type 与绑定 credentialType 不一致
- *   SLOT_NOT_DECLARED            #3     warning  服务槽无消费方声明（拼写/需求方未安装/旧槽位词汇）
+ *   SLOT_NOT_DECLARED            #3     warning  服务槽无消费方声明（拼写/需求方未安装/旧槽位词汇；
+ *                                                v6.1 归属豁免——owned 服务不报）
  *   SLOT_NOT_CONFIGURED          #4     warning  需求方缺口（服务槽未配置）
  *   INSTANCE_SUPPLY_UNMATCHED    #5     error    绑定未命中已装供给（槽级/实例级覆盖）
  *   IMPL_WITHOUT_PROVIDER        #5/#13 error    impl-only（implementation 缺 provider 绑定组头）
@@ -333,9 +334,11 @@ export function evaluateIntegrationServices(
   }
 
   for (const [serviceId, service] of Object.entries(integrations.services)) {
-    // 1. 槽未知（不在任何 manifest 需求声明，也非已知供给域）
+    // 1. 槽未知（不在任何 manifest 需求声明，也非已知归属/供给域）——v6.1 += 归属豁免：
+    //    owned+已配置+无人 consume（mall-core 形态）非「无消费方声明」，误报退役；
+    //    ownership 缺席 = 面信息未喂（谓词纯函数）→ 恒查（与 MODULE_CONFIG_DEAD 防御模式同律）
     const demanded = demandedServices[serviceId];
-    if (!demanded) {
+    if (!demanded && ownership?.[serviceId] === undefined) {
       issues.push({
         severity: 'warning',
         code: 'SLOT_NOT_DECLARED',

package/src/integrations/read.ts

@@ -66,8 +66,15 @@ export async function readIntegrationsStrict(
   return { config: raw, strict: false, contracts };
 }
 
-/** P9 服务身份判据单源（A2）：GET/PUT/DELETE 共用「词汇 ∪ 已配置」——service-detail 判据逐字冻结
- *  （api.md P9 的「demanded 退化」口径为文档层 nuance，现行实现与 GET 均不含 demanded——冻结现状即单源） */
-export function isKnownService(vocabulary: readonly string[], configuredKeys: readonly string[], service: string): boolean {
-  return vocabulary.includes(service) || configuredKeys.includes(service);
+/** P9 服务身份判据单源（A2）：GET/PUT/DELETE 共用「词汇 ∪ 已配置 ∪ 归属」——service-detail 判据
+ *  逐字冻结（api.md P9 的「demanded 退化」口径为文档层 nuance，现行实现与 GET 均不含 demanded——冻结现状即单源）。
+ *  v6.1 += 归属键（O6 对称——纯归属无词汇/demand/配置的 owns 合法，resolveServiceKey 供给足迹先例）：
+ *  求值轴可见（resolutionKeys 同批接入）而静态/写轴 404 会造死锁（诊断指引的编辑被拒）。 */
+export function isKnownService(
+  vocabulary: readonly string[],
+  configuredKeys: readonly string[],
+  service: string,
+  ownedKeys: readonly string[],
+): boolean {
+  return vocabulary.includes(service) || configuredKeys.includes(service) || ownedKeys.includes(service);
 }

package/src/integrations/write.ts

@@ -449,9 +449,12 @@ export function createWriteCore(appDir: string, opts: WriteCoreOptions = {}): Wr
       assertSafeInstanceKeys(node, writeOpts, 'slot');
       const issues: IntegrationServiceIssue[] = [];
       const current = loadConfig(appDir, cache);
-      // P9 服务身份判据单源（A2）：写入集 = 词汇 ∪ 已配置——未知服务（含 typo）404（api.md §5）
-      if (!isKnownService(walkManifests(appDir, cache).vocabulary, Object.keys((current?.services as Record<string, unknown> | undefined) ?? {}), service)) {
-        throw new AppToolkitError('SERVICE_NOT_FOUND', 404, `服务 ${service} 不在服务词汇（已装契约包 ∪ 已配置）`);
+      // P9 服务身份判据单源（A2）：写入集 = 词汇 ∪ 已配置 ∪ 归属——未知服务（含 typo）404（api.md §5；
+      // v6.1 += 归属键——owned ∖ 词汇服务可配置，与求值轴 resolutionKeys 同批接入）。
+      // walkManifests 单次调用（目录枚举零缓存——双调 = 每写多一整轮遍历）
+      const walk = walkManifests(appDir, cache);
+      if (!isKnownService(walk.vocabulary, Object.keys((current?.services as Record<string, unknown> | undefined) ?? {}), service, Object.keys(walk.ownership))) {
+        throw new AppToolkitError('SERVICE_NOT_FOUND', 404, `服务 ${service} 不在服务词汇（已装契约包 ∪ 已配置 ∪ 归属）`);
       }
       if (current === null) {
         issues.push({
@@ -505,8 +508,10 @@ export function createWriteCore(appDir: string, opts: WriteCoreOptions = {}): Wr
       const issues: IntegrationServiceIssue[] = [];
       const current = loadConfig(appDir, cache);
       // P9 服务身份判据单源（A2）：判据外未知服务 404；判据内缺席节点维持幂等 written:false
-      if (!isKnownService(walkManifests(appDir, cache).vocabulary, Object.keys((current?.services as Record<string, unknown> | undefined) ?? {}), service)) {
-        throw new AppToolkitError('SERVICE_NOT_FOUND', 404, `服务 ${service} 不在服务词汇（已装契约包 ∪ 已配置）`);
+      // （v6.1 判据 += 归属键——同 applyService；walkManifests 单次调用）
+      const walk = walkManifests(appDir, cache);
+      if (!isKnownService(walk.vocabulary, Object.keys((current?.services as Record<string, unknown> | undefined) ?? {}), service, Object.keys(walk.ownership))) {
+        throw new AppToolkitError('SERVICE_NOT_FOUND', 404, `服务 ${service} 不在服务词汇（已装契约包 ∪ 已配置 ∪ 归属）`);
       }
       const services = { ...((current?.services as Record<string, unknown>) ?? {}) };
       if (!(service in services)) {

package/src/views/service-detail.ts

@@ -11,9 +11,10 @@ import { resolveServiceDisplay, suppliedByVendors, type ViewSnapshot } from './c
 export function loadServiceDetailView(snapshot: ViewSnapshot, service: string): ServiceDetail {
   const configured = (snapshot.integrations as { services?: Record<string, unknown> } | null)?.services ?? {};
   const demand = snapshot.catalog.services[service];
-  // 404 判据与写路径单源（P9——A2 isKnownService；词汇成员零 demand/供给/config 仍 200）
-  if (!isKnownService(snapshot.walk.vocabulary, Object.keys(configured), service)) {
-    throw new AppToolkitError('SERVICE_NOT_FOUND', 404, `服务 ${service} 不在服务词汇（已装契约包 ∪ 已配置）`);
+  // 404 判据与写路径单源（P9——A2 isKnownService；词汇成员零 demand/供给/config 仍 200；
+  // v6.1 += 归属键——owned ∖ 词汇服务静态单体可达，与求值/写轴同批接入）
+  if (!isKnownService(snapshot.walk.vocabulary, Object.keys(configured), service, Object.keys(snapshot.walk.ownership))) {
+    throw new AppToolkitError('SERVICE_NOT_FOUND', 404, `服务 ${service} 不在服务词汇（已装契约包 ∪ 已配置 ∪ 归属）`);
   }
   // integration = 文件 services[s] 逐字原值（编辑预填源 D21）；无声明 = null
   const integration = (configured[service] as ServiceDetail['integration'] | undefined) ?? null;

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;
@@ -187,8 +192,9 @@ export function resolveServiceSummary(
   const demand = catalog.services[service];
   const required = demand !== undefined ? !demand.optional : undefined;
 
-  // module = owner 模块（demand owners 首）；平台/孤儿缺席
-  const module = demand?.owners[0];
+  // module = owner 模块（v6 归属单源 walk.ownership——install id 轴；平台/孤儿缺席）。
+  // demand owners 是消费方集合且键轴为包名/@app 形态，不作归因源（与模块清单 id 恒可 join）
+  const module = snapshot.walk.ownership[service];
 
   return {
     status: evaluation.status,
@@ -205,18 +211,28 @@ function isSuppliedCheck(catalog: WalkCatalog, provider: string, service: string
   return isSupplied(catalog, provider, service);
 }
 
-/** 批量求值（键集 = 服务词汇 ∪ 已配置；?service= 过滤语义——未知键缺席；issues 恒全量） */
+/** 批量键集（求值轴/降级轴共用单源：服务词汇 ∪ 需求侧 ∪ 已配置 ∪ 归属）。
+ *  v6.1 += 归属键——owned 服务恒可求值（embed 自足前置：迭代基不是 filter，
+ *  缺此键则 owned ∖ 词汇服务在内嵌轴静默丢键，fail-visible 破功）。 */
+function resolutionKeys(snapshot: ViewSnapshot): string[] {
+  const keys = new Set<string>([
+    ...snapshot.walk.vocabulary,
+    ...Object.keys(snapshot.catalog.services),
+    ...Object.keys(snapshot.walk.ownership),
+  ]);
+  const configured = (snapshot.integrations as { services?: Record<string, unknown> } | null)?.services ?? {};
+  for (const k of Object.keys(configured)) keys.add(k);
+  return [...keys].sort();
+}
+
+/** 批量求值（键集 = resolutionKeys 单源：词汇 ∪ 需求侧 ∪ 已配置 ∪ 归属；?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 +254,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 +275,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 +291,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 +343,84 @@ 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 = walk.ownership（v6 归属单源，install id 轴）/
+ *  required = OR 聚合；provider/layer 不投——保持「求值产物」语义纯净，layer 单独在场违 D31 孤儿层口径） */
+function degradeEntry(snapshot: ViewSnapshot, service: string, message: string): ServiceResolutionEntry {
+  const demand = snapshot.catalog.services[service];
+  const owner = snapshot.walk.ownership[service];
+  return {
+    status: 'evaluation-unavailable',
+    statusMessage: message,
+    ...(owner !== undefined ? { module: owner } : {}),
+    ...(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 : '*';
+}