scene-capability-engine 3.6.64 → 3.6.67

package/lib/project/supervision-action-model.js

@@ -0,0 +1,277 @@
+function normalizeString(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value.trim();
+}
+
+const SEVERITY_ORDER = {
+  none: 0,
+  low: 1,
+  medium: 2,
+  high: 3,
+  critical: 4
+};
+
+function quoteCliArg(value) {
+  const normalized = normalizeString(value);
+  if (!normalized) {
+    return '';
+  }
+  if (/^[A-Za-z0-9._:/=-]+$/.test(normalized)) {
+    return normalized;
+  }
+  return `"${normalized.replace(/(["\\$`])/g, '\\$1')}"`;
+}
+
+function appendCommandOption(parts, flag, value) {
+  const normalized = normalizeString(value);
+  if (!normalized) {
+    return;
+  }
+  parts.push(flag, quoteCliArg(normalized));
+}
+
+function joinCommand(parts) {
+  return parts.filter(Boolean).join(' ');
+}
+
+function buildProjectSupervisionCommand(projectId, channelId) {
+  const parts = ['sce', 'project', 'supervision', 'show'];
+  appendCommandOption(parts, '--project', projectId);
+  appendCommandOption(parts, '--channel', channelId);
+  parts.push('--json');
+  return joinCommand(parts);
+}
+
+function buildGovernanceReportCommand(projectId, item = {}) {
+  const parts = ['sce', 'semantic', 'governance-report'];
+  appendCommandOption(parts, '--project-id', projectId);
+  appendCommandOption(parts, '--channel-id', item.channelId);
+  appendCommandOption(parts, '--scene', item.sceneId);
+  appendCommandOption(parts, '--spec', item.specId);
+  parts.push('--json');
+  return joinCommand(parts);
+}
+
+function buildBackflowReportCommand(projectId, item = {}) {
+  const parts = ['sce', 'semantic', 'backflow-report'];
+  appendCommandOption(parts, '--project-id', projectId);
+  appendCommandOption(parts, '--spec', item.specId);
+  parts.push('--json');
+  return joinCommand(parts);
+}
+
+function buildArchiveReportCommand(projectId, item = {}) {
+  const parts = ['sce', 'semantic', 'archive-report'];
+  appendCommandOption(parts, '--project-id', projectId);
+  appendCommandOption(parts, '--spec', item.specId);
+  appendCommandOption(parts, '--session-id', item.sessionId);
+  parts.push('--json');
+  return joinCommand(parts);
+}
+
+function buildConnectSharedSourceCommand(item = {}) {
+  const suggested = normalizeString(item.suggestedConnectCommand);
+  if (suggested) {
+    return suggested;
+  }
+  const parts = ['sce', 'semantic', 'connect-shared-source'];
+  appendCommandOption(parts, '--input-file', item.descriptorFile);
+  parts.push('--json');
+  return joinCommand(parts);
+}
+
+function buildStudioResumeCommand(item = {}) {
+  const parts = ['sce', 'studio', 'resume'];
+  appendCommandOption(parts, '--job', item.eventId);
+  parts.push('--json');
+  return joinCommand(parts);
+}
+
+function buildHandoffEvidenceCommand(item = {}) {
+  const parts = ['sce', 'auto', 'handoff', 'evidence'];
+  appendCommandOption(parts, '--session-id', item.requestId);
+  parts.push('--json');
+  return joinCommand(parts);
+}
+
+function buildMergeSharedCommand(item = {}) {
+  const parts = ['sce', 'semantic', 'merge-shared'];
+  appendCommandOption(parts, '--spec', item.specId);
+  parts.push('--json');
+  return joinCommand(parts);
+}
+
+function buildPublishSharedRegistryCommand(item = {}) {
+  const parts = ['sce', 'semantic', 'publish-shared-registry'];
+  appendCommandOption(parts, '--spec', item.specId);
+  parts.push('--json');
+  return joinCommand(parts);
+}
+
+function resolveBlockingScope(item = {}) {
+  if (normalizeString(item.specId)) {
+    return 'spec';
+  }
+  if (normalizeString(item.sceneId)) {
+    return 'scene';
+  }
+  if (normalizeString(item.channelId)) {
+    return 'channel';
+  }
+  return 'project';
+}
+
+function annotateSupervisionItem(item = {}, context = {}) {
+  const projectId = normalizeString(context.projectId);
+  const state = normalizeString(item.state);
+  const kind = normalizeString(item.kind);
+  const blockingScope = resolveBlockingScope(item);
+  let severity = 'none';
+  let recommendedAction = null;
+  let recommendedCommand = null;
+
+  if (kind === 'blocked') {
+    severity = 'critical';
+    recommendedAction = 'resume_blocked_studio_job';
+    recommendedCommand = buildStudioResumeCommand(item);
+  } else if (kind === 'handoff') {
+    severity = 'low';
+    recommendedAction = 'review_handoff_readiness';
+    recommendedCommand = buildHandoffEvidenceCommand(item);
+  } else if (kind === 'risk') {
+    severity = 'medium';
+    recommendedAction = 'refresh_stale_spec_governance';
+    recommendedCommand = buildProjectSupervisionCommand(projectId, item.channelId);
+  } else if (kind === 'info' && state === 'pending-connect') {
+    severity = 'medium';
+    recommendedAction = 'connect_shared_source';
+    recommendedCommand = buildConnectSharedSourceCommand(item);
+  } else if (kind === 'governance') {
+    severity = state === 'refuse-hotspot' ? 'high' : 'medium';
+    recommendedAction = state === 'refuse-hotspot'
+      ? 'reduce_refuse_hotspot'
+      : 'reduce_rewrite_hotspot';
+    recommendedCommand = buildGovernanceReportCommand(projectId, item);
+  } else if (kind === 'backflow') {
+    if (state === 'central-release-blocked') {
+      severity = 'critical';
+      recommendedAction = 'unblock_central_release';
+      recommendedCommand = normalizeString(item.specId)
+        ? buildPublishSharedRegistryCommand(item)
+        : buildBackflowReportCommand(projectId, item);
+    } else if (state === 'central-merge-blocked') {
+      severity = 'high';
+      recommendedAction = 'unblock_central_merge';
+      recommendedCommand = normalizeString(item.specId)
+        ? buildMergeSharedCommand(item)
+        : buildBackflowReportCommand(projectId, item);
+    } else if (state === 'local-publish-blocked') {
+      severity = 'high';
+      recommendedAction = 'resolve_local_publish_blocker';
+      recommendedCommand = buildBackflowReportCommand(projectId, item);
+    }
+  } else if (kind === 'archive') {
+    if (state === 'archive-routing-missing') {
+      severity = 'critical';
+      recommendedAction = 'normalize_archive_routing';
+      recommendedCommand = buildArchiveReportCommand(projectId, item);
+    } else if (
+      Number(item.publishBlockedCount || 0) > 0
+      || Number(item.publishPendingCount || 0) > 0
+    ) {
+      severity = 'medium';
+      recommendedAction = 'clear_archive_publication_backlog';
+      recommendedCommand = buildArchiveReportCommand(projectId, item);
+    } else {
+      severity = 'low';
+      recommendedAction = 'review_archive_accumulation';
+      recommendedCommand = buildArchiveReportCommand(projectId, item);
+    }
+  }
+
+  return {
+    ...item,
+    severity,
+    blocking_scope: blockingScope,
+    recommended_action: recommendedAction,
+    recommended_command: recommendedCommand,
+    actionable: Boolean(recommendedAction && recommendedCommand)
+  };
+}
+
+function compareSupervisionItems(left = {}, right = {}) {
+  const severityDelta = (SEVERITY_ORDER[right.severity] || 0) - (SEVERITY_ORDER[left.severity] || 0);
+  if (severityDelta !== 0) {
+    return severityDelta;
+  }
+  const updatedAtDelta = `${right.updatedAt || ''}`.localeCompare(`${left.updatedAt || ''}`);
+  if (updatedAtDelta !== 0) {
+    return updatedAtDelta;
+  }
+  return `${left.id || ''}`.localeCompare(`${right.id || ''}`);
+}
+
+function summarizeActionQueue(actionQueue = []) {
+  const summary = {
+    highestSeverity: actionQueue[0] ? actionQueue[0].severity : 'none',
+    actionableCount: actionQueue.length,
+    criticalCount: 0,
+    highCount: 0,
+    mediumCount: 0,
+    lowCount: 0
+  };
+
+  for (const item of actionQueue) {
+    if (item.severity === 'critical') {
+      summary.criticalCount += 1;
+    } else if (item.severity === 'high') {
+      summary.highCount += 1;
+    } else if (item.severity === 'medium') {
+      summary.mediumCount += 1;
+    } else if (item.severity === 'low') {
+      summary.lowCount += 1;
+    }
+  }
+
+  if (actionQueue[0] && normalizeString(actionQueue[0].recommended_command)) {
+    summary.primaryRecommendedCommand = actionQueue[0].recommended_command;
+  }
+
+  return summary;
+}
+
+function buildSupervisionActionQueue(items = [], context = {}) {
+  const annotatedItems = items.map((item) => annotateSupervisionItem(item, context));
+  const actionQueue = annotatedItems
+    .filter((item) => item.actionable)
+    .sort(compareSupervisionItems)
+    .map((item, index) => ({
+      rank: index + 1,
+      id: item.id,
+      kind: item.kind,
+      state: item.state,
+      summary: item.summary,
+      updatedAt: item.updatedAt,
+      severity: item.severity,
+      blocking_scope: item.blocking_scope,
+      recommended_action: item.recommended_action,
+      recommended_command: item.recommended_command,
+      ...(normalizeString(item.channelId) ? { channelId: item.channelId } : {}),
+      ...(normalizeString(item.sceneId) ? { sceneId: item.sceneId } : {}),
+      ...(normalizeString(item.specId) ? { specId: item.specId } : {})
+    }));
+
+  return {
+    items: annotatedItems,
+    actionQueue,
+    summary: summarizeActionQueue(actionQueue)
+  };
+}
+
+module.exports = {
+  SEVERITY_ORDER,
+  annotateSupervisionItem,
+  buildSupervisionActionQueue
+};

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

@@ -4,6 +4,13 @@ const fs = require('fs-extra');
 const TaskClaimer = require('../task/task-claimer');
 const { SessionStore } = require('../runtime/session-store');
 const { buildProjectPortfolioProjection } = require('./portfolio-projection-service');
+const { buildProjectChannelProjection } = require('./project-channel-projection');
+const { buildProjectChannelOutputFromProjection } = require('./project-channel-output');
+const { buildSemanticSharedSourceProjection } = require('./semantic-shared-source-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 SPEC_GOVERNANCE_SCENE_INDEX = path.join('.sce', 'spec-governance', 'scene-index.json');
 const STUDIO_REPORT_DIR = path.join('.sce', 'reports', 'studio');
@@ -245,6 +252,159 @@ async function buildBlockedItems(projectRoot, fileSystem = fs) {
   return items;
 }
 
+async function buildSemanticSharedSourceInfoItems(projectRoot, fileSystem = fs) {
+  const projection = await buildSemanticSharedSourceProjection(projectRoot, {
+    fileSystem
+  });
+  const items = [];
+  for (const item of projection.items.filter((entry) => entry.approved && !entry.connected)) {
+    items.push({
+      id: `info:semantic-shared-source:${item.source_name}:${item.descriptor_file}`,
+      kind: 'info',
+      state: 'pending-connect',
+      reasonCode: 'project.semantic_shared_source_connect_recommended',
+      ...(normalizeString(item.spec_id) ? { specId: normalizeString(item.spec_id) } : {}),
+      descriptorFile: item.descriptor_file,
+      sourceName: item.source_name,
+      suggestedConnectCommand: item.suggested_connect_command,
+      ...(safeIsoAt(item.updated_at) ? { updatedAt: safeIsoAt(item.updated_at) } : {}),
+      summary: `Approved semantic shared source ${item.source_name} is available but not connected.`
+    });
+  }
+  return {
+    projection,
+    items
+  };
+}
+
+function buildSupremeIntentGovernanceItems(report = {}) {
+  const hotspots = Array.isArray(report.top_scope_hotspots) ? report.top_scope_hotspots : [];
+  return hotspots
+    .filter((item) => Number(item.governed_count || 0) > 0)
+    .slice(0, 3)
+    .map((item) => ({
+      id: `governance:${item.project_id || 'project'}:${item.channel_id || 'channel'}:${item.spec_id || 'spec'}`,
+      kind: 'governance',
+      state: item.refuse > 0 ? 'refuse-hotspot' : 'rewrite-hotspot',
+      reasonCode: 'project.supreme_intent_governance_hotspot',
+      ...(normalizeString(item.channel_id) ? { channelId: normalizeString(item.channel_id) } : {}),
+      ...(normalizeString(item.scene_id) ? { sceneId: normalizeString(item.scene_id) } : {}),
+      ...(normalizeString(item.spec_id) ? { specId: normalizeString(item.spec_id) } : {}),
+      governedCount: item.governed_count,
+      rewriteCount: Number(item.rewrite || 0),
+      refuseCount: Number(item.refuse || 0),
+      clarifyCount: Number(item.clarify || 0),
+      narrowCount: Number(item.narrow || 0),
+      updatedAt: safeIsoAt(item.latest_at) || new Date().toISOString(),
+      summary: `Governance hotspot on ${item.channel_id || 'project'} / ${item.spec_id || item.scene_id || 'unbound'} with ${item.governed_count} governed assessments.`
+    }));
+}
+
+function buildSemanticBackflowItems(report = {}) {
+  const items = [];
+  const localBlockedItems = Array.isArray(report?.local?.recent_blocked_items)
+    ? report.local.recent_blocked_items.slice(0, 3)
+    : [];
+  for (const item of localBlockedItems) {
+    items.push({
+      id: `backflow:local:${item.lesson_id || item.capability_id || item.spec_id || 'unknown'}`,
+      kind: 'backflow',
+      state: 'local-publish-blocked',
+      reasonCode: 'project.semantic_backflow_local_publish_blocked',
+      ...(normalizeString(item.channel_id) ? { channelId: normalizeString(item.channel_id) } : {}),
+      ...(normalizeString(item.scene_id) ? { sceneId: normalizeString(item.scene_id) } : {}),
+      ...(normalizeString(item.spec_id) ? { specId: normalizeString(item.spec_id) } : {}),
+      ...(normalizeString(item.lesson_id) ? { lessonId: normalizeString(item.lesson_id) } : {}),
+      ...(normalizeString(item.capability_id) ? { capabilityId: normalizeString(item.capability_id) } : {}),
+      blockedReason: normalizeString(item.blocked_reason) || 'unknown',
+      governancePenaltyScore: Number(item.governance_penalty_score || 0),
+      governanceRefuseCount: Number(item.governance_refuse_count || 0),
+      governanceExecutionBlockedCount: Number(item.governance_execution_blocked_count || 0),
+      updatedAt: safeIsoAt(item.blocked_at) || new Date().toISOString(),
+      summary: `Local semantic publication is blocked for ${item.spec_id || item.scene_id || 'project scope'} (${normalizeString(item.blocked_reason) || 'unknown'}).`
+    });
+  }
+
+  const mergeReceipts = Array.isArray(report?.central_merge?.receipts)
+    ? report.central_merge.receipts
+    : [];
+  for (const receipt of mergeReceipts.filter((entry) => Number(entry?.totals?.blocked || 0) > 0).slice(0, 3)) {
+    const blockedReasons = (Array.isArray(receipt.blocked) ? receipt.blocked : [])
+      .map((entry) => normalizeString(entry && entry.reason))
+      .filter(Boolean);
+    items.push({
+      id: `backflow:merge:${receipt.spec_id || 'unknown'}:${receipt.generated_at || 'latest'}`,
+      kind: 'backflow',
+      state: 'central-merge-blocked',
+      reasonCode: 'project.semantic_backflow_central_merge_blocked',
+      ...(normalizeString(receipt.spec_id) ? { specId: normalizeString(receipt.spec_id) } : {}),
+      blockedCount: Number(receipt?.totals?.blocked || 0),
+      blockedReasons,
+      updatedAt: safeIsoAt(receipt.generated_at) || new Date().toISOString(),
+      summary: `Central merge is blocked for ${receipt.spec_id || 'unknown spec'} with ${Number(receipt?.totals?.blocked || 0)} blocked entr${Number(receipt?.totals?.blocked || 0) === 1 ? 'y' : 'ies'}.`
+    });
+  }
+
+  const releaseReceipts = Array.isArray(report?.central_release?.receipts)
+    ? report.central_release.receipts
+    : [];
+  for (const receipt of releaseReceipts.filter((entry) => Number(entry?.totals?.blocked || 0) > 0).slice(0, 3)) {
+    const blockedReasons = (Array.isArray(receipt.blocked) ? receipt.blocked : [])
+      .map((entry) => normalizeString(entry && entry.reason))
+      .filter(Boolean);
+    items.push({
+      id: `backflow:release:${receipt.spec_id || 'unknown'}:${receipt.generated_at || 'latest'}`,
+      kind: 'backflow',
+      state: 'central-release-blocked',
+      reasonCode: 'project.semantic_backflow_central_release_blocked',
+      ...(normalizeString(receipt.spec_id) ? { specId: normalizeString(receipt.spec_id) } : {}),
+      blockedCount: Number(receipt?.totals?.blocked || 0),
+      blockedReasons,
+      updatedAt: safeIsoAt(receipt.generated_at) || new Date().toISOString(),
+      summary: `Approved-central release is blocked for ${receipt.spec_id || 'unknown spec'} with ${Number(receipt?.totals?.blocked || 0)} blocked entr${Number(receipt?.totals?.blocked || 0) === 1 ? 'y' : 'ies'}.`
+    });
+  }
+
+  return items;
+}
+
+function buildSemanticArchiveItems(report = {}) {
+  const items = [];
+  const libraries = Array.isArray(report.by_library) ? report.by_library : [];
+  for (const item of libraries.filter((entry) => (Number(entry.lesson_count || 0) + Number(entry.ledger_count || 0)) > 0).slice(0, 3)) {
+    items.push({
+      id: `archive:${item.target_library || 'unknown'}`,
+      kind: 'archive',
+      state: item.published_shared_count > 0 ? 'shared-accumulating' : 'local-accumulating',
+      reasonCode: 'project.semantic_archive_library_accumulating',
+      targetLibrary: normalizeString(item.target_library) || null,
+      archiveClass: normalizeString(item.archive_class) || null,
+      reuseScope: normalizeString(item.reuse_scope) || null,
+      lessonCount: Number(item.lesson_count || 0),
+      ledgerCount: Number(item.ledger_count || 0),
+      publishPendingCount: Number(item.publish_pending_count || 0),
+      publishedSharedCount: Number(item.published_shared_count || 0),
+      publishBlockedCount: Number(item.publish_blocked_count || 0),
+      updatedAt: safeIsoAt((report.recent_items || []).find((entry) => normalizeString(entry.target_library) === normalizeString(item.target_library))?.updated_at) || new Date().toISOString(),
+      summary: `${item.target_library || 'unknown'} is accumulating ${Number(item.lesson_count || 0)} lesson(s) and ${Number(item.ledger_count || 0)} ledger row(s).`
+    });
+  }
+
+  if (Number(report?.totals?.missing_archive_count || 0) > 0) {
+    items.push({
+      id: 'archive:missing-routing',
+      kind: 'archive',
+      state: 'archive-routing-missing',
+      reasonCode: 'project.semantic_archive_routing_missing',
+      missingArchiveCount: Number(report.totals.missing_archive_count || 0),
+      updatedAt: safeIsoAt(report.generated_at) || new Date().toISOString(),
+      summary: `${Number(report.totals.missing_archive_count || 0)} archive item(s) are missing normalized routing metadata.`
+    });
+  }
+
+  return items;
+}
+
 async function resolveVisibleProject(projectId, dependencies = {}) {
   const portfolio = await buildProjectPortfolioProjection({}, dependencies);
   const record = (portfolio.projects || []).find((item) => item.projectId === projectId) || null;
@@ -256,6 +416,7 @@ async function resolveVisibleProject(projectId, dependencies = {}) {
 
 async function buildProjectSupervisionProjection(options = {}, dependencies = {}) {
   const projectId = normalizeString(options.project);
+  const requestedChannelId = normalizeString(options.channel);
   if (!projectId) {
     throw new Error('--project is required');
   }
@@ -276,9 +437,16 @@ async function buildProjectSupervisionProjection(options = {}, dependencies = {}
       summary: {
         blockedCount: 0,
         handoffCount: 0,
-        riskCount: 0
+        riskCount: 0,
+        highestSeverity: 'none',
+        actionableCount: 0,
+        criticalCount: 0,
+        highCount: 0,
+        mediumCount: 0,
+        lowCount: 0
       },
       items: [],
+      actionQueue: [],
       partial: true,
       partialReasons: ['project_inaccessible']
     };
@@ -295,32 +463,164 @@ async function buildProjectSupervisionProjection(options = {}, dependencies = {}
   const riskItems = await buildRiskItems(projectRoot, fileSystem);
   const handoffItems = await buildHandoffItems(projectRoot, fileSystem);
   const blockedItems = await buildBlockedItems(projectRoot, fileSystem);
+  const semanticSharedSourceInfo = await buildSemanticSharedSourceInfoItems(projectRoot, fileSystem);
+  const semanticArchive = await buildSemanticArchiveReport({
+    project_id: projectId,
+    limit: 200,
+    recent_limit: 10
+  }, {
+    ...dependencies,
+    projectPath: projectRoot,
+    fileSystem
+  });
+  const semanticBackflow = await buildSemanticBackflowReport({
+    project_id: projectId,
+    limit: 200,
+    recent_limit: 10
+  }, {
+    ...dependencies,
+    projectPath: projectRoot,
+    fileSystem
+  });
+  const supremeIntentGovernance = await buildSupremeIntentGovernanceReport({
+    project_id: projectId,
+    ...(requestedChannelId ? { channel_id: requestedChannelId } : {}),
+    limit: 200,
+    hotspot_limit: 3,
+    recent_limit: 5
+  }, {
+    ...dependencies,
+    projectPath: projectRoot,
+    fileSystem
+  });
+  const projectChannelProjection = await buildProjectChannelProjection(projectRoot, {
+    preferredProjectIds: [record.projectChannelContext && record.projectChannelContext.contextProjectId, projectId, record.workspaceId],
+    channelId: requestedChannelId
+  }, {
+    fileSystem
+  });
+  const infoItems = semanticSharedSourceInfo.items;
+  const governanceItems = buildSupremeIntentGovernanceItems(supremeIntentGovernance);
+  const archiveItems = buildSemanticArchiveItems(semanticArchive);
+  const backflowItems = buildSemanticBackflowItems(semanticBackflow);
   const taskSummary = await collectSpecTaskSummary(projectRoot, fileSystem, taskClaimer);
-  const items = [
+  const rawItems = [
     ...blockedItems,
     ...handoffItems,
     ...riskItems,
-    ...activeItems
+    ...activeItems,
+    ...archiveItems,
+    ...backflowItems,
+    ...governanceItems,
+    ...infoItems
   ].sort((left, right) => `${right.updatedAt || ''}`.localeCompare(`${left.updatedAt || ''}`));
+  const actionProjection = buildSupervisionActionQueue(rawItems, { projectId });
+  const items = actionProjection.items;
   const latestEventAt = collectLatestTimestamp(items);
   const generatedAt = new Date().toISOString();
+  const summary = semanticSharedSourceInfo.projection.summary;
+  const partialReasons = Array.isArray(record.partialReasons) ? [...record.partialReasons] : [];
+  if (semanticSharedSourceInfo.projection.partial) {
+    partialReasons.push(...semanticSharedSourceInfo.projection.partialReasons);
+  }
+  if (projectChannelProjection.partial) {
+    partialReasons.push(...projectChannelProjection.partialReasons);
+  }
+  const resolvedChannel = projectChannelProjection.resolvedChannel;
 
   return {
     generatedAt,
     projectId,
+    ...(requestedChannelId ? { requestedChannelId } : {}),
     cursor: createCursor(projectId, latestEventAt || generatedAt, items.length),
     summary: {
       blockedCount: blockedItems.length,
       handoffCount: handoffItems.length,
       riskCount: riskItems.length,
+      infoCount: infoItems.length,
+      governanceHotspotCount: governanceItems.length,
+      archiveItemCount: archiveItems.length,
+      backflowItemCount: backflowItems.length,
       activeSceneCount: activeItems.length,
       activeSpecCount: taskSummary.activeSpecCount,
       activeTaskCount: taskSummary.activeTaskCount,
+      supremeIntentAssessmentCount: supremeIntentGovernance.totals.total,
+      supremeIntentGovernedCount: supremeIntentGovernance.totals.governed,
+      supremeIntentRewriteCount: supremeIntentGovernance.totals.rewrite,
+      supremeIntentRefuseCount: supremeIntentGovernance.totals.refuse,
+      supremeIntentGovernedRatePercent: supremeIntentGovernance.totals.governed_action_rate_percent,
+      archiveLibraryCount: semanticArchive.totals.library_count,
+      archiveMissingCount: semanticArchive.totals.missing_archive_count,
+      archiveExperienceLessonCount: Number(semanticArchive.by_library.find((item) => normalizeString(item.target_library) === 'experience-library')?.lesson_count || 0),
+      archiveOntologyCapabilityLessonCount: Number(semanticArchive.by_library.find((item) => normalizeString(item.target_library) === 'ontology-capability-library')?.lesson_count || 0),
+      archiveApplicationLessonCount: Number(semanticArchive.by_library.find((item) => normalizeString(item.target_library) === 'application-library')?.lesson_count || 0),
+      backflowLocalBlockedCount: semanticBackflow.totals.local_publish_blocked,
+      backflowCentralMergeBlockedCount: semanticBackflow.totals.central_merge_blocked,
+      backflowCentralReleaseBlockedCount: semanticBackflow.totals.central_release_blocked,
+      backflowBlockedSpecCount: semanticBackflow.totals.blocked_spec_count,
+      semanticSharedSourceApprovedCount: summary.approvedDescriptors,
+      semanticSharedSourceBlockedCount: summary.blockedDescriptors,
+      semanticSharedSourceConfiguredCount: summary.configuredSources,
+      semanticSharedSourceConnectedCount: summary.connectedApprovedDescriptors,
+      semanticSharedSourcePendingConnectCount: summary.pendingApprovedDescriptors,
+      projectChannelCount: projectChannelProjection.summary.channelCount,
+      highestSeverity: actionProjection.summary.highestSeverity,
+      actionableCount: actionProjection.summary.actionableCount,
+      criticalCount: actionProjection.summary.criticalCount,
+      highCount: actionProjection.summary.highCount,
+      mediumCount: actionProjection.summary.mediumCount,
+      lowCount: actionProjection.summary.lowCount,
+      ...(actionProjection.summary.primaryRecommendedCommand
+        ? { primaryRecommendedCommand: actionProjection.summary.primaryRecommendedCommand }
+        : {}),
+      ...(projectChannelProjection.summary.focusedChannelId
+        ? { focusedChannelId: projectChannelProjection.summary.focusedChannelId }
+        : {}),
       ...(latestEventAt ? { latestEventAt } : {})
     },
+    projectChannelContext: {
+      available: projectChannelProjection.summary.available,
+      contextProjectId: projectChannelProjection.summary.contextProjectId,
+      canonicalProjectIdMatched: projectChannelProjection.summary.canonicalProjectIdMatched,
+      focusedChannelId: projectChannelProjection.summary.focusedChannelId,
+      storageMode: projectChannelProjection.summary.storageMode,
+      channels: projectChannelProjection.channels
+    },
+    ...(resolvedChannel
+      ? {
+          projectChannel: buildProjectChannelOutputFromProjection(projectChannelProjection, {
+            canonicalProjectId: projectId,
+            requestedChannelId: requestedChannelId || null
+          })
+        }
+      : {}),
+    supremeIntent: {
+      totals: supremeIntentGovernance.totals,
+      topScopeHotspots: supremeIntentGovernance.top_scope_hotspots,
+      topMatchedRules: supremeIntentGovernance.top_matched_rules,
+      recentGovernedItems: supremeIntentGovernance.recent_governed_items
+    },
+    archive: {
+      totals: semanticArchive.totals,
+      byLibrary: semanticArchive.by_library,
+      byArchiveClass: semanticArchive.by_archive_class,
+      byReuseScope: semanticArchive.by_reuse_scope,
+      recentItems: semanticArchive.recent_items
+    },
+    backflow: {
+      totals: semanticBackflow.totals,
+      blockedSpecIds: semanticBackflow.blocked_spec_ids,
+      localBlockedByReason: semanticBackflow.local.blocked_by_reason,
+      recentLocalBlockedItems: semanticBackflow.local.recent_blocked_items,
+      centralMergeBlockedByReason: semanticBackflow.central_merge.blocked_by_reason,
+      recentCentralMergeReceipts: semanticBackflow.central_merge.receipts,
+      centralReleaseBlockedByReason: semanticBackflow.central_release.blocked_by_reason,
+      recentCentralReleaseReceipts: semanticBackflow.central_release.receipts
+    },
+    actionQueue: actionProjection.actionQueue,
     items,
-    partial: record.partial === true,
-    partialReasons: Array.isArray(record.partialReasons) ? record.partialReasons : []
+    partial: record.partial === true || semanticSharedSourceInfo.projection.partial || projectChannelProjection.partial,
+    partialReasons: Array.from(new Set(partialReasons))
   };
 }