scene-capability-engine 3.6.64 → 3.6.67

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

@@ -4,6 +4,22 @@ 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');
+const {
+  buildEmptySummary,
+  buildSemanticSharedSourceProjection
+} = require('./semantic-shared-source-projection');
+const {
+  buildEmptyProjectChannelProjection,
+  buildProjectChannelProjection
+} = require('./project-channel-projection');
+const { buildSupervisionActionQueue } = require('./supervision-action-model');
+const { buildSupremeIntentGovernanceReport } = require('../semantic/supreme-intent-report');
+const { buildSemanticBackflowReport } = require('../semantic/backflow-report');
+const { buildSemanticArchiveReport } = require('../semantic/archive-report');
+const {
+  classifyProjectVisibility,
+  isCallerVisibleProject
+} = require('./visibility-policy');
 
 function normalizeString(value) {
   if (typeof value !== 'string') {
@@ -130,6 +146,176 @@ function deriveStatus({ accessible, isCurrentProject, activeSessionCount }) {
   return 'idle';
 }
 
+function buildProjectSupervisionSignalCandidates(projectId, reports = {}) {
+  const archiveTotals = reports.archiveReport && reports.archiveReport.totals && typeof reports.archiveReport.totals === 'object'
+    ? reports.archiveReport.totals
+    : {};
+  const backflowTotals = reports.backflowReport && reports.backflowReport.totals && typeof reports.backflowReport.totals === 'object'
+    ? reports.backflowReport.totals
+    : {};
+  const governanceHotspots = Array.isArray(reports.governanceReport && reports.governanceReport.top_scope_hotspots)
+    ? reports.governanceReport.top_scope_hotspots
+    : [];
+  const libraryRecords = Array.isArray(reports.archiveReport && reports.archiveReport.by_library)
+    ? reports.archiveReport.by_library
+    : [];
+  const pendingConnectCount = Number(reports.semanticSharedSources && reports.semanticSharedSources.pendingApprovedDescriptors || 0);
+  const items = [];
+
+  if (Number(archiveTotals.missing_archive_count || 0) > 0) {
+    items.push({
+      id: `portfolio:archive-missing:${projectId}`,
+      kind: 'archive',
+      state: 'archive-routing-missing',
+      missingArchiveCount: Number(archiveTotals.missing_archive_count || 0),
+      updatedAt: reports.generatedAt
+    });
+  }
+
+  if (Number(backflowTotals.central_release_blocked || 0) > 0) {
+    items.push({
+      id: `portfolio:central-release:${projectId}`,
+      kind: 'backflow',
+      state: 'central-release-blocked',
+      specId: Array.isArray(reports.backflowReport && reports.backflowReport.blocked_spec_ids)
+        ? normalizeString(reports.backflowReport.blocked_spec_ids[0])
+        : '',
+      blockedCount: Number(backflowTotals.central_release_blocked || 0),
+      updatedAt: reports.generatedAt
+    });
+  }
+
+  if (Number(backflowTotals.central_merge_blocked || 0) > 0) {
+    items.push({
+      id: `portfolio:central-merge:${projectId}`,
+      kind: 'backflow',
+      state: 'central-merge-blocked',
+      specId: Array.isArray(reports.backflowReport && reports.backflowReport.blocked_spec_ids)
+        ? normalizeString(reports.backflowReport.blocked_spec_ids[0])
+        : '',
+      blockedCount: Number(backflowTotals.central_merge_blocked || 0),
+      updatedAt: reports.generatedAt
+    });
+  }
+
+  if (Number(backflowTotals.local_publish_blocked || 0) > 0) {
+    items.push({
+      id: `portfolio:local-backflow:${projectId}`,
+      kind: 'backflow',
+      state: 'local-publish-blocked',
+      specId: Array.isArray(reports.backflowReport && reports.backflowReport.blocked_spec_ids)
+        ? normalizeString(reports.backflowReport.blocked_spec_ids[0])
+        : '',
+      blockedCount: Number(backflowTotals.local_publish_blocked || 0),
+      updatedAt: reports.generatedAt
+    });
+  }
+
+  const topGovernanceHotspot = governanceHotspots.find((item) => Number(item && item.governed_count || 0) > 0);
+  if (topGovernanceHotspot) {
+    items.push({
+      id: `portfolio:governance:${projectId}:${normalizeString(topGovernanceHotspot.channel_id) || 'channel'}`,
+      kind: 'governance',
+      state: Number(topGovernanceHotspot.refuse || 0) > 0 ? 'refuse-hotspot' : 'rewrite-hotspot',
+      channelId: normalizeString(topGovernanceHotspot.channel_id),
+      sceneId: normalizeString(topGovernanceHotspot.scene_id),
+      specId: normalizeString(topGovernanceHotspot.spec_id),
+      governedCount: Number(topGovernanceHotspot.governed_count || 0),
+      updatedAt: safeIsoAt(topGovernanceHotspot.latest_at) || reports.generatedAt
+    });
+  }
+
+  if (pendingConnectCount > 0) {
+    items.push({
+      id: `portfolio:shared-source:${projectId}`,
+      kind: 'info',
+      state: 'pending-connect',
+      descriptorFile: '.sce/specs/<spec>/registry/semantic-shared/published/source-descriptor.json',
+      updatedAt: reports.generatedAt
+    });
+  }
+
+  const archivePressure = libraryRecords.find((item) => (
+    Number(item && item.publish_blocked_count || 0) > 0
+    || Number(item && item.publish_pending_count || 0) > 0
+    || Number(item && item.lesson_count || 0) > 0
+    || Number(item && item.ledger_count || 0) > 0
+  ));
+  if (archivePressure) {
+    items.push({
+      id: `portfolio:archive:${projectId}:${normalizeString(archivePressure.target_library) || 'library'}`,
+      kind: 'archive',
+      state: Number(archivePressure.published_shared_count || 0) > 0 ? 'shared-accumulating' : 'local-accumulating',
+      targetLibrary: normalizeString(archivePressure.target_library),
+      publishPendingCount: Number(archivePressure.publish_pending_count || 0),
+      publishBlockedCount: Number(archivePressure.publish_blocked_count || 0),
+      updatedAt: reports.generatedAt
+    });
+  }
+
+  return items;
+}
+
+async function buildProjectSupervisionSignals(projectId, projectRoot, semanticSharedSources, dependencies = {}) {
+  const fileSystem = dependencies.fileSystem || fs;
+  const archiveReport = await buildSemanticArchiveReport({
+    project_id: projectId,
+    limit: 50,
+    recent_limit: 5
+  }, {
+    ...dependencies,
+    projectPath: projectRoot,
+    fileSystem
+  });
+  const backflowReport = await buildSemanticBackflowReport({
+    project_id: projectId,
+    limit: 50,
+    recent_limit: 5
+  }, {
+    ...dependencies,
+    projectPath: projectRoot,
+    fileSystem
+  });
+  const governanceReport = await buildSupremeIntentGovernanceReport({
+    project_id: projectId,
+    limit: 50,
+    hotspot_limit: 3,
+    recent_limit: 3
+  }, {
+    ...dependencies,
+    projectPath: projectRoot,
+    fileSystem
+  });
+  const generatedAt = new Date().toISOString();
+  const candidates = buildProjectSupervisionSignalCandidates(projectId, {
+    generatedAt,
+    archiveReport,
+    backflowReport,
+    governanceReport,
+    semanticSharedSources
+  });
+  const actionProjection = buildSupervisionActionQueue(candidates, { projectId });
+
+  return {
+    highestSeverity: actionProjection.summary.highestSeverity,
+    actionableCount: actionProjection.summary.actionableCount,
+    archiveMissingCount: Number(archiveReport.totals.missing_archive_count || 0),
+    backflowBlockedCount: Number(backflowReport.totals.local_publish_blocked || 0)
+      + Number(backflowReport.totals.central_merge_blocked || 0)
+      + Number(backflowReport.totals.central_release_blocked || 0),
+    governanceHotspotCount: governanceHotspotsCount(governanceReport),
+    pendingConnectCount: Number(semanticSharedSources.pendingApprovedDescriptors || 0),
+    ...(actionProjection.summary.actionableCount > 0
+      ? { primaryRecommendedCommand: `sce project supervision show --project ${projectId} --json` }
+      : {})
+  };
+}
+
+function governanceHotspotsCount(report = {}) {
+  const hotspots = Array.isArray(report.top_scope_hotspots) ? report.top_scope_hotspots : [];
+  return hotspots.filter((item) => Number(item && item.governed_count || 0) > 0).length;
+}
+
 async function readSceneRecords(projectRoot, dependencies = {}) {
   const fileSystem = dependencies.fileSystem || fs;
   const env = dependencies.env || process.env;
@@ -152,6 +338,16 @@ async function buildRegisteredWorkspaceRecord(workspace, context = {}, dependenc
   let partial = false;
   let sceneRecords = [];
   let specCount = 0;
+  let semanticSharedSources = buildEmptySummary();
+  let projectChannelContext = buildEmptyProjectChannelProjection().summary;
+  let supervisionSignals = {
+    highestSeverity: 'none',
+    actionableCount: 0,
+    archiveMissingCount: 0,
+    backflowBlockedCount: 0,
+    governanceHotspotCount: 0,
+    pendingConnectCount: 0
+  };
 
   const sceProject = await isValidSceProjectRoot(projectRoot, fileSystem);
   if (!sceProject) {
@@ -171,6 +367,35 @@ async function buildRegisteredWorkspaceRecord(workspace, context = {}, dependenc
       partial = true;
       partialReasons.push('spec_inventory_unavailable');
     }
+    const semanticSharedSourceProjection = await buildSemanticSharedSourceProjection(projectRoot, {
+      fileSystem
+    });
+    semanticSharedSources = semanticSharedSourceProjection.summary;
+    if (semanticSharedSourceProjection.partial) {
+      partial = true;
+      partialReasons.push(...semanticSharedSourceProjection.partialReasons);
+    }
+    const projectChannelProjection = await buildProjectChannelProjection(projectRoot, {
+      preferredProjectIds: [projectId, workspaceId]
+    }, {
+      fileSystem
+    });
+    projectChannelContext = projectChannelProjection.summary;
+    if (projectChannelProjection.partial) {
+      partial = true;
+      partialReasons.push(...projectChannelProjection.partialReasons);
+    }
+    try {
+      supervisionSignals = await buildProjectSupervisionSignals(
+        projectId,
+        projectRoot,
+        semanticSharedSources,
+        dependencies
+      );
+    } catch (_error) {
+      partial = true;
+      partialReasons.push('supervision_signals_unavailable');
+    }
   }
 
   const sceneCount = Array.isArray(sceneRecords) ? sceneRecords.length : 0;
@@ -180,12 +405,19 @@ async function buildRegisteredWorkspaceRecord(workspace, context = {}, dependenc
   const lastActivityAt = collectRecordActivityTimestamps(sceneRecords);
   const uniquePartialReasons = Array.from(new Set(partialReasons));
   const isCurrentProject = context.projectId === projectId;
+  const visibilityInfo = classifyProjectVisibility({
+    workspaceId,
+    projectRoot,
+    projectName: path.basename(projectRoot) || workspaceId
+  });
 
   return {
     projectId,
     workspaceId,
     projectRoot,
     projectName: path.basename(projectRoot) || workspaceId,
+    visibility: visibilityInfo.visibility,
+    lifecycle: visibilityInfo.lifecycle,
     provenance: 'registered',
     readiness: deriveReadiness({
       accessible,
@@ -208,6 +440,9 @@ async function buildRegisteredWorkspaceRecord(workspace, context = {}, dependenc
       sceneCount,
       specCount
     },
+    semanticSharedSources,
+    supervisionSignals,
+    projectChannelContext,
     partial,
     partialReasons: uniquePartialReasons
   };
@@ -221,6 +456,16 @@ async function buildLocalProjectRecord(projectRoot, context = {}, dependencies =
   let specCount = 0;
   const partialReasons = ['unregistered_project'];
   let partial = true;
+  let semanticSharedSources = buildEmptySummary();
+  let projectChannelContext = buildEmptyProjectChannelProjection().summary;
+  let supervisionSignals = {
+    highestSeverity: 'none',
+    actionableCount: 0,
+    archiveMissingCount: 0,
+    backflowBlockedCount: 0,
+    governanceHotspotCount: 0,
+    pendingConnectCount: 0
+  };
 
   try {
     sceneRecords = await readSceneRecords(normalizedRoot, dependencies);
@@ -232,6 +477,32 @@ async function buildLocalProjectRecord(projectRoot, context = {}, dependencies =
   } catch (_error) {
     partialReasons.push('spec_inventory_unavailable');
   }
+  const semanticSharedSourceProjection = await buildSemanticSharedSourceProjection(normalizedRoot, {
+    fileSystem
+  });
+  semanticSharedSources = semanticSharedSourceProjection.summary;
+  if (semanticSharedSourceProjection.partial) {
+    partialReasons.push(...semanticSharedSourceProjection.partialReasons);
+  }
+  const projectChannelProjection = await buildProjectChannelProjection(normalizedRoot, {
+    preferredProjectIds: [projectId, path.basename(normalizedRoot)]
+  }, {
+    fileSystem
+  });
+  projectChannelContext = projectChannelProjection.summary;
+  if (projectChannelProjection.partial) {
+    partialReasons.push(...projectChannelProjection.partialReasons);
+  }
+  try {
+    supervisionSignals = await buildProjectSupervisionSignals(
+      projectId,
+      normalizedRoot,
+      semanticSharedSources,
+      dependencies
+    );
+  } catch (_error) {
+    partialReasons.push('supervision_signals_unavailable');
+  }
 
   const sceneCount = Array.isArray(sceneRecords) ? sceneRecords.length : 0;
   const activeSessionCount = Array.isArray(sceneRecords)
@@ -240,11 +511,17 @@ async function buildLocalProjectRecord(projectRoot, context = {}, dependencies =
   const lastActivityAt = collectRecordActivityTimestamps(sceneRecords);
   const uniquePartialReasons = Array.from(new Set(partialReasons));
   const isCurrentProject = context.projectId === projectId;
+  const visibilityInfo = classifyProjectVisibility({
+    projectRoot: normalizedRoot,
+    projectName: path.basename(normalizedRoot) || 'local-project'
+  });
 
   return {
     projectId,
     projectRoot: normalizedRoot,
     projectName: path.basename(normalizedRoot) || 'local-project',
+    visibility: visibilityInfo.visibility,
+    lifecycle: visibilityInfo.lifecycle,
     provenance: 'discovered',
     readiness: deriveReadiness({
       accessible: true,
@@ -267,6 +544,9 @@ async function buildLocalProjectRecord(projectRoot, context = {}, dependencies =
       sceneCount,
       specCount
     },
+    semanticSharedSources,
+    supervisionSignals,
+    projectChannelContext,
     partial,
     partialReasons: uniquePartialReasons
   };
@@ -282,6 +562,12 @@ async function resolveCurrentProjectContext(options = {}, dependencies = {}) {
     if (!workspace) {
       throw new Error(`workspace not found: ${explicitWorkspace}`);
     }
+    if (!isCallerVisibleProject({
+      workspaceId: workspace.name,
+      projectRoot: normalizePath(workspace.path)
+    })) {
+      throw new Error(`workspace not visible: ${explicitWorkspace}`);
+    }
     return {
       workspaceId: workspace.name,
       projectId: buildWorkspaceProjectId(workspace.name),
@@ -291,7 +577,10 @@ async function resolveCurrentProjectContext(options = {}, dependencies = {}) {
   }
 
   const matchedWorkspace = await stateManager.findWorkspaceByPath(currentDir);
-  if (matchedWorkspace) {
+  if (matchedWorkspace && isCallerVisibleProject({
+    workspaceId: matchedWorkspace.name,
+    projectRoot: normalizePath(matchedWorkspace.path)
+  })) {
     return {
       workspaceId: matchedWorkspace.name,
       projectId: buildWorkspaceProjectId(matchedWorkspace.name),
@@ -301,7 +590,10 @@ async function resolveCurrentProjectContext(options = {}, dependencies = {}) {
   }
 
   const activeWorkspace = await stateManager.getActiveWorkspace();
-  if (activeWorkspace) {
+  if (activeWorkspace && isCallerVisibleProject({
+    workspaceId: activeWorkspace.name,
+    projectRoot: normalizePath(activeWorkspace.path)
+  })) {
     return {
       workspaceId: activeWorkspace.name,
       projectId: buildWorkspaceProjectId(activeWorkspace.name),
@@ -310,7 +602,10 @@ async function resolveCurrentProjectContext(options = {}, dependencies = {}) {
     };
   }
 
-  if (await isValidSceProjectRoot(currentDir, dependencies.fileSystem || fs)) {
+  if (
+    await isValidSceProjectRoot(currentDir, dependencies.fileSystem || fs)
+    && isCallerVisibleProject({ projectRoot: currentDir })
+  ) {
     return {
       workspaceId: null,
       projectId: buildLocalProjectId(currentDir),
@@ -347,8 +642,20 @@ async function buildProjectPortfolioProjection(options = {}, dependencies = {})
 
   const workspaces = await stateManager.listWorkspaces();
   const records = [];
+  const hiddenWorkspaceIds = [];
   for (const workspace of workspaces) {
-    records.push(await buildRegisteredWorkspaceRecord(workspace, currentContext, dependencies));
+    const record = await buildRegisteredWorkspaceRecord(workspace, currentContext, dependencies);
+    if (record.visibility !== 'managed') {
+      if (record.lifecycle === 'ephemeral' && record.availability === 'inaccessible') {
+        hiddenWorkspaceIds.push(record.workspaceId);
+      }
+      continue;
+    }
+    records.push(record);
+  }
+
+  for (const workspaceId of hiddenWorkspaceIds) {
+    await stateManager.removeWorkspace(workspaceId);
   }
 
   const localRoot = normalizeString(currentContext.projectRoot);
@@ -357,7 +664,10 @@ async function buildProjectPortfolioProjection(options = {}, dependencies = {})
     && localRoot
     && !currentDirWorkspace;
   if (shouldAddLocalProject) {
-    records.push(await buildLocalProjectRecord(localRoot, currentContext, dependencies));
+    const localRecord = await buildLocalProjectRecord(localRoot, currentContext, dependencies);
+    if (localRecord.visibility === 'managed') {
+      records.push(localRecord);
+    }
   }
 
   records.sort((left, right) => {

package/lib/project/project-channel-output.js

@@ -0,0 +1,94 @@
+function normalizeString(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+function buildProjectChannelOutput(options = {}) {
+  const context = options.context && typeof options.context === 'object'
+    ? options.context
+    : null;
+  const channel = options.channel && typeof options.channel === 'object'
+    ? options.channel
+    : null;
+  const session = options.session && typeof options.session === 'object'
+    ? options.session
+    : null;
+  const fallback = options.fallback && typeof options.fallback === 'object'
+    ? options.fallback
+    : {};
+  const requestedChannelId = normalizeString(
+    options.requestedChannelId !== undefined
+      ? options.requestedChannelId
+      : fallback.requested_channel_id
+  ) || null;
+  const resolvedChannelId = normalizeString(
+    options.resolvedChannelId !== undefined
+      ? options.resolvedChannelId
+      : (channel && channel.channelId)
+  ) || null;
+  const focusedChannelId = normalizeString(
+    options.focusedChannelId !== undefined
+      ? options.focusedChannelId
+      : (context && context.focusedChannelId)
+  ) || normalizeString(fallback.focused_channel_id) || null;
+  const contextAvailable = options.contextAvailable !== undefined
+    ? options.contextAvailable === true
+    : context !== null;
+  const storageMode = normalizeString(
+    options.storageMode !== undefined
+      ? options.storageMode
+      : fallback.storage_mode
+  ) || (contextAvailable ? 'unknown' : 'none');
+
+  return {
+    project_id: normalizeString(
+      options.projectId !== undefined
+        ? options.projectId
+        : fallback.project_id
+    ) || null,
+    canonical_project_id: normalizeString(
+      options.canonicalProjectId !== undefined
+        ? options.canonicalProjectId
+        : fallback.canonical_project_id
+    ) || null,
+    context_available: contextAvailable,
+    storage_mode: storageMode,
+    requested_channel_id: requestedChannelId,
+    focused_channel_id: focusedChannelId,
+    channel_id: resolvedChannelId || normalizeString(fallback.channel_id) || null,
+    active_scene: normalizeString(channel ? channel.activeScene : fallback.active_scene) || null,
+    active_spec_id: normalizeString(channel ? channel.activeSpecId : fallback.active_spec_id) || null,
+    active_doc: normalizeString(channel ? channel.activeDoc : fallback.active_doc) || null,
+    active_session_path: normalizeString(channel ? channel.activeSessionPath : fallback.active_session_path) || null,
+    run_state: normalizeString(channel ? channel.runState : fallback.run_state) || null,
+    updated_at: normalizeString(channel ? channel.updatedAt : fallback.updated_at) || null,
+    resolved_session_id: normalizeString(
+      options.resolvedSessionId !== undefined
+        ? options.resolvedSessionId
+        : (session && session.session_id)
+    ) || normalizeString(fallback.resolved_session_id) || null
+  };
+}
+
+function buildProjectChannelOutputFromProjection(projection = {}, options = {}) {
+  const summary = projection && projection.summary && typeof projection.summary === 'object'
+    ? projection.summary
+    : {};
+  return buildProjectChannelOutput({
+    projectId: options.projectId !== undefined ? options.projectId : summary.contextProjectId,
+    canonicalProjectId: options.canonicalProjectId,
+    requestedChannelId: options.requestedChannelId,
+    focusedChannelId: summary.focusedChannelId,
+    contextAvailable: summary.available === true,
+    storageMode: summary.storageMode,
+    channel: projection && projection.resolvedChannel ? projection.resolvedChannel : null,
+    resolvedSessionId: options.resolvedSessionId
+  });
+}
+
+module.exports = {
+  buildProjectChannelOutput,
+  buildProjectChannelOutputFromProjection
+};