@geraldmaron/construct 1.4.2 → 1.5.0

package/lib/status.mjs

@@ -26,6 +26,21 @@ import { resolveTraceBackend, telemetryProviderLabel } from './telemetry/client.
 import { doctorRoot } from './config/xdg.mjs';
 import { resolveUiColors } from './ui/theme.mjs';
 import { applyLinks, terminalLinksEnabled } from './ui/links.mjs';
+import { getModeCapabilityStatus, getUnsupportedCapabilities, getCapabilities, categorizeEnterpriseCapability } from './mode-capabilities.mjs';
+import { ProviderRegistry } from './embed/providers/registry.mjs';
+import { resolveProviders } from './providers/registry.mjs';
+import { getState as getBreakerState } from './providers/circuit-breaker.mjs';
+import { ConsumptionBudgetStore } from './policy/consumption-budget.mjs';
+import { loadGraph, nodesByType, nodeId } from './graph/store.mjs';
+import { validateGraph } from './graph/validate.mjs';
+import { computeLastExecutionByWorkflow } from './graph/runtime-evidence.mjs';
+import { summarizeTeamHealth } from './team/health.mjs';
+import { loadProjectConfig } from './config/project-config.mjs';
+import { projectKey } from './orchestration/store.mjs';
+import { resolveTraceStore } from './orchestration/trace-store.mjs';
+import { resolveSharedMemoryStore } from './storage/shared-memory.mjs';
+import { runtimeDir as orchestrationRuntimeDir } from './orchestration/run-store.mjs';
+import { resolveStateDir } from './state-root.mjs';
 const TOTAL_BYTES_WARNING_THRESHOLD = 750_000;
 
 function readJSON(path) {
@@ -190,6 +205,252 @@ export function readSessionUsage(homeDir) {
 }
 
 
+/**
+ * readDegradationRecords(cwd)
+ *
+ * Reads `.cx/degradation.jsonl` (written by `requireTeamCapabilityOrDegrade` in
+ * deployment-mode.mjs) and returns an array of structured degradation detail objects.
+ *
+ * Each record in the JSONL file has the shape written by deployment-mode.mjs:
+ *   { ts, mode, subsystem, degradedOk: true }
+ *
+ * Each record is surfaced as:
+ *   { subsystem, declared, actual, reason }
+ *
+ * `declared` and `actual` are inferred from the subsystem name when not
+ * explicitly present in the record (the deployment-mode writer does not yet emit
+ * them). `reason` reflects the CONSTRUCT_DEGRADED_OK value.
+ *
+ * Returns an empty array when the file is absent or unreadable.
+ */
+function readDegradationRecords(cwd) {
+  const filePath = join(cwd, '.cx', 'degradation.jsonl');
+  if (!existsSync(filePath)) return [];
+  let lines;
+  try {
+    lines = readFileSync(filePath, 'utf8').split('\n').filter(Boolean);
+  } catch {
+    return [];
+  }
+  const records = [];
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (!entry || typeof entry.subsystem !== 'string') continue;
+      // Infer declared/actual from the subsystem id when not explicit.
+      // Convention: subsystem ids use the format "<declared>-queue", "<declared>-memory", etc.
+      const declared = entry.declared ?? entry.subsystem;
+      const actual = entry.actual ?? 'fallback';
+      const reason = entry.reason
+        ?? (entry.degradedOk ? `CONSTRUCT_DEGRADED_OK=${entry.subsystem} set` : 'degraded');
+      records.push({
+        subsystem: entry.subsystem,
+        declared,
+        actual,
+        reason,
+        ts: entry.ts ?? null,
+        mode: entry.mode ?? null,
+      });
+    } catch {
+      // malformed line — skip
+    }
+  }
+  return records;
+}
+
+/**
+ * countPersonaDegradedRuns(cwd)
+ *
+ * Reads orchestration run records from the machine-scoped state root
+ * (`<stateRoot>/runtime/orchestration/runs/`, ADR-0066 — same directory
+ * lib/orchestration/run-store.mjs's runtimeDir() writes to) and counts runs
+ * carrying at least one task with `personaAvailable === false` (LMCP-E2:
+ * solo-mode persona fallback). Reads the filesystem store directly — the
+ * same best-effort, no-throw pattern as readDegradationRecords — since
+ * status is a read-only surface and must not fail when a run file is
+ * corrupt or the sqlite/postgres store is in use instead of the default.
+ *
+ * Returns { total, runs } where `runs` is the degraded run ids (capped at 20
+ * for the summary), and `total` counts every matching run.
+ */
+function countPersonaDegradedRuns(cwd) {
+  const dir = join(orchestrationRuntimeDir(cwd), 'runs');
+  if (!existsSync(dir)) return { total: 0, runs: [] };
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return { total: 0, runs: [] };
+  }
+  const runs = [];
+  for (const name of entries) {
+    if (!name.endsWith('.json')) continue;
+    try {
+      const run = JSON.parse(readFileSync(join(dir, name), 'utf8'));
+      const hasPersonaFallback = (run.tasks || []).some((t) => t.personaAvailable === false);
+      if (hasPersonaFallback) runs.push(run.runId || name.replace(/\.json$/, ''));
+    } catch {
+      // a corrupt run file is skipped, not fatal to the count
+    }
+  }
+  return { total: runs.length, runs: runs.slice(0, 20) };
+}
+
+/**
+ * summarizeRecentRunExecutionStates(cwd, opts)
+ *
+ * Reads orchestration run records from the machine-scoped state root (same
+ * `<stateRoot>/runtime/orchestration/runs/` directory as
+ * countPersonaDegradedRuns above, ADR-0066) and buckets the most recent runs
+ * by their LMCP-F4 run-level `executionState`
+ * (prepared|executed|degraded-executed|failed|unknown), so `construct status`
+ * can distinguish a run that only prepared specialist work from one that
+ * actually executed it — the honesty gap construct-1yhp.2 and incident
+ * run-02158a157d53 (construct-neq9.7) both trace back to.
+ *
+ * A run with no tasks (prompt-only/host-direct) or a pre-F4 legacy record
+ * carrying no `executionState` field is bucketed `unknown` rather than guessed
+ * into `prepared` or `executed`.
+ *
+ * Returns { total, byState: {prepared,executed,degraded-executed,failed,unknown},
+ * recent: [{runId, executionState, status, createdAt}] } ordered newest-first
+ * and capped at `limit` (default 10) for the `recent` list; `byState` counts
+ * every readable run regardless of the cap.
+ */
+function summarizeRecentRunExecutionStates(cwd, { limit = 10 } = {}) {
+  const dir = join(orchestrationRuntimeDir(cwd), 'runs');
+  const empty = { total: 0, byState: { prepared: 0, executed: 0, 'degraded-executed': 0, failed: 0, unknown: 0 }, recent: [] };
+  if (!existsSync(dir)) return empty;
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return empty;
+  }
+  const runs = [];
+  for (const name of entries) {
+    if (!name.endsWith('.json')) continue;
+    try {
+      const run = JSON.parse(readFileSync(join(dir, name), 'utf8'));
+      runs.push({
+        runId: run.runId || name.replace(/\.json$/, ''),
+        executionState: run.executionState ?? 'unknown',
+        status: run.status ?? 'unknown',
+        createdAt: run.createdAt ?? null,
+      });
+    } catch {
+      // a corrupt run file is skipped, not fatal to the summary
+    }
+  }
+  runs.sort((a, b) => String(b.createdAt || '').localeCompare(String(a.createdAt || '')));
+
+  const byState = { prepared: 0, executed: 0, 'degraded-executed': 0, failed: 0, unknown: 0 };
+  for (const r of runs) {
+    const key = Object.hasOwn(byState, r.executionState) ? r.executionState : 'unknown';
+    byState[key] += 1;
+  }
+
+  return { total: runs.length, byState, recent: runs.slice(0, limit) };
+}
+
+// LMCP-G10: cross-machine read side of team mode's trace/memory boundary.
+// lib/orchestration/runtime.mjs's persistTeamTrace writes every completed
+// run's lifecycle trace into the same postgres-backed trace store this reads
+// back from, keyed on the same projectKey(config, cwd) — a trace worker A's
+// machine wrote is the exact row machine B's `construct status` lists here.
+// Shared memory (lib/storage/shared-memory.mjs) is listed the same way; only
+// records that opted in with visibility 'shared-project' + provenance ever
+// appear. Solo mode (both stores resolve to kind:'none') reports
+// unavailable rather than fabricating an empty list as "no team activity".
+
+async function summarizeSharedState(cwd, env, config) {
+  const project = projectKey(config, cwd);
+  const traceStore = resolveTraceStore({ env, cwd, config });
+  const memoryStore = resolveSharedMemoryStore({ env, cwd, config });
+  if (traceStore.kind !== 'postgres' && memoryStore.kind !== 'postgres') {
+    return { status: 'unavailable', reason: 'no-team-store-configured', recentTraces: [], sharedMemory: [] };
+  }
+  const [recentTraces, sharedMemory] = await Promise.all([
+    traceStore.kind === 'postgres' ? traceStore.listTeamTraces({ project, limit: 5 }).catch(() => []) : Promise.resolve([]),
+    memoryStore.kind === 'postgres' ? memoryStore.listSharedMemory({ project, limit: 5 }).catch(() => []) : Promise.resolve([]),
+  ]);
+  return { status: 'healthy', project, recentTraces, sharedMemory };
+}
+
+/**
+ * summarizeGraphWorkflows(rootDir)
+ *
+ * Classifies every workflow node in the living graph (LMCP-C1/C2) as
+ * available / degraded / missing, sourced from the same validateGraph() the
+ * `graph validate` CLI and the doctor check (lib/doctor/graph-validate.mjs)
+ * both call — so status, doctor, and `construct graph validate` can never
+ * report three different truths about the same workflow.
+ *
+ * - missing: no `workflow:<id>` node exists in the graph (or the graph has
+ *   not been built yet).
+ * - degraded: the node exists but validateGraph raised an error or warning
+ *   that names this workflow, or the most recent runtime-evidence outcome
+ *   (LMCP-C9, runtime-evidence.mjs) for it is 'failed'.
+ * - available: the node exists and neither of the above applies.
+ *
+ * Read-only against .cx/graph (project-local) and the machine-scoped
+ * orchestration run store (ADR-0066) — this function never writes to the
+ * graph store or the runtime-evidence store.
+ */
+function summarizeGraphWorkflows(rootDir) {
+  const graph = loadGraph(rootDir);
+  if (!graph.exists) {
+    return { available: [], degraded: [], missing: [], graphBuilt: false, errors: [], warnings: [] };
+  }
+
+  const validation = validateGraph(rootDir);
+  const graphWorkflowIds = new Set(nodesByType(graph, 'workflow').map((n) => n.id));
+  const lastExecutionByWorkflow = computeLastExecutionByWorkflow(rootDir);
+
+  const findingsFor = (id, name) => {
+    const needles = [id, name].filter(Boolean);
+    const matches = (msg) => needles.some((needle) => msg.includes(`'${needle}'`));
+    return {
+      errors: validation.errors.filter(matches),
+      warnings: validation.warnings.filter(matches),
+    };
+  };
+
+  const available = [];
+  const degraded = [];
+  const missing = [];
+
+  for (const type of Object.keys(lastExecutionByWorkflow)) {
+    const id = nodeId('workflow', type);
+    const evidence = lastExecutionByWorkflow[type];
+    if (!graphWorkflowIds.has(id)) {
+      missing.push({ type, reason: 'no workflow node in living graph' });
+      continue;
+    }
+    const findings = findingsFor(id, type);
+    const evidenceFailed = evidence?.outcome === 'failed';
+    if (findings.errors.length > 0 || findings.warnings.length > 0 || evidenceFailed) {
+      degraded.push({
+        type,
+        errors: findings.errors,
+        warnings: findings.warnings,
+        lastExecution: evidence,
+      });
+    } else {
+      available.push({ type, lastExecution: evidence });
+    }
+  }
+
+  return {
+    available,
+    degraded,
+    missing,
+    graphBuilt: true,
+    errors: validation.errors,
+    warnings: validation.warnings,
+  };
+}
+
 function newestMtime(dir) {
   if (!existsSync(dir)) return null;
   let newest = 0;
@@ -438,6 +699,79 @@ function summarizeIntegrations(features) {
   return { counts, summary: summary || 'No integrations detected' };
 }
 
+// Embed daemon provider set is the unified extension registry (lib/extensions/*)
+// filtered by capability + credential presence (LMCP-B3) — this reads the same
+// ProviderRegistry.fromEnv() the daemon builds, so status can never drift from
+// what the daemon actually resolves.
+
+async function summarizeEmbedProviders(env) {
+  const registry = await ProviderRegistry.fromEnv(env);
+  const available = registry.names().filter((name, idx, all) => all.indexOf(name) === idx);
+  const unavailable = registry.unavailable();
+
+  const summary = [
+    available.length ? `${available.length} available` : null,
+    unavailable.length ? `${unavailable.length} unavailable` : null,
+  ].filter(Boolean).join(' · ') || 'no embed providers configured';
+
+  return {
+    summary,
+    available,
+    unavailable: unavailable.map((u) => ({ id: u.id, reason: u.reason })),
+  };
+}
+
+// Circuit-breaker state (lib/providers/circuit-breaker.mjs) is per resolved
+// data-source provider (lib/providers/registry.mjs wraps read/search/watch/
+// write/webhook with a breaker keyed 'provider:<id>', failureThreshold=5,
+// cooldownMs=30_000 — LMCP-B9). Reading it here through resolveProviders()
+// means status can never show a provider getBreaker never wrapped.
+
+async function summarizeProviderBreakers({ rootDir, env }) {
+  const { providers, errors } = await resolveProviders({ rootDir, env });
+  const entries = Object.keys(providers).sort().map((id) => {
+    const breaker = getBreakerState(`provider:${id}`);
+    const state = breaker ? breaker.state : 'CLOSED';
+    return {
+      id,
+      state,
+      failures: breaker ? breaker.failures : 0,
+      lastFailure: breaker?.lastFailure ? breaker.lastFailure.toISOString() : null,
+      open: state === 'OPEN',
+    };
+  });
+  const openCount = entries.filter((e) => e.open).length;
+  const summary = entries.length === 0
+    ? 'No providers configured'
+    : openCount > 0
+      ? `${openCount} of ${entries.length} provider circuit(s) OPEN`
+      : `${entries.length} provider(s), all circuits closed`;
+  return { entries, openCount, summary, loadErrors: errors };
+}
+
+// Per-actor/run durable consumption (lib/policy/consumption-budget.mjs,
+// LMCP-N5) — accrued by lib/mcp/broker.mjs's Broker.invoke whenever a caller
+// passes a runId. Rows only exist for runs that have actually consumed
+// something, so an empty list here means no run has recorded consumption
+// yet, not that budgets are unconfigured.
+
+function summarizeConsumptionBudgets({ rootDir, env }) {
+  const store = new ConsumptionBudgetStore({ rootDir, env });
+  const entries = store.allEntries().map((entry) => {
+    const overBudget = entry.budget
+      ? Object.entries(entry.budget).some(([kind, cap]) => Number.isFinite(cap) && entry.consumption[kind] > cap)
+      : false;
+    return { ...entry, overBudget };
+  });
+  const overCount = entries.filter((e) => e.overBudget).length;
+  const summary = entries.length === 0
+    ? 'No run consumption recorded yet'
+    : overCount > 0
+      ? `${overCount} of ${entries.length} run(s) over budget`
+      : `${entries.length} run(s) tracked, all within budget`;
+  return { entries, overCount, summary };
+}
+
 function summarizePlugins(pluginRegistry) {
   const plugins = pluginRegistry?.plugins ?? [];
   const external = plugins.filter((plugin) => !plugin.builtIn);
@@ -497,14 +831,14 @@ function traceBackendDefinition(env) {
     return {
       id: 'telemetry',
       name: 'Telemetry',
-      url: 'local://.cx/traces',
+      url: 'local://<state-root>/traces',
       runtime: 'local',
       note: backend === 'none' ? 'Remote disabled; local JSONL preserved' : 'Local JSONL traces',
       healthyMessage: 'Local trace capture enabled',
       impactsOverall: false,
       selfCheck: {
         status: backend === 'none' ? 'disabled' : 'healthy',
-        message: backend === 'none' ? 'Remote telemetry disabled' : 'Writing .cx/traces/*.jsonl',
+        message: backend === 'none' ? 'Remote telemetry disabled' : 'Writing <state-root>/traces/*.jsonl',
       },
     };
   }
@@ -572,6 +906,111 @@ function serviceDefinitions(env) {
   ];
 }
 
+// Storage health: real filesystem state plus a live LanceDB open probe (tableNames() call).
+// A corrupted or locked store reports unhealthy. A timeout (default 2000ms) prevents a
+// locked DB from stalling `construct status`. Results are cached with a short TTL.
+
+const STORAGE_PROBE_CACHE = new Map();
+const STORAGE_PROBE_CACHE_TTL_MS = 5000;
+
+// Exported for testing: allows callers to inject a custom lancedb opener and clock.
+export async function probeStorageHealth(
+  cwd,
+  {
+    env = process.env,
+    fsExistsSync = existsSync,
+    lancedbOpener = null,
+    probeTimeoutMs = 2000,
+    now = () => Date.now(),
+  } = {},
+) {
+  const cxExists = fsExistsSync(join(cwd, '.cx'));
+
+  // CONSTRUCT_LANCEDB_PATH wins when set (a managed install shares one
+  // machine-wide store); otherwise the index lives at the machine-scoped
+  // state root (ADR-0066), not a project-relative `.cx/lancedb` — mirrors
+  // lib/storage/vector-client.mjs's own resolution so status never reports a
+  // location the real store doesn't use.
+
+  const lancedbPath = env.CONSTRUCT_LANCEDB_PATH || resolveStateDir(cwd, 'lancedb', { ensureDir: false });
+  const lancedbExists = fsExistsSync(lancedbPath);
+
+  const sqlStore = { mode: 'lancedb', label: 'LanceDB + Git-Backed', dbUrl: null, vectorEnabled: true };
+
+  if (!cxExists) {
+    return {
+      sqlStore,
+      sqlHealth: { status: 'unavailable', message: 'Local store not initialized (.cx/ absent)' },
+      vectorStore: { enabled: false, backend: 'lancedb', label: 'Embedded LanceDB' },
+    };
+  }
+
+  if (!lancedbExists) {
+    return {
+      sqlStore,
+      sqlHealth: { status: 'degraded', message: 'Local embedded — no vector index yet (no lancedb store found)' },
+      vectorStore: { enabled: false, backend: 'lancedb', label: 'Embedded LanceDB' },
+    };
+  }
+
+  // Check cache before probing.
+  const cacheKey = lancedbPath;
+  const cached = STORAGE_PROBE_CACHE.get(cacheKey);
+  if (cached && now() - cached.at < STORAGE_PROBE_CACHE_TTL_MS) {
+    return cached.result;
+  }
+
+  // Probe the LanceDB store: open it and call tableNames() with a timeout.
+  let sqlHealth;
+  try {
+    const opener = lancedbOpener ?? (async (p) => {
+      const ldb = await import('@lancedb/lancedb');
+      return ldb.connect(p);
+    });
+
+    const probeResult = await Promise.race([
+      (async () => {
+        const db = await opener(lancedbPath);
+        await db.tableNames();
+        return { status: 'healthy', message: 'Local embedded' };
+      })(),
+      new Promise((resolve) =>
+        setTimeout(
+          () => resolve({ status: 'unhealthy', reason: 'LanceDB open timed out' }),
+          probeTimeoutMs,
+        ),
+      ),
+    ]);
+
+    if (probeResult.status === 'unhealthy') {
+      sqlHealth = { status: 'unhealthy', message: probeResult.reason };
+    } else {
+      sqlHealth = probeResult;
+    }
+  } catch (err) {
+    sqlHealth = { status: 'unhealthy', message: `LanceDB open failed: ${err?.message ?? String(err)}` };
+  }
+
+  const result = {
+    sqlStore,
+    sqlHealth,
+    vectorStore: {
+      enabled: sqlHealth.status === 'healthy',
+      backend: 'lancedb',
+      label: 'Embedded LanceDB',
+    },
+  };
+
+  STORAGE_PROBE_CACHE.set(cacheKey, { at: now(), result });
+  return result;
+}
+
+// categorizeEnterpriseCapability (ADR-0057's active/fail-closed/later/absent
+// partition) lives in mode-capabilities.mjs — the single authoritative registry
+// module — and is re-exported here so existing status.mjs consumers/tests don't
+// need a second import path.
+export { categorizeEnterpriseCapability } from './mode-capabilities.mjs';
+
 export async function buildStatus({
   rootDir,
   cwd = process.cwd(),
@@ -591,6 +1030,9 @@ export async function buildStatus({
     registry = { teams: {}, specialists: {}, contracts: {}, policies: {} };
   }
   const settings = readJSON(join(homeDir, '.claude', 'settings.json')) ?? {};
+  // MCP server definitions live in ~/.claude.json's top-level `mcpServers`, not
+  // settings.json (settings.json carries hooks/permissions only — construct-ranh).
+  const claudeUserConfig = readJSON(join(homeDir, '.claude.json')) ?? {};
   const features = await checkAllFeatures({ homeDir, cwd, env: mergedEnv });
   const pluginRegistry = loadPluginRegistry({ cwd, homeDir, rootDir, env: mergedEnv });
   const services = [];
@@ -622,6 +1064,9 @@ export async function buildStatus({
 
   const runtime = summarizeRuntime(services);
   const integrations = summarizeIntegrations(features);
+  const embedProviders = await summarizeEmbedProviders(mergedEnv);
+  const providerBreakers = await summarizeProviderBreakers({ rootDir: cwd, env: mergedEnv });
+  const consumptionBudgets = summarizeConsumptionBudgets({ rootDir: cwd, env: mergedEnv });
   const plugins = summarizePlugins(pluginRegistry);
   const contextInspection = inspectContextState(cwd);
   const sessionEfficiency = readSessionEfficiency(homeDir);
@@ -634,10 +1079,12 @@ export async function buildStatus({
   triggerAutoBackfillIfSparse(telemetryRichness, { ...mergedEnv });
   const efficiencyDigest = summarizeEfficiencyData(readEfficiencyLog(homeDir));
   const activeOverlays = getActiveOverlays(cwd);
-  const sqlStore = { mode: 'lancedb', label: 'LanceDB + Git-Backed', dbUrl: null, vectorEnabled: true };
-  const vectorStore = { enabled: true, backend: 'lancedb', label: 'Embedded LanceDB' };
-  const sqlHealth = { status: 'healthy', message: 'Local embedded' };
+  const { sqlStore, vectorStore, sqlHealth } = await probeStorageHealth(cwd, { env: mergedEnv });
   const promotionRequests = getPromotionRequests(cwd);
+  const degradationDetails = readDegradationRecords(cwd);
+  const personaDegradedRuns = countPersonaDegradedRuns(cwd);
+  const recentRunExecutionStates = summarizeRecentRunExecutionStates(cwd);
+  const workflows = summarizeGraphWorkflows(cwd);
   const executionContractModel = resolveExecutionContractModelMetadata({
     envValues: mergedEnv,
     registryModels: registry.models ?? {},
@@ -681,6 +1128,37 @@ export async function buildStatus({
 
   const deploymentMode = getDeploymentMode(mergedEnv);
   const resourceMode = resolveResourceMode(deploymentMode);
+  const capStatus = getModeCapabilityStatus(deploymentMode);
+  const unsupportedCaps = getUnsupportedCapabilities(deploymentMode);
+  const teamHealth = deploymentMode === 'team' || deploymentMode === 'enterprise'
+    ? await summarizeTeamHealth({ rootDir: cwd, env: mergedEnv })
+    : null;
+  const sharedState = deploymentMode === 'team' || deploymentMode === 'enterprise'
+    ? await summarizeSharedState(cwd, mergedEnv, loadProjectConfig(cwd, mergedEnv).config)
+    : null;
+
+  // Enterprise mode: build a per-capability truth table so status/doctor can show
+  // the real implementation state rather than a single aggregate label.
+  // The overall enterprise verdict is 'unsupported' until all three ADR-0057
+  // IMPLEMENT-NOW capabilities (tenant-isolation, rbac, mandatory-audit) are
+  // marked 'implemented' in mode-capabilities.mjs.
+  const ENTERPRISE_IMPLEMENT_NOW_IDS = new Set(['tenant-isolation', 'rbac', 'mandatory-audit']);
+  let enterpriseCapabilityTable = null;
+  let enterpriseVerdict = null;
+  if (deploymentMode === 'enterprise') {
+    const allCaps = getCapabilities('enterprise');
+    enterpriseCapabilityTable = allCaps.map((cap) => ({
+      id: cap.id,
+      label: cap.label,
+      status: cap.status,
+      category: categorizeEnterpriseCapability(cap),
+      implementNow: ENTERPRISE_IMPLEMENT_NOW_IDS.has(cap.id),
+    }));
+    const implementNowDone = allCaps
+      .filter((cap) => ENTERPRISE_IMPLEMENT_NOW_IDS.has(cap.id))
+      .every((cap) => cap.status === 'implemented');
+    enterpriseVerdict = implementNowDone ? 'supported' : 'unsupported';
+  }
 
   return {
     version: pkg.version ?? '1.0.0',
@@ -689,6 +1167,12 @@ export async function buildStatus({
       mode: deploymentMode,
       resourceMode,
       description: describeDeploymentMode(deploymentMode),
+      capabilityStatus: capStatus,
+      unsupportedCapabilities: capStatus !== 'fully-implemented' ? unsupportedCaps : [],
+      ...(deploymentMode === 'enterprise' && {
+        enterpriseCapabilityTable,
+        enterpriseVerdict,
+      }),
     },
     system: {
       overall: runtime,
@@ -697,6 +1181,9 @@ export async function buildStatus({
       plugins,
     },
     features,
+    embedProviders,
+    providerBreakers,
+    consumptionBudgets,
     plugins: {
       status: plugins.status,
       summary: plugins.summary,
@@ -724,7 +1211,7 @@ export async function buildStatus({
     skills: listSkills(rootDir),
     commands: listCommands(rootDir),
     cliCommands: CLI_COMMANDS,
-    mcpServers: Object.keys(settings.mcpServers ?? {}),
+    mcpServers: Object.keys(claudeUserConfig.mcpServers ?? settings.mcpServers ?? {}),
     publicHealth,
     storage: {
       sql: sqlStore,
@@ -736,6 +1223,8 @@ export async function buildStatus({
           : { status: 'unavailable', message: 'No vector index configured; using file-state only' },
       },
     },
+    teamHealth,
+    sharedState,
     executionContractModel,
     sessionEfficiency,
     efficiencyDigest,
@@ -743,6 +1232,10 @@ export async function buildStatus({
     telemetryRichness,
     overlays: activeOverlays,
     promotionRequests,
+    degradationDetails,
+    personaDegradedRuns,
+    recentRunExecutionStates,
+    workflows,
   };
 }
 
@@ -776,6 +1269,27 @@ export function formatStatusReport(status) {
   if (status.deployment?.mode) {
     const r = status.deployment.resourceMode || {};
     lines.push(`Deployment: ${status.deployment.mode} · queue:${r.queue} · workers:${r.workers} · telemetry:${r.telemetry}`);
+    if (status.deployment.capabilityStatus && status.deployment.capabilityStatus !== 'fully-implemented') {
+      const caps = status.deployment.unsupportedCapabilities ?? [];
+      lines.push(`Mode capabilities: ${status.deployment.capabilityStatus} · ${caps.length} not fully implemented: ${caps.map(c => c.label).join(', ')}`);
+    }
+    if (status.deployment.mode === 'enterprise') {
+      lines.push(`Enterprise verdict: ${status.deployment.enterpriseVerdict ?? 'unsupported'}`);
+      lines.push('WARNING: Enterprise mode: most capabilities not yet implemented. See construct status for details.');
+      // ADR-0057 status contract: render only active/fail-closed/later — never a
+      // bare 'not-implemented' that could read as active, and never collapse
+      // fail-closed (hard-errors at runtime) into later (no runtime effect) or
+      // vice versa. A capability categorized 'absent' is not advertised at all.
+      const table = (status.deployment.enterpriseCapabilityTable ?? []).filter((cap) => cap.category !== 'absent');
+      if (table.length > 0) {
+        lines.push('Enterprise capability table:');
+        for (const cap of table) {
+          const icon = cap.category === 'active' ? '✓' : cap.category === 'fail-closed' ? '✗' : '·';
+          const tag = cap.implementNow ? ' [implement-now]' : '';
+          lines.push(`  ${icon} ${cap.label} (${cap.category})${tag}`);
+        }
+      }
+    }
   }
   lines.push('Coordination: external tracker + plan.md · single-writer per file · cass-memory for recall');
   if (status.executionContractModel?.selectedTier && status.executionContractModel?.selectedModel) {
@@ -785,6 +1299,16 @@ export function formatStatusReport(status) {
     lines.push(`Storage: ${status.storage.sql?.mode ?? 'unknown'} SQL · ${status.storage.vector?.mode ?? 'unknown'} vector`);
     lines.push(`Storage health: SQL ${status.storage.health?.sql?.status ?? 'unknown'} · vector ${status.storage.health?.vector?.status ?? 'unknown'}`);
   }
+  if (status.teamHealth) {
+    lines.push(`Team health: ${statusLabel(status.teamHealth.status)} · ${status.teamHealth.summary}`);
+  }
+  if (status.sharedState) {
+    if (status.sharedState.status === 'unavailable') {
+      lines.push('Shared state: unavailable · no team trace/memory store configured');
+    } else {
+      lines.push(`Shared state: ${status.sharedState.recentTraces.length} recent team trace(s) · ${status.sharedState.sharedMemory.length} shared memory record(s)`);
+    }
+  }
   if (status.sessionEfficiency) {
     lines.push(`Efficiency: ${statusLabel(status.sessionEfficiency.status)} · score ${status.sessionEfficiency.score.toFixed(2)} · ${status.sessionEfficiency.summary}`);
     for (const warning of status.sessionEfficiency.warnings ?? []) {
@@ -826,6 +1350,43 @@ export function formatStatusReport(status) {
       lines.push(`  - ${request.domain} · ${request.status}${challenge}`);
     }
   }
+  if ((status.degradationDetails ?? []).length > 0) {
+    lines.push('Degradation details:');
+    for (const d of status.degradationDetails) {
+      lines.push(`  ${d.subsystem}: declared=${d.declared} actual=${d.actual} (${d.reason})`);
+    }
+  }
+  if ((status.personaDegradedRuns?.total ?? 0) > 0) {
+    lines.push(`Persona-degraded runs: ${status.personaDegradedRuns.total} (solo-mode persona-fallback)`);
+  }
+  if ((status.recentRunExecutionStates?.total ?? 0) > 0) {
+    const b = status.recentRunExecutionStates.byState;
+    lines.push(
+      `Recent runs: ${status.recentRunExecutionStates.total} total`
+      + ` · prepared ${b.prepared}` + ` · executed ${b.executed}`
+      + ` · degraded-executed ${b['degraded-executed']}` + ` · failed ${b.failed}`
+      + (b.unknown ? ` · unknown ${b.unknown}` : ''),
+    );
+    for (const r of status.recentRunExecutionStates.recent.slice(0, 5)) {
+      lines.push(`  ${r.runId}: executionState=${r.executionState} (status=${r.status})`);
+    }
+  }
+  if (status.workflows) {
+    lines.push('');
+    if (!status.workflows.graphBuilt) {
+      lines.push('Workflows: living graph not built yet — run `construct graph build`');
+    } else {
+      const w = status.workflows;
+      lines.push(`Workflows: ${w.available.length} available · ${w.degraded.length} degraded · ${w.missing.length} missing (source: graph validate)`);
+      for (const entry of w.degraded) {
+        const reason = entry.errors[0] || entry.warnings[0] || (entry.lastExecution?.outcome === 'failed' ? 'last run failed' : 'degraded');
+        lines.push(`  ⚠ ${entry.type} — ${reason}`);
+      }
+      for (const entry of w.missing) {
+        lines.push(`  ✗ ${entry.type} — ${entry.reason}`);
+      }
+    }
+  }
   lines.push('');
   lines.push('Runtime');
   for (const service of status.system.services) {
@@ -838,6 +1399,36 @@ export function formatStatusReport(status) {
   for (const feature of status.features) {
     lines.push(`  ${serviceIcon(feature.status)} ${feature.name.padEnd(22)} ${statusLabel(feature.status)} — ${feature.message}`);
   }
+  if (status.embedProviders) {
+    lines.push('');
+    lines.push(`Embed providers: ${status.embedProviders.summary}`);
+    for (const name of status.embedProviders.available) {
+      lines.push(`  ${serviceIcon('healthy')} ${name.padEnd(22)} configured`);
+    }
+    for (const entry of status.embedProviders.unavailable) {
+      lines.push(`  ${serviceIcon('unavailable')} ${entry.id.padEnd(22)} configured but unavailable — ${entry.reason}`);
+    }
+  }
+  if (status.providerBreakers && status.providerBreakers.entries.length > 0) {
+    lines.push('');
+    lines.push(`Provider circuits: ${status.providerBreakers.summary}`);
+    for (const entry of status.providerBreakers.entries) {
+      const icon = entry.open ? serviceIcon('unavailable') : serviceIcon('healthy');
+      const detail = entry.open ? ` — OPEN since ${entry.lastFailure} (${entry.failures} failures)` : '';
+      lines.push(`  ${icon} ${entry.id.padEnd(22)} ${entry.state}${detail}`);
+    }
+  }
+  if (status.consumptionBudgets && status.consumptionBudgets.entries.length > 0) {
+    lines.push('');
+    lines.push(`Run consumption: ${status.consumptionBudgets.summary}`);
+    for (const entry of status.consumptionBudgets.entries) {
+      const icon = entry.overBudget ? serviceIcon('unavailable') : serviceIcon('healthy');
+      const budgetNote = entry.budget
+        ? `tokens ${entry.consumption.tokens}/${entry.budget.tokens} · toolCalls ${entry.consumption.toolCalls}/${entry.budget.toolCalls}`
+        : `tokens ${entry.consumption.tokens} · toolCalls ${entry.consumption.toolCalls} (unbounded)`;
+      lines.push(`  ${icon} ${entry.actor}/${entry.runId} — ${budgetNote}`);
+    }
+  }
   if (status.plugins) {
     lines.push('');
     lines.push(`Plugins: ${statusLabel(status.plugins.status)} · ${status.plugins.summary}`);