scene-capability-engine 3.6.57 → 3.6.59

package/lib/project/portfolio-projection-service.js

@@ -0,0 +1,389 @@
+const crypto = require('crypto');
+const path = require('path');
+const fs = require('fs-extra');
+const WorkspaceStateManager = require('../workspace/multi/workspace-state-manager');
+const { SessionStore } = require('../runtime/session-store');
+const { getCurrentDeviceProfile } = require('../device/current-device');
+
+function normalizeString(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+function normalizePath(value) {
+  return normalizeString(value).replace(/\\/g, '/');
+}
+
+function buildWorkspaceProjectId(workspaceId) {
+  return `workspace:${workspaceId}`;
+}
+
+function buildLocalProjectId(projectRoot) {
+  const hash = crypto
+    .createHash('sha1')
+    .update(normalizePath(projectRoot))
+    .digest('hex')
+    .slice(0, 12);
+  return `local:${hash}`;
+}
+
+function safeIsoAt(value) {
+  const normalized = normalizeString(value);
+  if (!normalized) {
+    return null;
+  }
+  const time = Date.parse(normalized);
+  return Number.isFinite(time) ? new Date(time).toISOString() : null;
+}
+
+function collectRecordActivityTimestamps(sceneRecords = []) {
+  const timestamps = [];
+  for (const record of sceneRecords) {
+    const updatedAt = safeIsoAt(record && record.updated_at);
+    if (updatedAt) {
+      timestamps.push(updatedAt);
+    }
+    const cycles = Array.isArray(record && record.cycles) ? record.cycles : [];
+    for (const cycle of cycles) {
+      const startedAt = safeIsoAt(cycle && cycle.started_at);
+      const completedAt = safeIsoAt(cycle && cycle.completed_at);
+      if (startedAt) {
+        timestamps.push(startedAt);
+      }
+      if (completedAt) {
+        timestamps.push(completedAt);
+      }
+    }
+  }
+  timestamps.sort((left, right) => right.localeCompare(left));
+  return timestamps[0] || null;
+}
+
+async function isValidSceProjectRoot(projectRoot, fileSystem = fs) {
+  const sceRoot = path.join(projectRoot, '.sce');
+  if (!await fileSystem.pathExists(sceRoot)) {
+    return false;
+  }
+  try {
+    const stats = await fileSystem.stat(sceRoot);
+    return stats.isDirectory();
+  } catch (_error) {
+    return false;
+  }
+}
+
+async function countSpecDirectories(projectRoot, fileSystem = fs) {
+  const specsRoot = path.join(projectRoot, '.sce', 'specs');
+  if (!await fileSystem.pathExists(specsRoot)) {
+    return 0;
+  }
+  const entries = await fileSystem.readdir(specsRoot);
+  let count = 0;
+  for (const entry of entries) {
+    try {
+      const stats = await fileSystem.stat(path.join(specsRoot, entry));
+      if (stats.isDirectory()) {
+        count += 1;
+      }
+    } catch (_error) {
+      // Ignore unreadable spec directories and keep reporting partial state elsewhere.
+    }
+  }
+  return count;
+}
+
+function deriveAvailability({ accessible, partial }) {
+  if (!accessible) {
+    return 'inaccessible';
+  }
+  if (partial) {
+    return 'degraded';
+  }
+  return 'accessible';
+}
+
+function deriveReadiness({ accessible, partial, sceneCount, specCount }) {
+  if (!accessible) {
+    return 'unknown';
+  }
+  if (partial) {
+    return 'partial';
+  }
+  if (sceneCount === 0 && specCount === 0) {
+    return 'pending';
+  }
+  return 'ready';
+}
+
+function deriveStatus({ accessible, isCurrentProject, activeSessionCount }) {
+  if (!accessible) {
+    return 'inaccessible';
+  }
+  if (isCurrentProject) {
+    return 'active';
+  }
+  if (activeSessionCount > 0) {
+    return 'background';
+  }
+  return 'idle';
+}
+
+async function readSceneRecords(projectRoot, dependencies = {}) {
+  const fileSystem = dependencies.fileSystem || fs;
+  const env = dependencies.env || process.env;
+  const sqliteModule = dependencies.sqliteModule;
+  const sessionStore = new SessionStore(projectRoot, null, {
+    fileSystem,
+    env,
+    sqliteModule
+  });
+  return sessionStore.listSceneRecords();
+}
+
+async function buildRegisteredWorkspaceRecord(workspace, context = {}, dependencies = {}) {
+  const fileSystem = dependencies.fileSystem || fs;
+  const workspaceId = normalizeString(workspace && workspace.name);
+  const projectRoot = normalizePath(workspace && workspace.path);
+  const partialReasons = [];
+  const projectId = buildWorkspaceProjectId(workspaceId);
+  let accessible = false;
+  let partial = false;
+  let sceneRecords = [];
+  let specCount = 0;
+
+  const sceProject = await isValidSceProjectRoot(projectRoot, fileSystem);
+  if (!sceProject) {
+    partial = true;
+    partialReasons.push('workspace_root_unavailable');
+  } else {
+    accessible = true;
+    try {
+      sceneRecords = await readSceneRecords(projectRoot, dependencies);
+    } catch (_error) {
+      partial = true;
+      partialReasons.push('scene_records_unavailable');
+    }
+    try {
+      specCount = await countSpecDirectories(projectRoot, fileSystem);
+    } catch (_error) {
+      partial = true;
+      partialReasons.push('spec_inventory_unavailable');
+    }
+  }
+
+  const sceneCount = Array.isArray(sceneRecords) ? sceneRecords.length : 0;
+  const activeSessionCount = Array.isArray(sceneRecords)
+    ? sceneRecords.filter((record) => normalizeString(record && record.active_session_id)).length
+    : 0;
+  const lastActivityAt = collectRecordActivityTimestamps(sceneRecords);
+  const uniquePartialReasons = Array.from(new Set(partialReasons));
+  const isCurrentProject = context.projectId === projectId;
+
+  return {
+    projectId,
+    workspaceId,
+    projectRoot,
+    projectName: path.basename(projectRoot) || workspaceId,
+    provenance: 'registered',
+    readiness: deriveReadiness({
+      accessible,
+      partial,
+      sceneCount,
+      specCount
+    }),
+    status: deriveStatus({
+      accessible,
+      isCurrentProject,
+      activeSessionCount
+    }),
+    availability: deriveAvailability({
+      accessible,
+      partial
+    }),
+    activeSessionCount,
+    ...(lastActivityAt ? { lastActivityAt } : {}),
+    summary: {
+      sceneCount,
+      specCount
+    },
+    partial,
+    partialReasons: uniquePartialReasons
+  };
+}
+
+async function buildLocalProjectRecord(projectRoot, context = {}, dependencies = {}) {
+  const fileSystem = dependencies.fileSystem || fs;
+  const normalizedRoot = normalizePath(projectRoot);
+  const projectId = buildLocalProjectId(normalizedRoot);
+  let sceneRecords = [];
+  let specCount = 0;
+  const partialReasons = ['unregistered_project'];
+  let partial = true;
+
+  try {
+    sceneRecords = await readSceneRecords(normalizedRoot, dependencies);
+  } catch (_error) {
+    partialReasons.push('scene_records_unavailable');
+  }
+  try {
+    specCount = await countSpecDirectories(normalizedRoot, fileSystem);
+  } catch (_error) {
+    partialReasons.push('spec_inventory_unavailable');
+  }
+
+  const sceneCount = Array.isArray(sceneRecords) ? sceneRecords.length : 0;
+  const activeSessionCount = Array.isArray(sceneRecords)
+    ? sceneRecords.filter((record) => normalizeString(record && record.active_session_id)).length
+    : 0;
+  const lastActivityAt = collectRecordActivityTimestamps(sceneRecords);
+  const uniquePartialReasons = Array.from(new Set(partialReasons));
+  const isCurrentProject = context.projectId === projectId;
+
+  return {
+    projectId,
+    projectRoot: normalizedRoot,
+    projectName: path.basename(normalizedRoot) || 'local-project',
+    provenance: 'discovered',
+    readiness: deriveReadiness({
+      accessible: true,
+      partial,
+      sceneCount,
+      specCount
+    }),
+    status: deriveStatus({
+      accessible: true,
+      isCurrentProject,
+      activeSessionCount
+    }),
+    availability: deriveAvailability({
+      accessible: true,
+      partial
+    }),
+    activeSessionCount,
+    ...(lastActivityAt ? { lastActivityAt } : {}),
+    summary: {
+      sceneCount,
+      specCount
+    },
+    partial,
+    partialReasons: uniquePartialReasons
+  };
+}
+
+async function resolveCurrentProjectContext(options = {}, dependencies = {}) {
+  const stateManager = dependencies.stateManager || new WorkspaceStateManager(dependencies.workspaceStatePath);
+  const currentDir = normalizePath(dependencies.projectPath || process.cwd());
+  const explicitWorkspace = normalizeString(options.workspace);
+
+  if (explicitWorkspace) {
+    const workspace = await stateManager.getWorkspace(explicitWorkspace);
+    if (!workspace) {
+      throw new Error(`workspace not found: ${explicitWorkspace}`);
+    }
+    return {
+      workspaceId: workspace.name,
+      projectId: buildWorkspaceProjectId(workspace.name),
+      projectRoot: normalizePath(workspace.path),
+      source: 'explicit-workspace'
+    };
+  }
+
+  const matchedWorkspace = await stateManager.findWorkspaceByPath(currentDir);
+  if (matchedWorkspace) {
+    return {
+      workspaceId: matchedWorkspace.name,
+      projectId: buildWorkspaceProjectId(matchedWorkspace.name),
+      projectRoot: normalizePath(matchedWorkspace.path),
+      source: 'current-directory'
+    };
+  }
+
+  const activeWorkspace = await stateManager.getActiveWorkspace();
+  if (activeWorkspace) {
+    return {
+      workspaceId: activeWorkspace.name,
+      projectId: buildWorkspaceProjectId(activeWorkspace.name),
+      projectRoot: normalizePath(activeWorkspace.path),
+      source: 'active-workspace'
+    };
+  }
+
+  if (await isValidSceProjectRoot(currentDir, dependencies.fileSystem || fs)) {
+    return {
+      workspaceId: null,
+      projectId: buildLocalProjectId(currentDir),
+      projectRoot: currentDir,
+      source: 'local-project'
+    };
+  }
+
+  return {
+    workspaceId: null,
+    projectId: null,
+    projectRoot: null,
+    source: 'none'
+  };
+}
+
+async function buildProjectPortfolioProjection(options = {}, dependencies = {}) {
+  const stateManager = dependencies.stateManager || new WorkspaceStateManager(dependencies.workspaceStatePath);
+  const fileSystem = dependencies.fileSystem || fs;
+  const currentContext = await resolveCurrentProjectContext(options, {
+    ...dependencies,
+    stateManager
+  });
+  let currentDevice = null;
+
+  try {
+    currentDevice = await getCurrentDeviceProfile(dependencies.projectPath || process.cwd(), {
+      fileSystem,
+      persistIfMissing: false
+    });
+  } catch (_error) {
+    currentDevice = null;
+  }
+
+  const workspaces = await stateManager.listWorkspaces();
+  const records = [];
+  for (const workspace of workspaces) {
+    records.push(await buildRegisteredWorkspaceRecord(workspace, currentContext, dependencies));
+  }
+
+  const localRoot = normalizeString(currentContext.projectRoot);
+  const currentDirWorkspace = localRoot ? await stateManager.findWorkspaceByPath(localRoot) : null;
+  const shouldAddLocalProject = currentContext.source === 'local-project'
+    && localRoot
+    && !currentDirWorkspace;
+  if (shouldAddLocalProject) {
+    records.push(await buildLocalProjectRecord(localRoot, currentContext, dependencies));
+  }
+
+  records.sort((left, right) => {
+    const leftCurrent = left.projectId === currentContext.projectId ? 0 : 1;
+    const rightCurrent = right.projectId === currentContext.projectId ? 0 : 1;
+    if (leftCurrent !== rightCurrent) {
+      return leftCurrent - rightCurrent;
+    }
+    return `${left.projectName || left.projectId}`.localeCompare(`${right.projectName || right.projectId}`);
+  });
+
+  return {
+    generatedAt: new Date().toISOString(),
+    callerContext: {
+      ...(currentContext.workspaceId ? { workspaceId: currentContext.workspaceId } : {}),
+      ...(currentContext.projectId ? { projectId: currentContext.projectId } : {}),
+      ...(currentDevice && currentDevice.device_id ? { deviceId: currentDevice.device_id } : {})
+    },
+    ...(currentContext.projectId ? { activeProjectId: currentContext.projectId } : {}),
+    projects: records
+  };
+}
+
+module.exports = {
+  buildProjectPortfolioProjection,
+  buildWorkspaceProjectId,
+  buildLocalProjectId,
+  resolveCurrentProjectContext
+};

package/lib/project/supervision-projection-service.js

@@ -0,0 +1,329 @@
+const crypto = require('crypto');
+const path = require('path');
+const fs = require('fs-extra');
+const TaskClaimer = require('../task/task-claimer');
+const { SessionStore } = require('../runtime/session-store');
+const { buildProjectPortfolioProjection } = require('./portfolio-projection-service');
+
+const SPEC_GOVERNANCE_SCENE_INDEX = path.join('.sce', 'spec-governance', 'scene-index.json');
+const STUDIO_REPORT_DIR = path.join('.sce', 'reports', 'studio');
+const HANDOFF_REPORT_DIR = path.join('.sce', 'reports', 'handoff-runs');
+
+function normalizeString(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+function safeIsoAt(value) {
+  const normalized = normalizeString(value);
+  if (!normalized) {
+    return null;
+  }
+  const time = Date.parse(normalized);
+  return Number.isFinite(time) ? new Date(time).toISOString() : null;
+}
+
+function listObjectValues(value) {
+  if (!value || typeof value !== 'object') {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return Object.values(value);
+}
+
+async function readJsonIfExists(filePath, fileSystem = fs) {
+  if (!await fileSystem.pathExists(filePath)) {
+    return null;
+  }
+  try {
+    return await fileSystem.readJson(filePath);
+  } catch (_error) {
+    return null;
+  }
+}
+
+async function listJsonFiles(dirPath, fileSystem = fs) {
+  if (!await fileSystem.pathExists(dirPath)) {
+    return [];
+  }
+  const entries = await fileSystem.readdir(dirPath);
+  return entries
+    .filter((entry) => entry.toLowerCase().endsWith('.json'))
+    .map((entry) => path.join(dirPath, entry))
+    .sort((left, right) => left.localeCompare(right));
+}
+
+function collectLatestTimestamp(items = []) {
+  const timestamps = items
+    .map((item) => safeIsoAt(item && item.updatedAt))
+    .filter(Boolean)
+    .sort((left, right) => right.localeCompare(left));
+  return timestamps[0] || null;
+}
+
+function createCursor(projectId, latestEventAt, itemCount) {
+  const hash = crypto
+    .createHash('sha1')
+    .update(`${projectId}::${latestEventAt || 'none'}::${itemCount}`)
+    .digest('hex')
+    .slice(0, 12);
+  return `${latestEventAt || 'none'}::${itemCount}::${hash}`;
+}
+
+function resolveReportSceneId(report = {}) {
+  return normalizeString(report.scene_id)
+    || normalizeString(report?.domain_chain?.context?.scene_id)
+    || normalizeString(report?.domain_chain?.problem_contract?.scene_id);
+}
+
+function resolveReportSpecId(report = {}) {
+  return normalizeString(report.spec_id)
+    || normalizeString(report?.domain_chain?.spec_id);
+}
+
+function summarizeTaskCounts(tasks = []) {
+  const total = tasks.length;
+  const completed = tasks.filter((item) => item.status === 'completed').length;
+  const inProgress = tasks.filter((item) => item.status === 'in-progress').length;
+  const queued = tasks.filter((item) => item.status === 'queued').length;
+  const notStarted = tasks.filter((item) => item.status === 'not-started').length;
+  return {
+    total,
+    completed,
+    inProgress,
+    queued,
+    notStarted,
+    active: Math.max(total - completed, 0)
+  };
+}
+
+async function collectSpecTaskSummary(projectRoot, fileSystem = fs, taskClaimer = new TaskClaimer()) {
+  const specsRoot = path.join(projectRoot, '.sce', 'specs');
+  if (!await fileSystem.pathExists(specsRoot)) {
+    return {
+      activeSpecCount: 0,
+      activeTaskCount: 0
+    };
+  }
+
+  const entries = await fileSystem.readdir(specsRoot);
+  let activeSpecCount = 0;
+  let activeTaskCount = 0;
+
+  for (const entry of entries) {
+    const specRoot = path.join(specsRoot, entry);
+    try {
+      const stats = await fileSystem.stat(specRoot);
+      if (!stats.isDirectory()) {
+        continue;
+      }
+      const tasksPath = path.join(specRoot, 'tasks.md');
+      if (!await fileSystem.pathExists(tasksPath)) {
+        continue;
+      }
+      const tasks = await taskClaimer.parseTasks(tasksPath, { preferStatusMarkers: true });
+      const counts = summarizeTaskCounts(tasks);
+      if (counts.active > 0) {
+        activeSpecCount += 1;
+        activeTaskCount += counts.active;
+      }
+    } catch (_error) {
+      // Keep the projection resilient and skip unreadable spec entries.
+    }
+  }
+
+  return {
+    activeSpecCount,
+    activeTaskCount
+  };
+}
+
+async function buildActiveItems(projectRoot, sceneRecords = []) {
+  const items = [];
+  for (const record of sceneRecords) {
+    const sceneId = normalizeString(record && record.scene_id);
+    const sessionId = normalizeString(record && record.active_session_id);
+    if (!sceneId || !sessionId) {
+      continue;
+    }
+    const cycles = Array.isArray(record && record.cycles) ? record.cycles : [];
+    const activeCycle = cycles.find((item) => normalizeString(item && item.session_id) === sessionId) || {};
+    const updatedAt = safeIsoAt(activeCycle.started_at) || safeIsoAt(record.updated_at) || new Date().toISOString();
+    items.push({
+      id: `active:${sceneId}:${sessionId}`,
+      kind: 'active',
+      state: 'active',
+      sceneId,
+      eventId: sessionId,
+      updatedAt,
+      summary: `Scene ${sceneId} has active session ${sessionId}.`
+    });
+  }
+  return items;
+}
+
+async function buildRiskItems(projectRoot, fileSystem = fs) {
+  const payload = await readJsonIfExists(path.join(projectRoot, SPEC_GOVERNANCE_SCENE_INDEX), fileSystem);
+  const items = [];
+  for (const record of listObjectValues(payload && payload.scenes)) {
+    const sceneId = normalizeString(record && record.scene_id);
+    const staleSpecs = Number(record && record.stale_specs || 0);
+    if (!sceneId || staleSpecs <= 0) {
+      continue;
+    }
+    items.push({
+      id: `risk:${sceneId}:stale-specs`,
+      kind: 'risk',
+      state: 'at-risk',
+      reasonCode: 'project.stale_specs_present',
+      sceneId,
+      updatedAt: safeIsoAt(record && record.updated_at) || safeIsoAt(payload && payload.updated_at),
+      summary: `Scene ${sceneId} has ${staleSpecs} stale spec(s).`
+    });
+  }
+  return items;
+}
+
+async function buildHandoffItems(projectRoot, fileSystem = fs) {
+  const files = await listJsonFiles(path.join(projectRoot, HANDOFF_REPORT_DIR), fileSystem);
+  const items = [];
+  for (const filePath of files) {
+    const report = await readJsonIfExists(filePath, fileSystem);
+    if (!report || typeof report !== 'object') {
+      continue;
+    }
+    const sceneId = resolveReportSceneId(report) || null;
+    const specId = resolveReportSpecId(report) || null;
+    const sessionId = normalizeString(report.session_id) || path.basename(filePath, '.json');
+    const updatedAt = safeIsoAt(report.generated_at || report.completed_at || report.updated_at) || new Date().toISOString();
+    items.push({
+      id: `handoff:${sessionId}:${specId || sceneId || 'project'}`,
+      kind: 'handoff',
+      state: normalizeString(report.status) || 'handoff',
+      ...(sceneId ? { sceneId } : {}),
+      ...(specId ? { specId } : {}),
+      requestId: sessionId,
+      updatedAt,
+      summary: `Handoff session ${sessionId} is recorded for ${specId || sceneId || 'project scope'}.`
+    });
+  }
+  return items;
+}
+
+async function buildBlockedItems(projectRoot, fileSystem = fs) {
+  const files = await listJsonFiles(path.join(projectRoot, STUDIO_REPORT_DIR), fileSystem);
+  const items = [];
+  for (const filePath of files) {
+    const report = await readJsonIfExists(filePath, fileSystem);
+    if (!report || typeof report !== 'object' || report.passed !== false) {
+      continue;
+    }
+    const sceneId = resolveReportSceneId(report) || null;
+    const specId = resolveReportSpecId(report) || null;
+    const reportId = path.basename(filePath, '.json');
+    const updatedAt = safeIsoAt(report.completed_at || report.updated_at || report.started_at) || new Date().toISOString();
+    items.push({
+      id: `blocked:${reportId}`,
+      kind: 'blocked',
+      state: normalizeString(report.mode) || 'blocked',
+      ...(sceneId ? { sceneId } : {}),
+      ...(specId ? { specId } : {}),
+      eventId: reportId,
+      updatedAt,
+      summary: `Studio report ${reportId} is blocked.`,
+      ...(Array.isArray(report.steps) && report.steps.length > 0
+        ? {
+            reasonCode: normalizeString(report.steps.find((step) => /fail|error|block/i.test(normalizeString(step && step.status)))?.id) || undefined
+          }
+        : {})
+    });
+  }
+  return items;
+}
+
+async function resolveVisibleProject(projectId, dependencies = {}) {
+  const portfolio = await buildProjectPortfolioProjection({}, dependencies);
+  const record = (portfolio.projects || []).find((item) => item.projectId === projectId) || null;
+  return {
+    portfolio,
+    record
+  };
+}
+
+async function buildProjectSupervisionProjection(options = {}, dependencies = {}) {
+  const projectId = normalizeString(options.project);
+  if (!projectId) {
+    throw new Error('--project is required');
+  }
+
+  const fileSystem = dependencies.fileSystem || fs;
+  const taskClaimer = dependencies.taskClaimer || new TaskClaimer();
+  const { record } = await resolveVisibleProject(projectId, dependencies);
+  if (!record) {
+    throw new Error(`project not visible: ${projectId}`);
+  }
+
+  if (record.availability === 'inaccessible') {
+    const generatedAt = new Date().toISOString();
+    return {
+      generatedAt,
+      projectId,
+      cursor: createCursor(projectId, generatedAt, 0),
+      summary: {
+        blockedCount: 0,
+        handoffCount: 0,
+        riskCount: 0
+      },
+      items: [],
+      partial: true,
+      partialReasons: ['project_inaccessible']
+    };
+  }
+
+  const projectRoot = record.projectRoot;
+  const sessionStore = new SessionStore(projectRoot, null, {
+    fileSystem,
+    env: dependencies.env || process.env,
+    sqliteModule: dependencies.sqliteModule
+  });
+  const sceneRecords = await sessionStore.listSceneRecords();
+  const activeItems = await buildActiveItems(projectRoot, sceneRecords);
+  const riskItems = await buildRiskItems(projectRoot, fileSystem);
+  const handoffItems = await buildHandoffItems(projectRoot, fileSystem);
+  const blockedItems = await buildBlockedItems(projectRoot, fileSystem);
+  const taskSummary = await collectSpecTaskSummary(projectRoot, fileSystem, taskClaimer);
+  const items = [
+    ...blockedItems,
+    ...handoffItems,
+    ...riskItems,
+    ...activeItems
+  ].sort((left, right) => `${right.updatedAt || ''}`.localeCompare(`${left.updatedAt || ''}`));
+  const latestEventAt = collectLatestTimestamp(items);
+  const generatedAt = new Date().toISOString();
+
+  return {
+    generatedAt,
+    projectId,
+    cursor: createCursor(projectId, latestEventAt || generatedAt, items.length),
+    summary: {
+      blockedCount: blockedItems.length,
+      handoffCount: handoffItems.length,
+      riskCount: riskItems.length,
+      activeSceneCount: activeItems.length,
+      activeSpecCount: taskSummary.activeSpecCount,
+      activeTaskCount: taskSummary.activeTaskCount,
+      ...(latestEventAt ? { latestEventAt } : {})
+    },
+    items,
+    partial: record.partial === true,
+    partialReasons: Array.isArray(record.partialReasons) ? record.partialReasons : []
+  };
+}
+
+module.exports = {
+  buildProjectSupervisionProjection
+};