scene-capability-engine 3.6.53 → 3.6.55

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([
@@ -53,6 +58,8 @@ 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([
@@ -625,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');
@@ -747,6 +849,7 @@ async function auditCollabGovernance(projectRoot = process.cwd(), options = {},
   const multiAgent = await inspectMultiAgentConfig(projectRoot, scanResult, 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 = {
@@ -773,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: {
@@ -782,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
     },
@@ -797,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);
 
@@ -805,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
   };
 }

package/lib/workspace/takeover-baseline.js

@@ -235,6 +235,11 @@ const PROBLEM_CLOSURE_POLICY_DEFAULTS = Object.freeze({
   schema_version: '1.0',
   enabled: true,
   governance_report_path: '.sce/reports/interactive-governance-report.json',
+  project_shared_projection: {
+    enabled: true,
+    file: '.sce/knowledge/problem/project-shared-problems.json',
+    scope: 'non_completed'
+  },
   verify: {
     require_problem_contract: true,
     require_domain_validation: true,
@@ -335,6 +340,11 @@ const TAKEOVER_DEFAULTS = Object.freeze({
   problem_closure: {
     enabled: true,
     governance_report_path: '.sce/reports/interactive-governance-report.json',
+    project_shared_projection: {
+      enabled: true,
+      file: '.sce/knowledge/problem/project-shared-problems.json',
+      scope: 'non_completed'
+    },
     verify: {
       require_problem_contract: true,
       require_domain_validation: true,
@@ -577,6 +587,53 @@ function _buildProjectSharedErrorbookRegistry(existing, projectPath, nowIso, con
   };
 }
 
+function _buildProjectSharedProblemProjection(existing, projectPath, config = {}) {
+  const projection = _isObject(config.project_shared_projection)
+    ? config.project_shared_projection
+    : _clone(PROBLEM_CLOSURE_POLICY_DEFAULTS.project_shared_projection);
+  const fallback = {
+    api_version: 'sce.project-problem-projection/v0.1',
+    generated_at: new Date().toISOString(),
+    source: {
+      project: path.basename(projectPath),
+      scope: typeof projection.scope === 'string' && projection.scope.trim()
+        ? projection.scope.trim()
+        : 'non_completed',
+      stale_days: 14
+    },
+    summary: {
+      total_entries: 0,
+      active_entries: 0,
+      stale_entries: 0,
+      completed_entries: 0
+    },
+    entries: []
+  };
+  if (!_isObject(existing) || !Array.isArray(existing.entries)) {
+    return fallback;
+  }
+  return {
+    ...fallback,
+    ...existing,
+    source: _isObject(existing.source)
+      ? {
+        ...fallback.source,
+        ...existing.source
+      }
+      : fallback.source,
+    summary: _isObject(existing.summary)
+      ? {
+        ...fallback.summary,
+        ...existing.summary,
+        total_entries: Array.isArray(existing.entries) ? existing.entries.length : Number(existing.summary.total_entries || 0)
+      }
+      : {
+        ...fallback.summary,
+        total_entries: Array.isArray(existing.entries) ? existing.entries.length : 0
+      }
+  };
+}
+
 function _normalizeRelativePath(value) {
   return `${value || ''}`.replace(/\\/g, '/');
 }
@@ -925,6 +982,20 @@ async function applyTakeoverBaseline(projectPath = process.cwd(), options = {})
   const desiredSpecDomainPolicy = _deepMerge(existingSpecDomainPolicy || {}, SPEC_DOMAIN_POLICY_DEFAULTS);
   const desiredProblemEvalPolicy = _deepMerge(existingProblemEvalPolicy || {}, PROBLEM_EVAL_POLICY_DEFAULTS);
   const desiredProblemClosurePolicy = _deepMerge(existingProblemClosurePolicy || {}, PROBLEM_CLOSURE_POLICY_DEFAULTS);
+  const projectSharedProblemRelativePath = _isObject(desiredProblemClosurePolicy.project_shared_projection)
+    && typeof desiredProblemClosurePolicy.project_shared_projection.file === 'string'
+    && desiredProblemClosurePolicy.project_shared_projection.file.trim()
+    ? desiredProblemClosurePolicy.project_shared_projection.file.trim()
+    : PROBLEM_CLOSURE_POLICY_DEFAULTS.project_shared_projection.file;
+  const projectSharedProblemPath = path.isAbsolute(projectSharedProblemRelativePath)
+    ? projectSharedProblemRelativePath
+    : path.join(projectPath, projectSharedProblemRelativePath);
+  const existingProjectSharedProblemProjection = await _readJsonSafe(projectSharedProblemPath, fileSystem);
+  const desiredProjectSharedProblemProjection = _buildProjectSharedProblemProjection(
+    existingProjectSharedProblemProjection,
+    projectPath,
+    desiredProblemClosurePolicy
+  );
   const desiredStudioIntakePolicy = _deepMerge(existingStudioIntakePolicy || {}, STUDIO_INTAKE_POLICY_DEFAULTS);
   const desiredStateStoragePolicy = _deepMerge(existingStateStoragePolicy || {}, cloneStateStoragePolicyDefaults());
   const customErrorbookFindings = await _scanProjectDefinedErrorbookMechanisms(projectPath, fileSystem);
@@ -981,6 +1052,11 @@ async function applyTakeoverBaseline(projectPath = process.cwd(), options = {})
     apply,
     fileSystem
   }));
+  fileResults.push(await _reconcileJsonFile(projectSharedProblemPath, desiredProjectSharedProblemProjection, {
+    projectPath,
+    apply,
+    fileSystem
+  }));
   fileResults.push(await _reconcileJsonFile(studioIntakePolicyPath, desiredStudioIntakePolicy, {
     projectPath,
     apply,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scene-capability-engine",
-  "version": "3.6.53",
+  "version": "3.6.55",
   "description": "SCE (Scene Capability Engine) - A CLI tool and npm package for spec-driven development with AI coding assistants.",
   "main": "index.js",
   "bin": {

package/template/.sce/README.md

@@ -243,6 +243,6 @@ A Spec is a complete feature definition with three parts:
 ---
 
 **Project Type**: Spec-driven development  
-**sce Version**: 3.6.53  
+**sce Version**: 3.6.55  
 **Last Updated**: 2026-03-16  
 **Purpose**: Guide AI tools to work effectively with this project

package/template/.sce/config/problem-closure-policy.json

@@ -2,6 +2,11 @@
   "schema_version": "1.0",
   "enabled": true,
   "governance_report_path": ".sce/reports/interactive-governance-report.json",
+  "project_shared_projection": {
+    "enabled": true,
+    "file": ".sce/knowledge/problem/project-shared-problems.json",
+    "scope": "non_completed"
+  },
   "verify": {
     "require_problem_contract": true,
     "require_domain_validation": true,

package/template/.sce/knowledge/problem/project-shared-problems.json

@@ -0,0 +1,16 @@
+{
+  "api_version": "sce.project-problem-projection/v0.1",
+  "generated_at": "2026-03-16T00:00:00.000Z",
+  "source": {
+    "project": "template",
+    "scope": "non_completed",
+    "stale_days": 14
+  },
+  "summary": {
+    "total_entries": 0,
+    "active_entries": 0,
+    "stale_entries": 0,
+    "completed_entries": 0
+  },
+  "entries": []
+}