@geraldmaron/construct 1.0.0 → 1.0.2

package/lib/status.mjs

@@ -1,7 +1,9 @@
 /**
- * lib/status.mjs — <one-line purpose>
+ * lib/status.mjs — Project health summary for the Construct dashboard and CLI.
  *
- * <2–6 line summary: what it does, who calls it, key side effects.>
+ * Reads workflow state, plan.md, tracker config, and MCP surface to produce a
+ * structured health object. Called by `construct status`, the MCP status tool,
+ * and the session-start bootstrap to surface blocked tasks and open questions.
  */
 import { readFileSync, statSync, existsSync, readdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
@@ -9,17 +11,19 @@ import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 
 import { inspectContextState } from './context-state.mjs';
-import { inspectWorkflowHealth, loadWorkflow } from './workflow-state.mjs';
 import { CLI_COMMANDS } from './cli-commands.mjs';
 import { checkAllFeatures } from './features.mjs';
 import { loadConstructEnv } from './env-config.mjs';
+import { describeDeploymentMode, getDeploymentMode, resolveResourceMode } from './deployment-mode.mjs';
 import { getActiveOverlays, getPromotionRequests } from './headhunt.mjs';
 import { resolveExecutionContractModelMetadata, selectModelTierForWorkCategory } from './model-router.mjs';
+import { loadPluginRegistry } from './plugin-registry.mjs';
 import { readCostLog, summarizeCostData, normalizeCostEntry } from './cost.mjs';
 import { readEfficiencyLog, summarizeEfficiencyData } from './efficiency.mjs';
 import { describeSqlStore, sqlStoreHealth } from './storage/sql-store.mjs';
 import { describeVectorStore } from './storage/vector-store.mjs';
 import { describeSqlStoreHealth } from './storage/sql-store.mjs';
+import { triggerAutoBackfillIfSparse } from './telemetry/backfill.mjs';
 const TOTAL_BYTES_WARNING_THRESHOLD = 750_000;
 
 function readJSON(path) {
@@ -122,6 +126,12 @@ export function readSessionUsage(homeDir) {
       interactions: 0,
       inputTokens: 0,
       outputTokens: 0,
+      reasoningTokens: 0,
+      providerTotalTokens: 0,
+      billedTotalTokens: 0,
+      processedInputTokens: 0,
+      cacheReadInputTokens: 0,
+      cacheCreationInputTokens: 0,
       totalTokens: 0,
       totalCostUsd: 0,
       summary: 'No token usage recorded yet',
@@ -137,29 +147,40 @@ export function readSessionUsage(homeDir) {
     timestamp: lastEntry.ts || null,
     inputTokens: normalizedLast.inputTokens,
     outputTokens: normalizedLast.outputTokens,
+    reasoningTokens: normalizedLast.reasoningTokens,
     cacheReadInputTokens: normalizedLast.cacheReadInputTokens,
     cacheCreationInputTokens: normalizedLast.cacheCreationInputTokens,
     processedInputTokens: normalizedLast.processedInputTokens,
-    totalTokens: normalizedLast.totalTokens,
+    providerTotalTokens: normalizedLast.providerTotalTokens,
+    billedTotalTokens: normalizedLast.billedTotalTokens,
+    totalTokens: normalizedLast.providerTotalTokens,
     costUsd: normalizedLast.costUsd,
   };
 
   const data = summarizeCostData(entries);
 
+  const billed = data.billedTotalTokens || 0;
+  const cacheReadPct = billed > 0 ? ((data.cacheReadInputTokens / billed) * 100).toFixed(1) : '?';
+  const cacheWritePct = billed > 0 ? ((data.cacheCreationInputTokens / billed) * 100).toFixed(1) : '?';
+  const freshPct = billed > 0 ? ((((data.totalInputTokens || 0) + (data.totalOutputTokens || 0)) / billed) * 100).toFixed(1) : '?';
+
   return {
     status: 'available',
     interactions: data.interactions,
     inputTokens: data.totalInputTokens,
     outputTokens: data.totalOutputTokens,
+    reasoningTokens: data.totalReasoningTokens,
     cacheReadInputTokens: data.cacheReadInputTokens,
     cacheCreationInputTokens: data.cacheCreationInputTokens,
     processedInputTokens: data.processedInputTokens,
     cachedTokens: data.cachedTokens,
     cacheReadRate: data.cacheReadRate,
     cacheHitRate: data.cacheReadRate,
-    totalTokens: data.totalTokens,
+    providerTotalTokens: data.providerTotalTokens,
+    billedTotalTokens: billed,
+    totalTokens: data.providerTotalTokens,
     totalCostUsd: data.totalCostUsd,
-    summary: `${data.interactions} interaction${data.interactions === 1 ? '' : 's'} · ${data.totalTokens.toLocaleString()} tokens · $${data.totalCostUsd.toFixed(2)}`,
+    summary: `${data.interactions} interaction${data.interactions === 1 ? '' : 's'} · ${data.providerTotalTokens.toLocaleString()} provider · ${billed.toLocaleString()} billed (${cacheReadPct}% cache read · ${cacheWritePct}% cache write · ${freshPct}% fresh)`,
     lastInteraction,
     source: join(homeDir, '.cx', 'session-cost.jsonl'),
     lastUpdatedAt: lastInteraction.timestamp,
@@ -229,7 +250,12 @@ function parsePort(value, fallback) {
   return Number.isFinite(parsed) ? parsed : fallback;
 }
 
-async function probeHttp(url, { method = 'GET', headers, body, timeout = 2000 } = {}) {
+async function probeHttp(url, { method = 'GET', headers, body, timeout = 5000 } = {}) {
+  // 5s is generous on purpose. The dashboard runs many concurrent requests when
+  // a page first loads (status + insights + registry + auth + …), which can stall
+  // its own event loop just long enough that a 2s timeout fires on a healthy
+  // localhost service. Reachability is a yes/no signal — a hung remote dies
+  // visibly via ECONNREFUSED long before this, so the extra headroom is free.
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeout);
   try {
@@ -242,6 +268,24 @@ async function probeHttp(url, { method = 'GET', headers, body, timeout = 2000 }
   }
 }
 
+// Per-service probe-result cache so back-to-back /api/status calls (page reload,
+// React StrictMode double-mount, multiple components polling) don't pound the
+// same probe URLs. TTL is short so a true outage shows within a few seconds.
+const PROBE_CACHE = new Map();
+const PROBE_CACHE_TTL_MS = 3000;
+function probeCacheKey(service) {
+  return `${service.id || service.name}\0${service.method || 'GET'}\0${service.probeUrl || service.url}`;
+}
+function readProbeCache(service, now = Date.now()) {
+  const entry = PROBE_CACHE.get(probeCacheKey(service));
+  if (!entry) return null;
+  if (now - entry.at > PROBE_CACHE_TTL_MS) return null;
+  return entry.result;
+}
+function writeProbeCache(service, result, now = Date.now()) {
+  PROBE_CACHE.set(probeCacheKey(service), { at: now, result });
+}
+
 function normalizeProbeResult(result) {
   if (typeof result === 'string') {
     return { status: result };
@@ -250,28 +294,34 @@ function normalizeProbeResult(result) {
 }
 
 async function defaultProbeService(service) {
+  const cached = readProbeCache(service);
+  if (cached) return cached;
+
+  const headers = service.probeHeaders || (service.method === 'POST' ? { 'Content-Type': 'application/json' } : undefined);
   const result = service.method === 'POST'
-    ? await probeHttp(service.url, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: service.body,
-      })
-    : await probeHttp(service.url);
-
-  if (result.ok) return { status: 'healthy', message: service.healthyMessage ?? 'Reachable' };
-  if (result.statusCode) return { status: 'degraded', message: `HTTP ${result.statusCode}` };
-  if (result.error?.name === 'AbortError') return { status: 'unavailable', message: 'Timed out' };
-  if (result.error?.cause?.code === 'ECONNREFUSED' || result.error?.code === 'ECONNREFUSED') {
-    return { status: 'unavailable', message: 'Connection refused' };
+    ? await probeHttp(service.url, { method: 'POST', headers, body: service.body })
+    : await probeHttp(service.url, headers ? { headers } : undefined);
+
+  let outcome;
+  if (result.ok) outcome = { status: 'healthy', message: service.healthyMessage ?? 'Reachable' };
+  else if (result.statusCode) outcome = { status: 'degraded', message: `HTTP ${result.statusCode}` };
+  else if (result.error?.name === 'AbortError') outcome = { status: 'unavailable', message: 'Timed out' };
+  else if (result.error?.cause?.code === 'ECONNREFUSED' || result.error?.code === 'ECONNREFUSED') {
+    outcome = { status: 'unavailable', message: 'Connection refused' };
+  } else {
+    outcome = { status: 'unavailable', message: result.error?.message ?? 'Connection failed' };
   }
-  return { status: 'unavailable', message: result.error?.message ?? 'Connection failed' };
+
+  writeProbeCache(service, outcome);
+  return outcome;
 }
 
-async function fetchLangfuseTelemetryStatus(env, { timeout = 2500 } = {}) {
-  const baseUrl = (env.LANGFUSE_BASEURL ?? 'https://cloud.langfuse.com').replace(/\/$/, '');
-  const key = env.LANGFUSE_PUBLIC_KEY;
-  const secret = env.LANGFUSE_SECRET_KEY;
-  if (!key || !secret) return { status: 'unavailable', summary: 'Langfuse credentials not configured' };
+async function fetchTelemetryStatus(env, { timeout = 2500 } = {}) {
+  const baseUrl = (env.CONSTRUCT_TELEMETRY_URL ?? '').replace(/\/$/, '');
+  const key = env.CONSTRUCT_TELEMETRY_PUBLIC_KEY;
+  const secret = env.CONSTRUCT_TELEMETRY_SECRET_KEY;
+  if (!key || !secret) return { status: 'unavailable', summary: 'Telemetry credentials not configured' };
+  if (!baseUrl) return { status: 'unavailable', summary: 'CONSTRUCT_TELEMETRY_URL not set' };
   const headers = {
     Authorization: `Basic ${Buffer.from(`${key}:${secret}`).toString('base64')}`,
   };
@@ -279,7 +329,10 @@ async function fetchLangfuseTelemetryStatus(env, { timeout = 2500 } = {}) {
   const timer = setTimeout(() => controller.abort(), timeout);
   try {
     const res = await fetch(`${baseUrl}/api/public/traces?limit=25`, { headers, signal: controller.signal });
-    if (!res.ok) return { status: 'unavailable', summary: `Langfuse HTTP ${res.status}` };
+    if (res.status === 401 || res.status === 403) {
+      return { status: 'credentials-invalid', summary: `Telemetry credentials rejected (HTTP ${res.status}) — run: construct setup` };
+    }
+    if (!res.ok) return { status: 'degraded', summary: `Telemetry HTTP ${res.status}` };
     const json = await res.json().catch(() => ({}));
     const traces = Array.isArray(json.data) ? json.data : [];
     const counts = { rich: 0, partial: 0, sparse: 0 };
@@ -291,8 +344,6 @@ async function fetchLangfuseTelemetryStatus(env, { timeout = 2500 } = {}) {
       const metaKeys = trace?.metadata && typeof trace.metadata === 'object' ? Object.keys(trace.metadata).length : 0;
       const hasRichMetadata = metaKeys >= 5;
       const hasPayload = hasInput || hasOutput || metaKeys > 0;
-      // Rich: has meaningful input/output AND (at least one observation OR rich metadata with 5+ keys).
-      // This correctly scores event-style traces (session, message) that carry metadata instead of spans.
       if ((hasInput || hasOutput) && (observationCount >= 1 || hasRichMetadata)) counts.rich += 1;
       else if (hasPayload || observationCount >= 1) counts.partial += 1;
       else counts.sparse += 1;
@@ -308,19 +359,18 @@ async function fetchLangfuseTelemetryStatus(env, { timeout = 2500 } = {}) {
 
     return {
       status,
-      backend: 'langfuse',
       total,
       rich: counts.rich,
       partial: counts.partial,
       sparse: counts.sparse,
       coverage: Number(coverage.toFixed(2)),
       summary: total > 0
-        ? `Langfuse reachable · ${total} traces · rich ${counts.rich} · partial ${counts.partial} · sparse ${counts.sparse} · coverage ${(coverage * 100).toFixed(0)}%`
-        : 'Langfuse reachable · no traces yet',
+        ? `Telemetry reachable · ${total} traces · rich ${counts.rich} · partial ${counts.partial} · sparse ${counts.sparse} · coverage ${(coverage * 100).toFixed(0)}%`
+        : 'Telemetry reachable · no traces yet',
     };
   } catch (err) {
     const msg = err?.name === 'AbortError' ? 'timed out' : err.message;
-    return { status: 'unavailable', summary: `Langfuse ${msg}` };
+    return { status: 'unavailable', summary: `Telemetry ${msg}` };
   } finally {
     clearTimeout(timer);
   }
@@ -335,7 +385,7 @@ function summarizeRuntime(services) {
   const optionalServices = services.filter((service) => service.impactsOverall === false);
 
   const healthy = coreServices.filter((service) => service.status === 'healthy').length;
-  const degraded = coreServices.filter((service) => service.status === 'degraded').length;
+  const degraded = coreServices.filter((service) => service.status === 'degraded' || service.status === 'credentials-invalid').length;
   const unavailable = coreServices.filter((service) => service.status === 'unavailable').length;
   const optionalUnavailable = optionalServices.filter((service) => service.status !== 'healthy').length;
 
@@ -375,42 +425,51 @@ function summarizeIntegrations(features) {
   return { counts, summary: summary || 'No integrations detected' };
 }
 
-function workflowStatusSummary(workflow, cwd) {
-  const health = inspectWorkflowHealth(workflow, { cwd });
+function summarizePlugins(pluginRegistry) {
+  const plugins = pluginRegistry?.plugins ?? [];
+  const external = plugins.filter((plugin) => !plugin.builtIn);
+  const invalidCount = pluginRegistry?.errors?.length ?? 0;
+  const totalMcpCount = pluginRegistry?.mcps?.length ?? 0;
+
+  let status = 'healthy';
+  if (invalidCount > 0) status = 'degraded';
+  else if (external.length === 0) status = 'configured';
+
+  const summary = [
+    `${plugins.length} plugin${plugins.length === 1 ? '' : 's'}`,
+    `${external.length} external`,
+    `${totalMcpCount} MCP entries`,
+    invalidCount ? `${invalidCount} errors` : null,
+  ].filter(Boolean).join(' · ');
+
   return {
-    cwd,
-    exists: health.exists,
-    status: health.alignment.status,
-    summary: health.summary,
-    state: workflow,
-    findings: health.alignment.findings,
+    status,
+    total: plugins.length,
+    external: external.length,
+    builtIn: plugins.length - external.length,
+    totalMcpCount,
+    invalidCount,
+    summary,
   };
 }
 
 export function buildPublicHealthSurface({
   cwd = process.cwd(),
   contextInspection = inspectContextState(cwd),
-  workflow = loadWorkflow(cwd),
   executionContractModel = null,
 } = {}) {
-  const workflowHealth = inspectWorkflowHealth(workflow, { cwd });
-
   return {
-    activeTask: workflowHealth.activeTask,
     context: {
       hasFile: Boolean(contextInspection?.hasFile),
       source: contextInspection?.source ?? 'missing',
       savedAt: contextInspection?.savedAt ?? null,
       summary: contextInspection?.summary ?? null,
     },
-    workflow: {
-      exists: workflowHealth.exists,
-      phase: workflowHealth.phase,
-      lifecycleStatus: workflowHealth.lifecycleStatus,
-      currentTaskKey: workflowHealth.currentTaskKey,
-      summary: workflowHealth.summary,
+    coordination: {
+      authority: 'external-tracker-plus-plan',
+      fileOwnershipRule: 'single-writer',
+      memoryRole: 'cross-session-recall',
     },
-    alignment: workflowHealth.alignment,
     metadataPresence: {
       executionContractModel: Boolean(executionContractModel?.version),
       contextState: contextInspection?.source === 'json',
@@ -419,18 +478,91 @@ export function buildPublicHealthSurface({
 }
 
 function traceBackendDefinition(env) {
-  const langfuseUrl = (env.LANGFUSE_BASEURL ?? 'https://cloud.langfuse.com').replace(/\/$/, '');
+  const url = (env.CONSTRUCT_TELEMETRY_URL ?? '').replace(/\/$/, '');
+  const pubKey = env.CONSTRUCT_TELEMETRY_PUBLIC_KEY || '';
+  const secKey = env.CONSTRUCT_TELEMETRY_SECRET_KEY || '';
+  const auth = pubKey && secKey ? `Basic ${Buffer.from(`${pubKey}:${secKey}`).toString('base64')}` : '';
   return {
-    id: 'langfuse',
-    name: 'Langfuse',
-    url: langfuseUrl,
-    probeUrl: `${langfuseUrl}/api/public/health`,
+    id: 'telemetry',
+    name: 'Telemetry',
+    url: url || '(not configured)',
+    probeUrl: url ? `${url}/api/public/traces?limit=1` : '',
+    probeHeaders: auth ? { Authorization: auth } : undefined,
     runtime: 'live',
     note: 'Trace backend',
     healthyMessage: 'Reachable',
   };
 }
 
+/**
+ * In-process self-check for when Construct is serving its own dashboard.
+ * Rather than skipping the probe and asserting "healthy", we actually measure
+ * the process state and surface real problems.
+ *
+ * Checks:
+ *   - Heap usage — warn at 80%, critical at 95%
+ *   - Process uptime — surface as context
+ *   - Embed daemon — read state file and report if stale or crashed
+ *
+ * Returns { status: 'healthy'|'degraded'|'unavailable', message: string }
+ */
+function buildSelfCheck() {
+  const problems = [];
+  const notes = [];
+
+  // Memory
+  try {
+    const mem = process.memoryUsage();
+    const heapPct = mem.heapUsed / mem.heapTotal;
+    if (heapPct >= 0.95) {
+      problems.push(`heap ${Math.round(heapPct * 100)}% (critical)`);
+    } else if (heapPct >= 0.80) {
+      problems.push(`heap ${Math.round(heapPct * 100)}% (high)`);
+    } else {
+      notes.push(`heap ${Math.round(heapPct * 100)}%`);
+    }
+  } catch { /* non-fatal */ }
+
+  // Uptime
+  try {
+    const uptimeSec = process.uptime();
+    const h = Math.floor(uptimeSec / 3600);
+    const m = Math.floor((uptimeSec % 3600) / 60);
+    notes.push(`up ${h}h${m}m`);
+  } catch { /* non-fatal */ }
+
+  // Embed daemon state
+  try {
+    const stateFile = join(homedir(), '.cx', 'runtime', 'embed-daemon.json');
+    if (existsSync(stateFile)) {
+      const state = JSON.parse(readFileSync(stateFile, 'utf8'));
+      if (state.status === 'running' && state.pid) {
+        // Verify the PID is actually alive
+        try {
+          process.kill(state.pid, 0);
+          notes.push(`embed daemon pid ${state.pid}`);
+        } catch {
+          problems.push(`embed daemon pid ${state.pid} is not running (state file stale)`);
+        }
+      } else if (state.status === 'stopped') {
+        notes.push('embed daemon stopped');
+      }
+    }
+  } catch { /* non-fatal */ }
+
+  if (problems.length) {
+    return {
+      status: problems.some(p => p.includes('critical')) ? 'unavailable' : 'degraded',
+      message: problems.join('; ') + (notes.length ? ` — ${notes.join(', ')}` : ''),
+    };
+  }
+
+  return {
+    status: 'healthy',
+    message: ['Serving status API', ...notes].join(' — '),
+  };
+}
+
 function serviceDefinitions(env, dashboardPort, selfDashboard) {
   const memoryPort = parsePort(env.MEMORY_PORT, 8765);
   const bridgePort = parsePort(env.BRIDGE_PORT, 5173);
@@ -443,7 +575,7 @@ function serviceDefinitions(env, dashboardPort, selfDashboard) {
       runtime: 'live',
       note: selfDashboard ? 'Current process' : 'Dashboard API',
       healthyMessage: selfDashboard ? 'Serving status API' : 'Reachable',
-      selfHealthy: selfDashboard,
+      selfCheck: selfDashboard ? buildSelfCheck() : null,
     },
     traceBackendDefinition(env),
     {
@@ -486,12 +618,19 @@ export async function buildStatus({
   const pkg = readJSON(join(rootDir, 'package.json')) ?? {};
   const registry = readJSON(join(rootDir, 'agents', 'registry.json')) ?? {};
   const settings = readJSON(join(homeDir, '.claude', 'settings.json')) ?? {};
-  const features = await checkAllFeatures({ homeDir, env: mergedEnv });
+  const features = await checkAllFeatures({ homeDir, cwd, env: mergedEnv });
+  const pluginRegistry = loadPluginRegistry({ cwd, homeDir, rootDir, env: mergedEnv });
   const services = [];
 
   for (const definition of serviceDefinitions(mergedEnv, resolvedDashboardPort, selfDashboard)) {
-    if (definition.selfHealthy) {
-      services.push({ ...definition, status: 'healthy', message: definition.healthyMessage ?? 'Reachable' });
+    if (definition.selfCheck) {
+      const check = definition.selfCheck;
+      services.push({
+        ...definition,
+        status: check.status,
+        message: check.message,
+        selfCheck: undefined,
+      });
       continue;
     }
 
@@ -500,8 +639,9 @@ export async function buildStatus({
       url: definition.probeUrl ?? definition.url,
     }));
 
+    const { probeHeaders, ...safeDef } = definition;
     services.push({
-      ...definition,
+      ...safeDef,
       status: result.status ?? 'unavailable',
       message: result.message ?? '',
     });
@@ -509,14 +649,16 @@ export async function buildStatus({
 
   const runtime = summarizeRuntime(services);
   const integrations = summarizeIntegrations(features);
-  const workflow = loadWorkflow(cwd);
-  const workflowSummary = workflowStatusSummary(workflow, cwd);
+  const plugins = summarizePlugins(pluginRegistry);
   const contextInspection = inspectContextState(cwd);
   const sessionEfficiency = readSessionEfficiency(homeDir);
   const sessionUsage = readSessionUsage(homeDir);
   const telemetryRichness = readTelemetryRichness(homeDir)
     ?? summarizeTelemetryHealth()
-    ?? await fetchLangfuseTelemetryStatus(mergedEnv);
+    ?? await fetchTelemetryStatus(mergedEnv);
+
+  // Fire-and-forget: post backfill observations to sparse traces when coverage is low.
+  triggerAutoBackfillIfSparse(telemetryRichness, { ...mergedEnv });
   const efficiencyDigest = summarizeEfficiencyData(readEfficiencyLog(homeDir));
   const activeOverlays = getActiveOverlays(cwd);
   const sqlStore = describeSqlStore(mergedEnv);
@@ -526,13 +668,12 @@ export async function buildStatus({
   const executionContractModel = resolveExecutionContractModelMetadata({
     envValues: mergedEnv,
     registryModels: registry.models ?? {},
-    requestedTier: selectModelTierForWorkCategory(workflowSummary.state?.tasks?.find((task) => task.key === workflowSummary.state?.currentTaskKey)?.workCategory),
+    requestedTier: selectModelTierForWorkCategory(null),
     workCategory: null,
   });
   const publicHealth = buildPublicHealthSurface({
     cwd,
     contextInspection,
-    workflow,
     executionContractModel,
   });
 
@@ -563,15 +704,45 @@ export async function buildStatus({
     }
   }
 
+  const deploymentMode = getDeploymentMode(mergedEnv);
+  const resourceMode = resolveResourceMode(deploymentMode);
+
   return {
     version: pkg.version ?? '1.0.0',
     lastSync: newestMtime(join(homeDir, '.claude', 'agents')),
+    deployment: {
+      mode: deploymentMode,
+      resourceMode,
+      description: describeDeploymentMode(deploymentMode),
+    },
     system: {
       overall: runtime,
       services,
       integrations,
+      plugins,
     },
     features,
+    plugins: {
+      status: plugins.status,
+      summary: plugins.summary,
+      directories: pluginRegistry.pluginDirs,
+      errors: pluginRegistry.errors,
+      entries: pluginRegistry.plugins.map((plugin) => ({
+        id: plugin.id,
+        name: plugin.name,
+        version: plugin.version,
+        description: plugin.description,
+        capabilities: plugin.capabilities ?? [],
+        builtIn: Boolean(plugin.builtIn),
+        manifestPath: plugin.manifestPath,
+        mcpCount: (plugin.mcps ?? []).length,
+        mcps: (plugin.mcps ?? []).map((mcp) => ({
+          id: mcp.id,
+          name: mcp.name,
+          category: mcp.category,
+        })),
+      })),
+    },
     personas,
     specialists,
     hooks,
@@ -579,7 +750,6 @@ export async function buildStatus({
     commands: listCommands(rootDir),
     cliCommands: CLI_COMMANDS,
     mcpServers: Object.keys(settings.mcpServers ?? {}),
-    workflow: workflowSummary,
     publicHealth,
     storage: {
       sql: sqlStore,
@@ -628,7 +798,11 @@ export function formatStatusReport(status) {
   lines.push('════════════════');
   lines.push('');
   lines.push(`Overall: ${statusLabel(status.system.overall.status)} · ${status.system.overall.summary}`);
-  lines.push(`Workflow: ${statusLabel(status.workflow.status)} · ${status.workflow.summary}`);
+  if (status.deployment?.mode) {
+    const r = status.deployment.resourceMode || {};
+    lines.push(`Deployment: ${status.deployment.mode} · queue:${r.queue} · workers:${r.workers} · telemetry:${r.telemetry}`);
+  }
+  lines.push('Coordination: external tracker + plan.md · single-writer per file · cass-memory for recall');
   if (status.executionContractModel?.selectedTier && status.executionContractModel?.selectedModel) {
     lines.push(`Execution contract: ${status.executionContractModel.selectedTier} · ${status.executionContractModel.selectedModel} (${status.executionContractModel.selectedModelSource})`);
   }
@@ -652,7 +826,13 @@ export function formatStatusReport(status) {
       : '';
     lines.push(`Usage: ${statusLabel(status.sessionUsage.status)} · ${status.sessionUsage.summary}${cacheNote}`);
     if (status.sessionUsage.lastInteraction) {
-      lines.push(`Last interaction: ${status.sessionUsage.lastInteraction.totalTokens.toLocaleString()} tokens (${status.sessionUsage.lastInteraction.inputTokens.toLocaleString()} in / ${status.sessionUsage.lastInteraction.outputTokens.toLocaleString()} out)`);
+      lines.push(
+        `Last interaction: ${status.sessionUsage.lastInteraction.providerTotalTokens.toLocaleString()} provider total` +
+        ` · ${status.sessionUsage.lastInteraction.billedTotalTokens.toLocaleString()} billed total` +
+        ` (${status.sessionUsage.lastInteraction.inputTokens.toLocaleString()} uncached in / ` +
+        `${status.sessionUsage.lastInteraction.outputTokens.toLocaleString()} out / ` +
+        `${Number(status.sessionUsage.lastInteraction.reasoningTokens || 0).toLocaleString()} reasoning)`,
+      );
     }
   }
   if (status.telemetryRichness) {
@@ -683,6 +863,17 @@ 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.plugins) {
+    lines.push('');
+    lines.push(`Plugins: ${statusLabel(status.plugins.status)} · ${status.plugins.summary}`);
+    for (const plugin of status.plugins.entries ?? []) {
+      const source = plugin.builtIn ? 'built-in' : plugin.manifestPath;
+      lines.push(`  ${serviceIcon(plugin.builtIn ? 'configured' : 'healthy')} ${plugin.name.padEnd(22)} ${plugin.version} — ${source}`);
+    }
+    for (const error of status.plugins.errors ?? []) {
+      lines.push(`  ${serviceIcon('degraded')} manifest error — ${error}`);
+    }
+  }
   return `${lines.join('\n')}\n`;
 }