scene-capability-engine 3.6.51 → 3.6.53

package/lib/commands/errorbook.js

@@ -18,6 +18,15 @@ const TEMPORARY_MITIGATION_TAG = 'temporary-mitigation';
 const DEFAULT_ERRORBOOK_REGISTRY_CONFIG = '.sce/config/errorbook-registry.json';
 const DEFAULT_ERRORBOOK_REGISTRY_CACHE = '.sce/errorbook/registry-cache.json';
 const DEFAULT_ERRORBOOK_REGISTRY_EXPORT = '.sce/errorbook/exports/errorbook-registry-export.json';
+const DEFAULT_PROJECT_SHARED_ERRORBOOK_REGISTRY = '.sce/knowledge/errorbook/project-shared-registry.json';
+const DEFAULT_PROJECT_SHARED_ERRORBOOK_STATUSES = Object.freeze(['verified', 'promoted']);
+const DEFAULT_PROJECT_SHARED_ERRORBOOK_MIN_QUALITY = 75;
+const DEFAULT_PROJECT_SHARED_ERRORBOOK_PROJECTION = Object.freeze({
+  enabled: true,
+  file: DEFAULT_PROJECT_SHARED_ERRORBOOK_REGISTRY,
+  statuses: [...DEFAULT_PROJECT_SHARED_ERRORBOOK_STATUSES],
+  min_quality: DEFAULT_PROJECT_SHARED_ERRORBOOK_MIN_QUALITY
+});
 const STATUS_RANK = Object.freeze({
   deprecated: 0,
   candidate: 1,
@@ -107,6 +116,10 @@ function nowIso() {
   return new Date().toISOString();
 }
 
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
 function normalizeText(value) {
   if (typeof value !== 'string') {
     return '';
@@ -1036,6 +1049,26 @@ function normalizeStatusList(values = [], fallback = ['promoted']) {
   return unique;
 }
 
+function normalizeProjectSharedProjection(input = {}) {
+  const candidate = input && typeof input === 'object' && !Array.isArray(input)
+    ? input
+    : {};
+  const minQualityCandidate = candidate.min_quality ?? candidate.minQuality;
+  const minQuality = Number.isFinite(Number(minQualityCandidate))
+    ? Math.max(0, Math.min(100, Number(minQualityCandidate)))
+    : DEFAULT_PROJECT_SHARED_ERRORBOOK_MIN_QUALITY;
+
+  return {
+    enabled: normalizeBoolean(candidate.enabled, true),
+    file: normalizeText(candidate.file || candidate.out || candidate.path || DEFAULT_PROJECT_SHARED_ERRORBOOK_REGISTRY),
+    statuses: normalizeStatusList(
+      candidate.statuses || candidate.status || DEFAULT_PROJECT_SHARED_ERRORBOOK_STATUSES,
+      DEFAULT_PROJECT_SHARED_ERRORBOOK_STATUSES
+    ),
+    min_quality: minQuality
+  };
+}
+
 function normalizeRegistrySource(input = {}) {
   const candidate = input || {};
   const name = normalizeText(candidate.name) || 'default';
@@ -1067,7 +1100,8 @@ async function readErrorbookRegistryConfig(paths, fileSystem = fs) {
     enabled: false,
     search_mode: 'cache',
     cache_file: DEFAULT_ERRORBOOK_REGISTRY_CACHE,
-    sources: []
+    sources: [],
+    project_shared_projection: cloneJson(DEFAULT_PROJECT_SHARED_ERRORBOOK_PROJECTION)
   };
   if (!await fileSystem.pathExists(paths.configFile)) {
     return fallback;
@@ -1083,7 +1117,55 @@ async function readErrorbookRegistryConfig(paths, fileSystem = fs) {
     enabled: normalizeBoolean(payload.enabled, true),
     search_mode: normalizeRegistryMode(payload.search_mode || payload.searchMode, 'cache'),
     cache_file: normalizeText(payload.cache_file || payload.cacheFile || DEFAULT_ERRORBOOK_REGISTRY_CACHE),
-    sources
+    sources,
+    project_shared_projection: normalizeProjectSharedProjection(
+      payload.project_shared_projection || payload.projectSharedProjection
+    )
+  };
+}
+
+async function refreshProjectSharedErrorbookProjection(projectPath, fileSystem = fs, options = {}) {
+  const registryPaths = resolveErrorbookRegistryPaths(projectPath, {
+    configPath: options.config
+  });
+  const registryConfig = await readErrorbookRegistryConfig(registryPaths, fileSystem);
+  const projection = normalizeProjectSharedProjection(
+    options.projectSharedProjection || registryConfig.project_shared_projection
+  );
+  const projectionFile = resolveProjectPath(
+    projectPath,
+    projection.file,
+    DEFAULT_PROJECT_SHARED_ERRORBOOK_REGISTRY
+  );
+
+  if (projection.enabled !== true) {
+    return {
+      enabled: false,
+      refreshed: false,
+      file: projectionFile,
+      statuses: projection.statuses,
+      min_quality: projection.min_quality,
+      total_entries: 0
+    };
+  }
+
+  const exportResult = await runErrorbookExportCommand({
+    out: projection.file,
+    status: projection.statuses.join(','),
+    minQuality: projection.min_quality,
+    silent: true
+  }, {
+    projectPath,
+    fileSystem
+  });
+
+  return {
+    enabled: true,
+    refreshed: true,
+    file: exportResult.out_file,
+    statuses: exportResult.statuses,
+    min_quality: exportResult.min_quality,
+    total_entries: exportResult.total_entries
   };
 }
 
@@ -1322,6 +1404,7 @@ async function searchRegistryRemote(options = {}, dependencies = {}) {
 
   const warnings = [];
   let shardSources = [];
+  const localFileSource = !isHttpSource(source.source);
   if (source.index_url) {
     try {
       const indexPayload = await loadRegistryPayload(projectPath, source.index_url, fileSystem);
@@ -1332,7 +1415,10 @@ async function searchRegistryRemote(options = {}, dependencies = {}) {
   }
 
   if (shardSources.length === 0) {
-    if (allowRemoteFullscan) {
+    if (localFileSource) {
+      shardSources = [source.source];
+      warnings.push('local registry file source scanned directly without index');
+    } else if (allowRemoteFullscan) {
       shardSources = [source.source];
       warnings.push('remote index unavailable; fallback to full-source scan');
     } else {
@@ -1769,13 +1855,15 @@ async function runErrorbookRecordCommand(options = {}, dependencies = {}) {
   const incidentLoop = await syncIncidentLoopForRecord(paths, normalized, entry, {
     nowIso: entry.updated_at
   }, fileSystem);
+  const projectSharedProjection = await refreshProjectSharedErrorbookProjection(projectPath, fileSystem, options);
 
   const result = {
     mode: 'errorbook-record',
     created,
     deduplicated,
     entry,
-    incident_loop: incidentLoop
+    incident_loop: incidentLoop,
+    project_shared_projection: projectSharedProjection
   };
 
   if (options.json) {
@@ -2575,11 +2663,13 @@ async function runErrorbookPromoteCommand(options = {}, dependencies = {}) {
   }
   index.entries.sort((left, right) => `${right.updated_at}`.localeCompare(`${left.updated_at}`));
   await writeErrorbookIndex(paths, index, fileSystem);
+  const projectSharedProjection = await refreshProjectSharedErrorbookProjection(projectPath, fileSystem, options);
 
   const result = {
     mode: 'errorbook-promote',
     promoted: true,
-    entry
+    entry,
+    project_shared_projection: projectSharedProjection
   };
 
   if (options.json) {
@@ -2672,11 +2762,13 @@ async function runErrorbookDeprecateCommand(options = {}, dependencies = {}) {
   }
   index.entries.sort((left, right) => `${right.updated_at}`.localeCompare(`${left.updated_at}`));
   await writeErrorbookIndex(paths, index, fileSystem);
+  const projectSharedProjection = await refreshProjectSharedErrorbookProjection(projectPath, fileSystem, options);
 
   const result = {
     mode: 'errorbook-deprecate',
     deprecated: true,
-    entry
+    entry,
+    project_shared_projection: projectSharedProjection
   };
 
   if (options.json) {
@@ -2744,11 +2836,13 @@ async function runErrorbookRequalifyCommand(options = {}, dependencies = {}) {
   }
   index.entries.sort((left, right) => `${right.updated_at}`.localeCompare(`${left.updated_at}`));
   await writeErrorbookIndex(paths, index, fileSystem);
+  const projectSharedProjection = await refreshProjectSharedErrorbookProjection(projectPath, fileSystem, options);
 
   const result = {
     mode: 'errorbook-requalify',
     requalified: true,
-    entry
+    entry,
+    project_shared_projection: projectSharedProjection
   };
 
   if (options.json) {
@@ -3009,6 +3103,8 @@ module.exports = {
   DEFAULT_ERRORBOOK_REGISTRY_CONFIG,
   DEFAULT_ERRORBOOK_REGISTRY_CACHE,
   DEFAULT_ERRORBOOK_REGISTRY_EXPORT,
+  DEFAULT_PROJECT_SHARED_ERRORBOOK_REGISTRY,
+  DEFAULT_PROJECT_SHARED_ERRORBOOK_PROJECTION,
   HIGH_RISK_SIGNAL_TAGS,
   DEBUG_EVIDENCE_TAGS,
   DEFAULT_PROMOTE_MIN_QUALITY,
@@ -3035,5 +3131,6 @@ module.exports = {
   runErrorbookReleaseGateCommand,
   runErrorbookDeprecateCommand,
   runErrorbookRequalifyCommand,
+  refreshProjectSharedErrorbookProjection,
   registerErrorbookCommands
 };

package/lib/commands/mode.js

@@ -37,18 +37,44 @@ function isFreshProjectionCache(cacheRecord, ttlSeconds) {
   return (Date.now() - generatedAt) <= maxAgeMs;
 }
 
-async function buildApplicationHome(graph = {}, dependencies = {}) {
+function getRuntimeProjectionState(graph = {}) {
   const bundle = graph.bundle || {};
   const runtimeRelease = graph.runtime_release || {};
-  const sceneBindings = Array.isArray(graph.scene_bindings) ? graph.scene_bindings : [];
   const metadata = bundle.metadata && typeof bundle.metadata === 'object' ? bundle.metadata : {};
   const installation = metadata.runtime_installation && typeof metadata.runtime_installation === 'object'
     ? metadata.runtime_installation
     : {};
+  const runtimeActivation = metadata.runtime_activation && typeof metadata.runtime_activation === 'object'
+    ? metadata.runtime_activation
+    : {};
   const serviceCatalog = metadata.service_catalog && typeof metadata.service_catalog === 'object'
     ? metadata.service_catalog
     : {};
   const releases = Array.isArray(serviceCatalog.releases) ? serviceCatalog.releases : [];
+  const installStatus = normalizeString(installation.status) || 'not-installed';
+  const installedReleaseId = installStatus === 'installed'
+    ? (normalizeString(installation.release_id) || null)
+    : null;
+  const activeReleaseId = normalizeString(
+    bundle.runtime_release_id
+    || runtimeRelease.release_id
+    || runtimeActivation.active_release_id
+  ) || null;
+
+  return {
+    installation,
+    releases,
+    installStatus,
+    installedReleaseId,
+    activeReleaseId
+  };
+}
+
+async function buildApplicationHome(graph = {}, dependencies = {}) {
+  const bundle = graph.bundle || {};
+  const runtimeRelease = graph.runtime_release || {};
+  const sceneBindings = Array.isArray(graph.scene_bindings) ? graph.scene_bindings : [];
+  const state = getRuntimeProjectionState(graph);
   return {
     mode: 'application-home',
     query: {
@@ -60,8 +86,10 @@ async function buildApplicationHome(graph = {}, dependencies = {}) {
       environment: bundle.environment || null,
       release_status: runtimeRelease.release_status || null,
       runtime_status: runtimeRelease.runtime_status || null,
-      install_status: installation.status || 'not-installed',
-      release_count: releases.length
+      install_status: state.installStatus,
+      installed_release_id: state.installedReleaseId,
+      active_release_id: state.activeReleaseId,
+      release_count: state.releases.length
     },
     relations: {
       runtime_release_id: bundle.runtime_release_id || null,
@@ -69,20 +97,22 @@ async function buildApplicationHome(graph = {}, dependencies = {}) {
       engineering_project_id: bundle.engineering_project_id || null,
       default_scene_id: bundle.default_scene_id || null
     },
-    items: releases,
+    items: state.releases,
     view_model: {
       projection: 'application',
       app_id: bundle.app_id || null,
       app_key: bundle.app_key || null,
       app_name: bundle.app_name || null,
       entrypoint: runtimeRelease.entrypoint || null,
-      current_release: installation.release_id || runtimeRelease.release_id || null,
-      current_environment: bundle.environment || installation.current_environment || null,
-      install_root: installation.install_root || null,
+      current_release: state.activeReleaseId,
+      installed_release_id: state.installedReleaseId,
+      active_release_id: state.activeReleaseId,
+      current_environment: bundle.environment || state.installation.current_environment || null,
+      install_root: state.installation.install_root || null,
       scene_binding_count: sceneBindings.length,
-      release_count: releases.length
+      release_count: state.releases.length
     },
-    mb_status: runtimeRelease.runtime_status || installation.status || bundle.status || 'unknown'
+    mb_status: runtimeRelease.runtime_status || state.installStatus || bundle.status || 'unknown'
   };
 }
 

package/lib/workspace/collab-governance-audit.js

@@ -50,6 +50,10 @@ const ACTIVE_TEXT_SCAN_EXCLUDES = Object.freeze([
 
 const LEGACY_REFERENCE_REGEX = /\.kiro(?:[\\/]|-workspaces\b)/;
 const MULTI_AGENT_CONFIG_REFERENCE = '.sce/config/multi-agent.json';
+const ERRORBOOK_REGISTRY_CONFIG_PATH = '.sce/config/errorbook-registry.json';
+const PROJECT_SHARED_ERRORBOOK_REGISTRY_PATH = '.sce/knowledge/errorbook/project-shared-registry.json';
+const PROJECT_SHARED_ERRORBOOK_SOURCE_NAME = 'project-shared';
+const ADOPTION_CONFIG_PATH = '.sce/adoption-config.json';
 
 const REQUIRED_GITIGNORE_RULES = Object.freeze([
   { rule: '.sce/steering/CURRENT_CONTEXT.md', sample: '.sce/steering/CURRENT_CONTEXT.md' },
@@ -377,6 +381,250 @@ function validateMultiAgentConfig(payload) {
   return violations;
 }
 
+function validateErrorbookRegistryConfig(payload) {
+  const violations = [];
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    violations.push('errorbook registry config must be a JSON object');
+    return violations;
+  }
+
+  if (typeof payload.enabled !== 'boolean') {
+    violations.push('errorbook registry config must declare boolean field "enabled"');
+  } else if (payload.enabled !== true) {
+    violations.push('errorbook registry config must keep "enabled" set to true under co-work baseline');
+  }
+
+  if (typeof payload.cache_file !== 'string' || !payload.cache_file.trim()) {
+    violations.push('errorbook registry config must declare non-empty field "cache_file"');
+  }
+
+  const projection = payload.project_shared_projection;
+  if (!projection || typeof projection !== 'object' || Array.isArray(projection)) {
+    violations.push('errorbook registry config must declare object field "project_shared_projection"');
+  } else {
+    if (projection.enabled !== true) {
+      violations.push('errorbook registry config must keep project_shared_projection.enabled=true under co-work baseline');
+    }
+    if (typeof projection.file !== 'string' || !projection.file.trim()) {
+      violations.push('errorbook registry config must declare non-empty project_shared_projection.file');
+    }
+    if (!Array.isArray(projection.statuses) || projection.statuses.length === 0) {
+      violations.push('errorbook registry config must declare non-empty project_shared_projection.statuses');
+    }
+    if (!Number.isFinite(Number(projection.min_quality))) {
+      violations.push('errorbook registry config must declare numeric project_shared_projection.min_quality');
+    }
+  }
+
+  const sources = Array.isArray(payload.sources) ? payload.sources : [];
+  if (sources.length === 0) {
+    violations.push('errorbook registry config must declare at least one registry source');
+    return violations;
+  }
+
+  const enabledSources = sources.filter((item) => {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) {
+      return false;
+    }
+    const enabled = item.enabled !== false;
+    const source = typeof item.url === 'string' && item.url.trim()
+      ? item.url.trim()
+      : typeof item.file === 'string' && item.file.trim()
+        ? item.file.trim()
+        : typeof item.path === 'string' && item.path.trim()
+          ? item.path.trim()
+          : '';
+    return enabled && Boolean(source);
+  });
+
+  if (enabledSources.length === 0) {
+    violations.push('errorbook registry config must keep at least one enabled source with a non-empty url/file');
+  }
+
+  if (projection && typeof projection === 'object' && !Array.isArray(projection)) {
+    const hasProjectSharedSource = enabledSources.some((item) => {
+      const name = typeof item.name === 'string' ? item.name.trim() : '';
+      const file = typeof item.file === 'string' ? item.file.trim() : '';
+      const sourcePath = typeof item.path === 'string' ? item.path.trim() : '';
+      return name === PROJECT_SHARED_ERRORBOOK_SOURCE_NAME
+        || file === projection.file
+        || sourcePath === projection.file;
+    });
+    if (!hasProjectSharedSource) {
+      violations.push('errorbook registry config must keep an enabled project-shared source aligned with project_shared_projection.file');
+    }
+  }
+
+  return violations;
+}
+
+async function inspectErrorbookRegistry(projectRoot, gitSnapshot, options = {}, dependencies = {}) {
+  const fileSystem = dependencies.fileSystem || fs;
+  const configPath = path.join(projectRoot, '.sce', 'config', 'errorbook-registry.json');
+  const exists = await fileSystem.pathExists(configPath);
+  const report = {
+    file: ERRORBOOK_REGISTRY_CONFIG_PATH,
+    exists,
+    valid: false,
+    enabled: null,
+    enabled_source_count: 0,
+    project_shared_projection_file: PROJECT_SHARED_ERRORBOOK_REGISTRY_PATH,
+    project_shared_projection_exists: false,
+    project_shared_projection_tracked: null,
+    warnings: [],
+    violations: [],
+    passed: true,
+    reason: 'passed'
+  };
+
+  if (!exists) {
+    report.passed = false;
+    report.reason = 'missing-config';
+    report.violations.push('shared errorbook registry config is missing');
+    return report;
+  }
+
+  let payload;
+  try {
+    payload = await fileSystem.readJson(configPath);
+  } catch (error) {
+    report.passed = false;
+    report.reason = 'invalid-json';
+    report.violations.push(`invalid errorbook registry config: ${error.message}`);
+    return report;
+  }
+
+  const validationErrors = validateErrorbookRegistryConfig(payload);
+  report.valid = validationErrors.length === 0;
+  report.enabled = typeof payload.enabled === 'boolean' ? payload.enabled : null;
+  report.project_shared_projection_file = payload
+    && payload.project_shared_projection
+    && typeof payload.project_shared_projection.file === 'string'
+    && payload.project_shared_projection.file.trim()
+    ? normalizeRelativePath(projectRoot, payload.project_shared_projection.file.trim()) || payload.project_shared_projection.file.trim()
+    : PROJECT_SHARED_ERRORBOOK_REGISTRY_PATH;
+  report.enabled_source_count = Array.isArray(payload.sources)
+    ? payload.sources.filter((item) => {
+      if (!item || typeof item !== 'object' || Array.isArray(item) || item.enabled === false) {
+        return false;
+      }
+      return (
+        (typeof item.url === 'string' && item.url.trim())
+        || (typeof item.file === 'string' && item.file.trim())
+        || (typeof item.path === 'string' && item.path.trim())
+      );
+    }).length
+    : 0;
+
+  if (validationErrors.length > 0) {
+    report.passed = false;
+    report.reason = 'invalid-config';
+    report.violations.push(...validationErrors);
+    return report;
+  }
+
+  const projectionFile = report.project_shared_projection_file;
+  const projectionAbsolutePath = path.isAbsolute(projectionFile)
+    ? projectionFile
+    : path.join(projectRoot, projectionFile);
+  report.project_shared_projection_exists = await fileSystem.pathExists(projectionAbsolutePath);
+  if (!report.project_shared_projection_exists) {
+    report.passed = false;
+    report.reason = 'missing-project-shared-projection';
+    report.violations.push(`shared project errorbook projection file is missing: ${projectionFile}`);
+    return report;
+  }
+
+  try {
+    const projectionPayload = await fileSystem.readJson(projectionAbsolutePath);
+    if (!projectionPayload || typeof projectionPayload !== 'object' || Array.isArray(projectionPayload)) {
+      report.violations.push(`shared project errorbook projection must be a JSON object: ${projectionFile}`);
+    } else if (!Array.isArray(projectionPayload.entries)) {
+      report.violations.push(`shared project errorbook projection must declare entries[]: ${projectionFile}`);
+    }
+  } catch (error) {
+    report.violations.push(`invalid shared project errorbook projection: ${error.message}`);
+  }
+
+  if (gitSnapshot && gitSnapshot.available === true) {
+    report.project_shared_projection_tracked = gitSnapshot.tracked_files.has(projectionFile);
+    if (report.project_shared_projection_tracked !== true) {
+      report.violations.push(`shared project errorbook projection must be tracked by git: ${projectionFile}`);
+    }
+  }
+
+  if (report.violations.length > 0) {
+    report.passed = false;
+    report.reason = 'invalid-config';
+  }
+
+  return report;
+}
+
+async function inspectErrorbookConvergence(projectRoot, options = {}, dependencies = {}) {
+  const fileSystem = dependencies.fileSystem || fs;
+  const configPath = path.join(projectRoot, '.sce', 'adoption-config.json');
+  const exists = await fileSystem.pathExists(configPath);
+  const report = {
+    file: ADOPTION_CONFIG_PATH,
+    exists,
+    managed_project: exists,
+    warnings: [],
+    violations: [],
+    passed: true,
+    reason: exists ? 'passed' : 'not-managed'
+  };
+
+  if (!exists) {
+    return report;
+  }
+
+  let payload;
+  try {
+    payload = await fileSystem.readJson(configPath);
+  } catch (error) {
+    report.passed = false;
+    report.reason = 'invalid-json';
+    report.violations.push(`invalid adoption config: ${error.message}`);
+    return report;
+  }
+
+  const convergence = payload
+    && payload.defaults
+    && payload.defaults.errorbook_convergence
+    && typeof payload.defaults.errorbook_convergence === 'object'
+    && !Array.isArray(payload.defaults.errorbook_convergence)
+    ? payload.defaults.errorbook_convergence
+    : null;
+
+  if (!convergence) {
+    report.passed = false;
+    report.reason = 'missing-convergence';
+    report.violations.push('managed adoption baseline is missing defaults.errorbook_convergence');
+    return report;
+  }
+
+  if (convergence.enabled !== true) {
+    report.violations.push('managed adoption baseline must keep errorbook_convergence.enabled=true');
+  }
+  if (convergence.canonical_mechanism !== 'errorbook') {
+    report.violations.push('managed adoption baseline must keep errorbook_convergence.canonical_mechanism=errorbook');
+  }
+  if (convergence.disallow_parallel_mechanisms !== true) {
+    report.violations.push('managed adoption baseline must keep errorbook_convergence.disallow_parallel_mechanisms=true');
+  }
+  if (convergence.strategy !== 'absorb_into_sce_errorbook') {
+    report.violations.push('managed adoption baseline must keep errorbook_convergence.strategy=absorb_into_sce_errorbook');
+  }
+
+  if (report.violations.length > 0) {
+    report.passed = false;
+    report.reason = 'convergence-drift';
+  }
+
+  return report;
+}
+
 async function inspectMultiAgentConfig(projectRoot, scanResult, options = {}, dependencies = {}) {
   const fileSystem = dependencies.fileSystem || fs;
   const configPath = path.join(projectRoot, '.sce', 'config', 'multi-agent.json');
@@ -497,6 +745,8 @@ async function auditCollabGovernance(projectRoot = process.cwd(), options = {},
   const runtimeTracking = inspectRuntimeTracking(gitSnapshot);
   const scanResult = await scanActiveTextReferences(projectRoot, gitSnapshot.tracked_files, options, dependencies);
   const multiAgent = await inspectMultiAgentConfig(projectRoot, scanResult, options, dependencies);
+  const errorbookRegistry = await inspectErrorbookRegistry(projectRoot, gitSnapshot, options, dependencies);
+  const errorbookConvergence = await inspectErrorbookConvergence(projectRoot, options, dependencies);
   const steeringBoundary = inspectSteeringBoundary(projectRoot);
 
   const legacyReferences = {
@@ -521,6 +771,8 @@ async function auditCollabGovernance(projectRoot = process.cwd(), options = {},
     gitignore,
     runtime_tracking: runtimeTracking,
     multi_agent: multiAgent,
+    errorbook_registry: errorbookRegistry,
+    errorbook_convergence: errorbookConvergence,
     legacy_references: legacyReferences,
     steering_boundary: steeringBoundary,
     summary: {
@@ -528,6 +780,8 @@ async function auditCollabGovernance(projectRoot = process.cwd(), options = {},
       tracked_runtime_files: runtimeTracking.tracked_runtime_files.length,
       multi_agent_warnings: multiAgent.warnings.length,
       multi_agent_violations: multiAgent.violations.length,
+      errorbook_registry_violations: errorbookRegistry.violations.length,
+      errorbook_convergence_violations: errorbookConvergence.violations.length,
       legacy_reference_count: legacyReferences.matches.length,
       steering_boundary_violations: steeringBoundary.violations.length
     },
@@ -541,12 +795,16 @@ async function auditCollabGovernance(projectRoot = process.cwd(), options = {},
   report.warnings.push(...(gitSnapshot.available === true ? gitSnapshot.warnings : []));
   report.warnings.push(...runtimeTracking.warnings);
   report.warnings.push(...multiAgent.warnings);
+  report.warnings.push(...errorbookRegistry.warnings);
+  report.warnings.push(...errorbookConvergence.warnings);
   report.warnings.push(...legacyReferences.warnings);
   report.warnings.push(...steeringBoundary.warnings);
 
   report.violations.push(...gitignore.violations);
   report.violations.push(...runtimeTracking.violations);
   report.violations.push(...multiAgent.violations);
+  report.violations.push(...errorbookRegistry.violations);
+  report.violations.push(...errorbookConvergence.violations);
   report.violations.push(...legacyReferences.violations);
   report.violations.push(
     ...steeringBoundary.violations.map((item) => `steering boundary violation: ${item.path || item.name}`)
@@ -568,8 +826,11 @@ module.exports = {
   RUNTIME_TRACKED_PATTERNS,
   auditCollabGovernance,
   inspectGitignore,
+  inspectErrorbookConvergence,
+  inspectErrorbookRegistry,
   inspectMultiAgentConfig,
   inspectRuntimeTracking,
   scanActiveTextReferences,
+  validateErrorbookRegistryConfig,
   validateMultiAgentConfig
 };