scene-capability-engine 3.6.52 → 3.6.54

package/lib/problem/project-problem-projection.js

@@ -0,0 +1,239 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs-extra');
+
+const {
+  loadStudioIntakePolicy,
+  scanSpecPortfolio
+} = require('../studio/spec-intake-governor');
+
+const PROJECT_SHARED_PROBLEM_PROJECTION_API_VERSION = 'sce.project-problem-projection/v0.1';
+const DEFAULT_PROBLEM_CLOSURE_POLICY_PATH = '.sce/config/problem-closure-policy.json';
+const DEFAULT_PROJECT_SHARED_PROBLEM_FILE = '.sce/knowledge/problem/project-shared-problems.json';
+const DEFAULT_PROJECT_SHARED_PROBLEM_SCOPE = 'non_completed';
+
+function normalizeText(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function normalizeProblemProjectionScope(value, fallback = DEFAULT_PROJECT_SHARED_PROBLEM_SCOPE) {
+  const normalized = normalizeText(`${value || ''}`).toLowerCase();
+  if (!normalized) {
+    return fallback;
+  }
+  if (normalized === 'all' || normalized === 'non_completed' || normalized === 'active_only') {
+    return normalized;
+  }
+  throw new Error('project_shared_projection.scope must be one of: all, non_completed, active_only');
+}
+
+function normalizeProblemProjectionConfig(payload = {}) {
+  const candidate = payload && typeof payload === 'object' && !Array.isArray(payload)
+    ? payload
+    : {};
+  return {
+    enabled: candidate.enabled !== false,
+    file: normalizeText(candidate.file || DEFAULT_PROJECT_SHARED_PROBLEM_FILE) || DEFAULT_PROJECT_SHARED_PROBLEM_FILE,
+    scope: normalizeProblemProjectionScope(candidate.scope, DEFAULT_PROJECT_SHARED_PROBLEM_SCOPE)
+  };
+}
+
+async function readProblemClosurePolicy(projectPath = process.cwd(), fileSystem = fs, configPath = DEFAULT_PROBLEM_CLOSURE_POLICY_PATH) {
+  const absolutePath = path.isAbsolute(configPath)
+    ? configPath
+    : path.join(projectPath, configPath);
+  if (!await fileSystem.pathExists(absolutePath)) {
+    return {
+      exists: false,
+      path: absolutePath,
+      payload: null,
+      project_shared_projection: normalizeProblemProjectionConfig({})
+    };
+  }
+
+  const payload = await fileSystem.readJson(absolutePath);
+  return {
+    exists: true,
+    path: absolutePath,
+    payload,
+    project_shared_projection: normalizeProblemProjectionConfig(payload.project_shared_projection)
+  };
+}
+
+async function readJsonSafe(filePath, fileSystem = fs) {
+  if (!await fileSystem.pathExists(filePath)) {
+    return null;
+  }
+  return fileSystem.readJson(filePath).catch(() => null);
+}
+
+function pickScopeRecords(records = [], scope = DEFAULT_PROJECT_SHARED_PROBLEM_SCOPE) {
+  if (scope === 'all') {
+    return records;
+  }
+  if (scope === 'active_only') {
+    return records.filter((item) => item.lifecycle_state === 'active');
+  }
+  return records.filter((item) => item.lifecycle_state !== 'completed');
+}
+
+function toRelativePosix(projectPath, absolutePath) {
+  return path.relative(projectPath, absolutePath).replace(/\\/g, '/');
+}
+
+async function buildProjectSharedProblemProjection(projectPath = process.cwd(), options = {}, dependencies = {}) {
+  const fileSystem = dependencies.fileSystem || fs;
+  const studioIntakePolicy = dependencies.studioIntakePolicy || await loadStudioIntakePolicy(projectPath, fileSystem);
+  const staleDays = Number(
+    options.staleDays
+    || studioIntakePolicy?.governance?.stale_days
+    || 14
+  );
+  const closurePolicy = dependencies.problemClosurePolicyBundle
+    || await readProblemClosurePolicy(projectPath, fileSystem, options.policyPath || DEFAULT_PROBLEM_CLOSURE_POLICY_PATH);
+  const projectionConfig = normalizeProblemProjectionConfig(
+    options.projectSharedProjection || closurePolicy.project_shared_projection
+  );
+  const scanOptions = {
+    staleDays
+  };
+  const records = dependencies.specPortfolio
+    || await scanSpecPortfolio(projectPath, scanOptions, { fileSystem });
+  const scopedRecords = pickScopeRecords(records, projectionConfig.scope);
+  const entries = [];
+
+  for (const record of scopedRecords) {
+    const specRoot = path.join(projectPath, '.sce', 'specs', record.spec_id);
+    const contractPath = path.join(specRoot, 'custom', 'problem-contract.json');
+    const domainChainPath = path.join(specRoot, 'custom', 'problem-domain-chain.json');
+    const contract = await readJsonSafe(contractPath, fileSystem);
+    const domainChain = await readJsonSafe(domainChainPath, fileSystem);
+    const problemStatement = normalizeText(
+      record.problem_statement
+      || (contract && contract.issue_statement)
+      || (domainChain && domainChain.problem && domainChain.problem.statement)
+    );
+
+    if (!problemStatement) {
+      continue;
+    }
+
+    const summary = domainChain && domainChain.summary && typeof domainChain.summary === 'object'
+      ? domainChain.summary
+      : {};
+    const ontologyCounts = summary.ontology_counts && typeof summary.ontology_counts === 'object'
+      ? summary.ontology_counts
+      : {};
+
+    entries.push({
+      spec_id: record.spec_id,
+      scene_id: record.scene_id || null,
+      lifecycle_state: record.lifecycle_state || null,
+      updated_at: record.updated_at || null,
+      age_days: Number.isFinite(Number(record.age_days)) ? Number(record.age_days) : null,
+      tasks_total: Number.isFinite(Number(record.tasks_total)) ? Number(record.tasks_total) : 0,
+      tasks_done: Number.isFinite(Number(record.tasks_done)) ? Number(record.tasks_done) : 0,
+      tasks_progress: Number.isFinite(Number(record.tasks_progress)) ? Number(record.tasks_progress) : 0,
+      problem_statement: problemStatement,
+      expected_outcome: normalizeText(contract && contract.expected_outcome),
+      impact_scope: normalizeText(contract && contract.impact_scope),
+      reproduction_steps: Array.isArray(contract && contract.reproduction_steps) ? contract.reproduction_steps : [],
+      forbidden_workarounds: Array.isArray(contract && contract.forbidden_workarounds)
+        ? contract.forbidden_workarounds
+        : [],
+      verification_gates: Array.isArray(summary.verification_gates) ? summary.verification_gates : [],
+      ontology_counts: {
+        entity: Number(ontologyCounts.entity || 0),
+        relation: Number(ontologyCounts.relation || 0),
+        business_rule: Number(ontologyCounts.business_rule || 0),
+        decision_policy: Number(ontologyCounts.decision_policy || 0),
+        execution_flow: Number(ontologyCounts.execution_flow || 0)
+      },
+      evidence_binding_count: Number(summary.evidence_binding_count || 0),
+      hypothesis_count: Number(summary.hypothesis_count || 0),
+      risk_count: Number(summary.risk_count || 0),
+      paths: {
+        problem_contract: await fileSystem.pathExists(contractPath) ? toRelativePosix(projectPath, contractPath) : null,
+        problem_domain_chain: await fileSystem.pathExists(domainChainPath) ? toRelativePosix(projectPath, domainChainPath) : null
+      }
+    });
+  }
+
+  entries.sort((left, right) => String(right.updated_at || '').localeCompare(String(left.updated_at || '')));
+  const activeCount = entries.filter((item) => item.lifecycle_state === 'active').length;
+  const staleCount = entries.filter((item) => item.lifecycle_state === 'stale').length;
+  const completedCount = entries.filter((item) => item.lifecycle_state === 'completed').length;
+
+  return {
+    api_version: PROJECT_SHARED_PROBLEM_PROJECTION_API_VERSION,
+    generated_at: new Date().toISOString(),
+    source: {
+      project: path.basename(projectPath),
+      stale_days: staleDays,
+      scope: projectionConfig.scope
+    },
+    summary: {
+      total_entries: entries.length,
+      active_entries: activeCount,
+      stale_entries: staleCount,
+      completed_entries: completedCount
+    },
+    entries
+  };
+}
+
+async function syncProjectSharedProblemProjection(projectPath = process.cwd(), options = {}, dependencies = {}) {
+  const fileSystem = dependencies.fileSystem || fs;
+  const closurePolicy = dependencies.problemClosurePolicyBundle
+    || await readProblemClosurePolicy(projectPath, fileSystem, options.policyPath || DEFAULT_PROBLEM_CLOSURE_POLICY_PATH);
+  const projectionConfig = normalizeProblemProjectionConfig(
+    options.projectSharedProjection || closurePolicy.project_shared_projection
+  );
+  const absolutePath = path.isAbsolute(projectionConfig.file)
+    ? projectionConfig.file
+    : path.join(projectPath, projectionConfig.file);
+
+  if (projectionConfig.enabled !== true) {
+    return {
+      mode: 'project-problem-projection-sync',
+      enabled: false,
+      file: absolutePath,
+      scope: projectionConfig.scope,
+      total_entries: 0,
+      refreshed: false
+    };
+  }
+
+  const payload = await buildProjectSharedProblemProjection(projectPath, {
+    ...options,
+    projectSharedProjection: projectionConfig
+  }, {
+    ...dependencies,
+    problemClosurePolicyBundle: closurePolicy
+  });
+
+  await fileSystem.ensureDir(path.dirname(absolutePath));
+  await fileSystem.writeJson(absolutePath, payload, { spaces: 2 });
+
+  return {
+    mode: 'project-problem-projection-sync',
+    enabled: true,
+    file: absolutePath,
+    scope: projectionConfig.scope,
+    total_entries: Number(payload.summary.total_entries || payload.entries.length || 0),
+    refreshed: true
+  };
+}
+
+module.exports = {
+  PROJECT_SHARED_PROBLEM_PROJECTION_API_VERSION,
+  DEFAULT_PROBLEM_CLOSURE_POLICY_PATH,
+  DEFAULT_PROJECT_SHARED_PROBLEM_FILE,
+  DEFAULT_PROJECT_SHARED_PROBLEM_SCOPE,
+  normalizeProblemProjectionScope,
+  normalizeProblemProjectionConfig,
+  readProblemClosurePolicy,
+  buildProjectSharedProblemProjection,
+  syncProjectSharedProblemProjection
+};

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

@@ -5,6 +5,11 @@ const path = require('path');
 const { minimatch } = require('minimatch');
 const { loadGitSnapshot } = require('./spec-delivery-audit');
 const SteeringComplianceChecker = require('../steering/steering-compliance-checker');
+const {
+  normalizeProblemProjectionConfig,
+  DEFAULT_PROBLEM_CLOSURE_POLICY_PATH,
+  DEFAULT_PROJECT_SHARED_PROBLEM_FILE
+} = require('../problem/project-problem-projection');
 
 const MAX_SCAN_BYTES = 256 * 1024;
 const ACTIVE_TEXT_EXTENSIONS = new Set([
@@ -51,6 +56,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 PROBLEM_CLOSURE_POLICY_PATH = DEFAULT_PROBLEM_CLOSURE_POLICY_PATH;
+const PROJECT_SHARED_PROBLEM_FILE_PATH = DEFAULT_PROJECT_SHARED_PROBLEM_FILE;
 const ADOPTION_CONFIG_PATH = '.sce/adoption-config.json';
 
 const REQUIRED_GITIGNORE_RULES = Object.freeze([
@@ -396,6 +405,24 @@ function validateErrorbookRegistryConfig(payload) {
     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');
@@ -407,18 +434,38 @@ function validateErrorbookRegistryConfig(payload) {
       return false;
     }
     const enabled = item.enabled !== false;
-    const url = typeof item.url === 'string' ? item.url.trim() : '';
-    return enabled && Boolean(url);
+    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"');
+    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, options = {}, dependencies = {}) {
+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);
@@ -428,6 +475,9 @@ async function inspectErrorbookRegistry(projectRoot, options = {}, dependencies
     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,
@@ -454,8 +504,23 @@ async function inspectErrorbookRegistry(projectRoot, options = {}, dependencies
   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) => item && typeof item === 'object' && item.enabled !== false && typeof item.url === 'string' && item.url.trim()).length
+    ? 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) {
@@ -465,6 +530,41 @@ async function inspectErrorbookRegistry(projectRoot, options = {}, dependencies
     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;
 }
 
@@ -532,6 +632,101 @@ async function inspectErrorbookConvergence(projectRoot, options = {}, dependenci
   return report;
 }
 
+async function inspectProjectProblemProjection(projectRoot, gitSnapshot, options = {}, dependencies = {}) {
+  const fileSystem = dependencies.fileSystem || fs;
+  const policyPath = path.join(projectRoot, PROBLEM_CLOSURE_POLICY_PATH);
+  const exists = await fileSystem.pathExists(policyPath);
+  const report = {
+    file: PROBLEM_CLOSURE_POLICY_PATH,
+    exists,
+    valid: false,
+    project_shared_projection_file: PROJECT_SHARED_PROBLEM_FILE_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('problem closure policy is missing');
+    return report;
+  }
+
+  let payload;
+  try {
+    payload = await fileSystem.readJson(policyPath);
+  } catch (error) {
+    report.passed = false;
+    report.reason = 'invalid-json';
+    report.violations.push(`invalid problem closure policy: ${error.message}`);
+    return report;
+  }
+
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    report.passed = false;
+    report.reason = 'invalid-config';
+    report.violations.push('problem closure policy must be a JSON object');
+    return report;
+  }
+
+  let projection;
+  try {
+    projection = normalizeProblemProjectionConfig(payload.project_shared_projection);
+  } catch (error) {
+    report.passed = false;
+    report.reason = 'invalid-config';
+    report.violations.push(error.message);
+    return report;
+  }
+  report.valid = true;
+  report.project_shared_projection_file = normalizeRelativePath(projectRoot, projection.file) || projection.file;
+
+  if (projection.enabled !== true) {
+    report.violations.push('problem closure policy must keep project_shared_projection.enabled=true under co-work baseline');
+  }
+  if (!projection.file) {
+    report.violations.push('problem closure policy must declare non-empty project_shared_projection.file');
+  }
+
+  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.violations.push(`shared project problem projection file is missing: ${projectionFile}`);
+  } else {
+    try {
+      const projectionPayload = await fileSystem.readJson(projectionAbsolutePath);
+      if (!projectionPayload || typeof projectionPayload !== 'object' || Array.isArray(projectionPayload)) {
+        report.violations.push(`shared project problem projection must be a JSON object: ${projectionFile}`);
+      } else if (!Array.isArray(projectionPayload.entries)) {
+        report.violations.push(`shared project problem projection must declare entries[]: ${projectionFile}`);
+      }
+    } catch (error) {
+      report.violations.push(`invalid shared project problem 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 problem projection must be tracked by git: ${projectionFile}`);
+    }
+  }
+
+  if (report.violations.length > 0) {
+    report.passed = false;
+    report.reason = 'projection-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');
@@ -652,8 +847,9 @@ 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, options, dependencies);
+  const errorbookRegistry = await inspectErrorbookRegistry(projectRoot, gitSnapshot, options, dependencies);
   const errorbookConvergence = await inspectErrorbookConvergence(projectRoot, options, dependencies);
+  const projectProblemProjection = await inspectProjectProblemProjection(projectRoot, gitSnapshot, options, dependencies);
   const steeringBoundary = inspectSteeringBoundary(projectRoot);
 
   const legacyReferences = {
@@ -680,6 +876,7 @@ async function auditCollabGovernance(projectRoot = process.cwd(), options = {},
     multi_agent: multiAgent,
     errorbook_registry: errorbookRegistry,
     errorbook_convergence: errorbookConvergence,
+    problem_projection: projectProblemProjection,
     legacy_references: legacyReferences,
     steering_boundary: steeringBoundary,
     summary: {
@@ -689,6 +886,7 @@ async function auditCollabGovernance(projectRoot = process.cwd(), options = {},
       multi_agent_violations: multiAgent.violations.length,
       errorbook_registry_violations: errorbookRegistry.violations.length,
       errorbook_convergence_violations: errorbookConvergence.violations.length,
+      problem_projection_violations: projectProblemProjection.violations.length,
       legacy_reference_count: legacyReferences.matches.length,
       steering_boundary_violations: steeringBoundary.violations.length
     },
@@ -704,6 +902,7 @@ async function auditCollabGovernance(projectRoot = process.cwd(), options = {},
   report.warnings.push(...multiAgent.warnings);
   report.warnings.push(...errorbookRegistry.warnings);
   report.warnings.push(...errorbookConvergence.warnings);
+  report.warnings.push(...projectProblemProjection.warnings);
   report.warnings.push(...legacyReferences.warnings);
   report.warnings.push(...steeringBoundary.warnings);
 
@@ -712,6 +911,7 @@ async function auditCollabGovernance(projectRoot = process.cwd(), options = {},
   report.violations.push(...multiAgent.violations);
   report.violations.push(...errorbookRegistry.violations);
   report.violations.push(...errorbookConvergence.violations);
+  report.violations.push(...projectProblemProjection.violations);
   report.violations.push(...legacyReferences.violations);
   report.violations.push(
     ...steeringBoundary.violations.map((item) => `steering boundary violation: ${item.path || item.name}`)

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

@@ -1,23 +1,43 @@
 'use strict';
 
 const { auditCollabGovernance } = require('./collab-governance-audit');
+const { syncProjectSharedProblemProjection } = require('../problem/project-problem-projection');
 
 async function evaluateCollabGovernanceGate(options = {}, dependencies = {}) {
   const projectPath = options.projectPath || dependencies.projectPath || process.cwd();
+  const warnings = [];
+  const preflightViolations = [];
+  let projectProblemProjection = null;
+
+  try {
+    projectProblemProjection = await (
+      dependencies.syncProjectSharedProblemProjection || syncProjectSharedProblemProjection
+    )(projectPath, options, dependencies);
+  } catch (error) {
+    preflightViolations.push(`project-shared problem projection sync failed: ${error.message}`);
+  }
+
   const audit = await (dependencies.auditCollabGovernance || auditCollabGovernance)(
     projectPath,
     options,
     dependencies
   );
+  warnings.push(...(Array.isArray(audit.warnings) ? audit.warnings : []));
+  const violations = [
+    ...preflightViolations,
+    ...(Array.isArray(audit.violations) ? audit.violations : [])
+  ];
+  const passed = audit.passed === true && preflightViolations.length === 0;
 
   return {
     mode: 'collab-governance-gate',
     project_path: projectPath,
-    passed: audit.passed === true,
-    reason: audit.reason || (audit.passed === true ? 'passed' : 'violations'),
+    passed,
+    reason: passed ? (audit.reason || 'passed') : 'violations',
     summary: audit.summary || {},
-    warnings: Array.isArray(audit.warnings) ? audit.warnings : [],
-    violations: Array.isArray(audit.violations) ? audit.violations : [],
+    warnings,
+    violations,
+    project_problem_projection_sync: projectProblemProjection,
     audit
   };
 }