memorix 1.7.3 → 1.8.1

package/src/config/dotenv-loader.ts

@@ -31,6 +31,8 @@ let dotenvProjectRoot: string | null = null;
 
 /** Track which .env files were loaded (for diagnostics) */
 const loadedEnvFiles: string[] = [];
+const loadedEnvKeys = new Set<string>();
+const loadedEnvValues = new Map<string, string>();
 /** Track keys injected by .env so project switches can cleanly restore process.env */
 const injectedKeys = new Set<string>();
 
@@ -40,6 +42,8 @@ function loadEnvFile(filePath: string): void {
   const parsed = parse(readFileSync(filePath, 'utf-8'));
   for (const [key, value] of Object.entries(parsed)) {
     if (!(key in process.env)) {
+      loadedEnvKeys.add(key);
+      loadedEnvValues.set(key, value);
       process.env[key] = value;
       injectedKeys.add(key);
     }
@@ -68,6 +72,8 @@ export function loadDotenv(projectRoot?: string, options: DotenvLoadOptions = {}
   }
 
   loadedEnvFiles.length = 0;
+  loadedEnvKeys.clear();
+  loadedEnvValues.clear();
 
   // Loading order = priority order (with override: false, first value wins).
   // System env vars already exist in process.env, so they always win.
@@ -96,6 +102,7 @@ export function resetDotenv(): void {
   dotenvLoaded = false;
   dotenvProjectRoot = null;
   loadedEnvFiles.length = 0;
+  loadedEnvKeys.clear();
 }
 
 /**
@@ -105,6 +112,16 @@ export function getLoadedEnvFiles(): readonly string[] {
   return loadedEnvFiles;
 }
 
+/** Get names found in loaded .env files without exposing their values. */
+export function getLoadedEnvKeys(): ReadonlySet<string> {
+  return loadedEnvKeys;
+}
+
+/** Get the value injected by .env, if the current process still has that value. */
+export function getLoadedEnvValue(key: string): string | undefined {
+  return loadedEnvValues.get(key);
+}
+
 // ─── Supported .env variables ───
 // These are the ONLY variables Memorix reads from .env.
 // All are secrets or endpoint URLs — no behavior config.

package/src/dashboard/config-provenance.ts

@@ -0,0 +1,17 @@
+import { getLoadedEnvValue } from '../config/dotenv-loader.js';
+
+export interface DashboardKeySourceOptions {
+  value: string;
+  envKeys: readonly string[];
+  configSource: string;
+}
+
+/** Resolve a secret source using the ordered environment fallback candidates. */
+export function resolveDashboardKeySource({ value, envKeys, configSource }: DashboardKeySourceOptions): string {
+  for (const envKey of envKeys) {
+    const envValue = process.env[envKey];
+    if (envValue !== value) continue;
+    return getLoadedEnvValue(envKey) === envValue ? '.env' : `env:${envKey}`;
+  }
+  return configSource;
+}

package/src/dashboard/evidence.ts

@@ -0,0 +1,63 @@
+import type { Entity, Relation, Observation } from '../types.js';
+
+export interface EvidenceCard {
+  id: number;
+  title: string;
+  type: string;
+  entityName: string;
+  why: string;
+  source: string;
+  sessionId?: string;
+  createdAt: string;
+  updatedAt?: string;
+  status: string;
+  verification: 'unverified' | 'verified' | 'conflicted';
+  files: string[];
+  relatedEntities: string[];
+  correctionHistory: string[];
+}
+
+function relationNeighbors(entityName: string, relations: Relation[]): string[] {
+  return [...new Set(relations.flatMap((relation) => {
+    if (relation.from === entityName) return [relation.to];
+    if (relation.to === entityName) return [relation.from];
+    return [];
+  }))].slice(0, 8);
+}
+
+/** Build bounded, operator-readable evidence cards from persisted records. */
+export function buildEvidenceCards(
+  observations: Observation[],
+  graph: { entities: Entity[]; relations: Relation[] },
+  query = '',
+  limit = 20,
+): EvidenceCard[] {
+  const needle = query.trim().toLowerCase();
+  return observations
+    .filter((observation) => !needle || [observation.title, observation.narrative, observation.entityName, ...(observation.concepts ?? [])]
+      .join(' ').toLowerCase().includes(needle))
+    .sort((a, b) => b.id - a.id)
+    .slice(0, Math.max(1, Math.min(100, limit)))
+    .map((observation) => {
+      const neighbors = relationNeighbors(observation.entityName, graph.relations);
+      const entity = graph.entities.find((candidate) => candidate.name === observation.entityName);
+      const verification = observation.status === 'resolved' ? 'verified' :
+        observation.status === 'archived' ? 'conflicted' : 'unverified';
+      return {
+        id: observation.id,
+        title: observation.title,
+        type: observation.type,
+        entityName: observation.entityName,
+        why: entity ? 'Matched persisted entity and project-scoped evidence.' : 'Matched project-scoped memory record.',
+        source: observation.sourceDetail || observation.source || 'unknown',
+        ...(observation.sessionId ? { sessionId: observation.sessionId } : {}),
+        createdAt: observation.createdAt,
+        ...(observation.updatedAt ? { updatedAt: observation.updatedAt } : {}),
+        status: observation.status || 'active',
+        verification,
+        files: observation.filesModified || [],
+        relatedEntities: neighbors,
+        correctionHistory: [],
+      };
+    });
+}

package/src/dashboard/server.ts

@@ -22,10 +22,13 @@ import { loadDotenv } from '../config/dotenv-loader.js';
 import { resetDotenv } from '../config/dotenv-loader.js';
 import { initProjectRoot } from '../config/yaml-loader.js';
 import { clearProjectRoot } from '../config/yaml-loader.js';
+import { getResolvedConfig } from '../config/resolved-config.js';
 import { scopeKnowledgeGraphToProject } from '../memory/graph-scope.js';
 import { projectObservationRetention, summarizeRetentionProjections } from '../memory/retention.js';
 import { canManageObservation, filterReadableObservations } from '../memory/visibility.js';
 import type { Observation } from '../types.js';
+import { EvidenceCardStore } from '../store/evidence-store.js';
+import { MemoryFeedbackStore } from '../memory/feedback.js';
 import {
     DashboardMaintenanceError,
     executeCleanup,
@@ -37,6 +40,7 @@ import {
     previewDeduplicate,
     previewRetentionArchive,
 } from './maintenance.js';
+import { resolveDashboardKeySource } from './config-provenance.js';
 
 // MIME types for static file serving
 const MIME_TYPES: Record<string, string> = {
@@ -326,6 +330,22 @@ async function handleApi(
                 break;
             }
 
+            case '/evidence': {
+                const observations = filterDashboardObservations(
+                    await getObservationStore().loadByProject(effectiveProjectId, { status: 'active' }),
+                    effectiveProjectId,
+                );
+                const evidenceStore = new EvidenceCardStore();
+                await evidenceStore.init(effectiveDataDir);
+                evidenceStore.syncObservations(observations);
+                const query = url.searchParams.get('q') || '';
+                const limit = Number(url.searchParams.get('limit') || 20);
+                const cards = evidenceStore.list(effectiveProjectId, { limit: Math.min(100, Math.max(1, limit)) })
+                    .filter((card) => !query || [card.title, card.summary, card.sourceRef, card.locator ?? ''].join(' ').toLowerCase().includes(query.toLowerCase()));
+                sendJson(res, { cards, projectId: effectiveProjectId });
+                break;
+            }
+
             case '/sessions': {
                 const allSessions = await getSessionStore().loadAll();
                 const sessions = filterByProject(allSessions as Array<{ projectId?: string }>, effectiveProjectId);
@@ -381,10 +401,15 @@ async function handleApi(
                 }));
 
                 const retentionReferenceTime = new Date(now);
+                const feedback = new MemoryFeedbackStore();
+                await feedback.init(effectiveDataDir).catch(() => undefined);
                 const retention = summarizeRetentionProjections(
                     observations
                         .filter((observation) => observation.type !== 'probe')
-                        .map((observation) => projectObservationRetention(observation, { referenceTime: retentionReferenceTime })),
+                        .map((observation) => projectObservationRetention(observation, {
+                            referenceTime: retentionReferenceTime,
+                            feedback: feedback.getState(effectiveProjectId, 'observation', String(observation.id)),
+                        })),
                 );
                 const retentionSummary = {
                     active: retention.active,
@@ -489,11 +514,16 @@ async function handleApi(
                 );
 
                 const referenceTime = new Date();
+                const feedback = new MemoryFeedbackStore();
+                await feedback.init(effectiveDataDir).catch(() => undefined);
                 const rows = observations
                     .filter((observation) => observation.type !== 'probe')
                     .map((observation) => ({
                         observation,
-                        retention: projectObservationRetention(observation, { referenceTime }),
+                        retention: projectObservationRetention(observation, {
+                            referenceTime,
+                            feedback: feedback.getState(effectiveProjectId, 'observation', String(observation.id)),
+                        }),
                     }))
                     .sort((a, b) => b.retention.displayScore - a.retention.displayScore);
                 const summary = summarizeRetentionProjections(rows.map((row) => row.retention));
@@ -580,26 +610,18 @@ async function handleApi(
                 const { existsSync } = await import('node:fs');
                 const { join } = await import('node:path');
 
-                let yml: any = {};
                 // Use the real project root from dashboard state, not process.cwd()
                 const configProjectRoot = effectiveProjectRoot;
-                try {
-                    const { loadYamlConfig } = await import('../config/yaml-loader.js');
-                    yml = configProjectRoot ? loadYamlConfig(configProjectRoot) : loadYamlConfig(null);
-                } catch { /* best effort */ }
-
-                // Load .env files so process.env reflects actual config (fixes #74, #62)
-                if (configProjectRoot) {
-                    try {
-                        const { loadDotenv } = await import('../config/dotenv-loader.js');
-                        loadDotenv(configProjectRoot);
-                    } catch { /* best effort */ }
-                }
+                // This is the same TOML-first chain used by status and runtime lanes.
+                // Do not fall back to user config if a bound project cannot resolve.
+                const resolved = getResolvedConfig({ projectRoot: configProjectRoot });
 
                 // Check which config files exist
                 const files: Record<string, { exists: boolean; path: string; unavailable?: boolean }> = {
                     'project memorix.yml': { exists: false, path: '', unavailable: !configProjectRoot },
                     'user memorix.yml': { exists: false, path: '' },
+                    'project memorix.toml': { exists: false, path: '', unavailable: !configProjectRoot },
+                    'user config.toml': { exists: false, path: '' },
                     'project .env': { exists: false, path: '', unavailable: !configProjectRoot },
                     'user .env': { exists: false, path: '' },
                     'legacy config.json': { exists: false, path: '' },
@@ -609,6 +631,8 @@ async function handleApi(
                     const paths: Record<string, string | null> = {
                         'project memorix.yml': configProjectRoot ? join(configProjectRoot, 'memorix.yml') : null,
                         'user memorix.yml': join(home, '.memorix', 'memorix.yml'),
+                        'project memorix.toml': configProjectRoot ? join(configProjectRoot, 'memorix.toml') : null,
+                        'user config.toml': join(home, '.memorix', 'config.toml'),
                         'project .env': configProjectRoot ? join(configProjectRoot, '.env') : null,
                         'user .env': join(home, '.memorix', '.env'),
                         'legacy config.json': join(home, '.memorix', 'config.json'),
@@ -626,82 +650,83 @@ async function handleApi(
                 const values: Array<{ key: string; value: string; source: string; sensitive?: boolean }> = [];
 
                 // LLM
-                // Helper: determine source label (distinguishes .env file vs system env)
-                const getEnvSource = async (envKey: string, ymlSource?: string): Promise<string> => {
-                    if (process.env[envKey]) {
-                        // Check if this key was injected by dotenv-loader (from .env file)
-                        try {
-                            const { getLoadedEnvFiles } = await import('../config/dotenv-loader.js');
-                            const envFiles = getLoadedEnvFiles();
-                            if (envFiles.length > 0) return `.env (${envKey})`;
-                        } catch { /* ignore */ }
-                        return `env:${envKey}`;
-                    }
-                    return ymlSource ?? 'default';
-                };
+                const tomlSource = configProjectRoot && files['project memorix.toml'].exists
+                    ? 'memorix.toml'
+                    : files['user config.toml'].exists ? 'config.toml' : 'default';
+                const legacySource = files['project memorix.yml'].exists || files['user memorix.yml'].exists
+                    ? 'memorix.yml'
+                    : files['legacy config.json'].exists ? 'config.json' : 'default';
+                const configSource = resolved.sources.toml.length > 0 ? tomlSource
+                    : resolved.sources.legacy.length > 0 ? legacySource : 'default';
+                const source = (envKey: string): string => resolveDashboardKeySource({
+                    value: process.env[envKey] ?? '',
+                    envKeys: [envKey],
+                    configSource,
+                });
 
-                const llmProvider = process.env.MEMORIX_LLM_PROVIDER || yml.llm?.provider;
-                if (llmProvider) values.push({ key: 'llm.provider', value: llmProvider, source: await getEnvSource('MEMORIX_LLM_PROVIDER', yml.llm?.provider ? 'memorix.yml' : undefined) });
+                if (resolved.memory.llm.provider) values.push({ key: 'llm.provider', value: resolved.memory.llm.provider, source: source('MEMORIX_LLM_PROVIDER') });
 
-                const llmModel = process.env.MEMORIX_LLM_MODEL || yml.llm?.model;
-                if (llmModel) values.push({ key: 'llm.model', value: llmModel, source: await getEnvSource('MEMORIX_LLM_MODEL', yml.llm?.model ? 'memorix.yml' : undefined) });
+                if (resolved.memory.llm.model) values.push({ key: 'llm.model', value: resolved.memory.llm.model, source: source('MEMORIX_LLM_MODEL') });
 
-                const llmKey = process.env.MEMORIX_LLM_API_KEY || process.env.MEMORIX_API_KEY || yml.llm?.apiKey || process.env.OPENAI_API_KEY;
+                const llmKey = resolved.memory.llm.apiKey;
+                const memoryKeyEnv = [
+                    'MEMORIX_LLM_API_KEY',
+                    'MEMORIX_API_KEY',
+                    'OPENAI_API_KEY',
+                    'ANTHROPIC_API_KEY',
+                    ...(resolved.memory.llm.provider === 'openrouter' || resolved.memory.llm.baseUrl?.includes('openrouter.ai')
+                        ? ['OPENROUTER_API_KEY']
+                        : []),
+                ];
                 if (llmKey) {
-                    let src = 'unknown';
-                    if (process.env.MEMORIX_LLM_API_KEY) src = await getEnvSource('MEMORIX_LLM_API_KEY');
-                    else if (process.env.MEMORIX_API_KEY) src = await getEnvSource('MEMORIX_API_KEY');
-                    else if (yml.llm?.apiKey) src = 'memorix.yml (move to .env!)';
-                    else if (process.env.OPENAI_API_KEY) src = await getEnvSource('OPENAI_API_KEY');
+                    const src = resolveDashboardKeySource({ value: llmKey, envKeys: memoryKeyEnv, configSource });
                     values.push({ key: 'llm.apiKey', value: '****' + llmKey.slice(-4), source: src, sensitive: true });
                 } else {
                     values.push({ key: 'llm.apiKey', value: 'not set', source: 'none' });
                 }
 
-                const agentProvider = process.env.MEMORIX_AGENT_PROVIDER || process.env.MEMORIX_AGENT_LLM_PROVIDER || yml.agent?.provider;
-                if (agentProvider) {
-                    let source: string;
-                    if (process.env.MEMORIX_AGENT_PROVIDER) source = await getEnvSource('MEMORIX_AGENT_PROVIDER');
-                    else if (process.env.MEMORIX_AGENT_LLM_PROVIDER) source = `${await getEnvSource('MEMORIX_AGENT_LLM_PROVIDER')} (legacy)`;
-                    else source = yml.agent?.provider ? 'memorix.yml' : 'default';
-                    values.push({ key: 'agent.provider', value: agentProvider, source });
+                if (resolved.agent.provider) {
+                    values.push({ key: 'agent.provider', value: resolved.agent.provider, source: source('MEMORIX_AGENT_PROVIDER') });
                 }
 
-                const agentModel = process.env.MEMORIX_AGENT_MODEL || process.env.MEMORIX_AGENT_LLM_MODEL || yml.agent?.model;
-                if (agentModel) {
-                    let source: string;
-                    if (process.env.MEMORIX_AGENT_MODEL) source = await getEnvSource('MEMORIX_AGENT_MODEL');
-                    else if (process.env.MEMORIX_AGENT_LLM_MODEL) source = `${await getEnvSource('MEMORIX_AGENT_LLM_MODEL')} (legacy)`;
-                    else source = yml.agent?.model ? 'memorix.yml' : 'default';
-                    values.push({ key: 'agent.model', value: agentModel, source });
+                if (resolved.agent.model) {
+                    values.push({ key: 'agent.model', value: resolved.agent.model, source: source('MEMORIX_AGENT_MODEL') });
                 }
 
-                const agentKey = process.env.MEMORIX_AGENT_API_KEY || process.env.MEMORIX_AGENT_LLM_API_KEY || yml.agent?.apiKey;
+                const agentKey = resolved.agent.apiKey;
                 if (agentKey) {
-                    let src = 'unknown';
-                    if (process.env.MEMORIX_AGENT_API_KEY) src = await getEnvSource('MEMORIX_AGENT_API_KEY');
-                    else if (process.env.MEMORIX_AGENT_LLM_API_KEY) src = `${await getEnvSource('MEMORIX_AGENT_LLM_API_KEY')} (legacy)`;
-                    else if (yml.agent?.apiKey) src = 'memorix.yml (move to .env!)';
+                    const src = resolveDashboardKeySource({
+                        value: agentKey,
+                        envKeys: ['MEMORIX_AGENT_API_KEY', 'MEMORIX_AGENT_LLM_API_KEY'],
+                        configSource,
+                    });
                     values.push({ key: 'agent.apiKey', value: '****' + agentKey.slice(-4), source: src, sensitive: true });
                 } else {
-                    values.push({ key: 'agent.apiKey', value: 'fallback to llm.apiKey', source: 'default' });
+                    values.push({
+                        key: 'agent.apiKey',
+                        value: 'fallback to llm.apiKey',
+                        source: llmKey
+                            ? resolveDashboardKeySource({ value: llmKey, envKeys: memoryKeyEnv, configSource })
+                            : 'default',
+                    });
                 }
 
                 // Embedding
-                const embProvider = process.env.MEMORIX_EMBEDDING || yml.embedding?.provider || 'off';
-                values.push({ key: 'embedding.provider', value: embProvider, source: await getEnvSource('MEMORIX_EMBEDDING', yml.embedding?.provider ? 'memorix.yml' : undefined) });
+                values.push({ key: 'embedding.provider', value: resolved.embedding.provider || 'off', source: source('MEMORIX_EMBEDDING') });
+                if (resolved.embedding.model) values.push({ key: 'embedding.model', value: resolved.embedding.model, source: source('MEMORIX_EMBEDDING_MODEL') });
 
-                // Git
-                values.push({ key: 'git.autoHook', value: String(yml.git?.autoHook ?? false), source: yml.git?.autoHook !== undefined ? 'memorix.yml' : 'default' });
-                values.push({ key: 'git.skipMergeCommits', value: String(yml.git?.skipMergeCommits ?? true), source: yml.git?.skipMergeCommits !== undefined ? 'memorix.yml' : 'default' });
+                if (resolved.rerank.provider !== 'off') {
+                    values.push({ key: 'rerank.provider', value: resolved.rerank.provider, source: source('MEMORIX_RERANK_PROVIDER') });
+                    if (resolved.rerank.model) values.push({ key: 'rerank.model', value: resolved.rerank.model, source: source('MEMORIX_RERANK_MODEL') });
+                }
 
-                // Behavior
-                if (yml.behavior?.formationMode) values.push({ key: 'behavior.formationMode', value: yml.behavior.formationMode, source: 'memorix.yml' });
-                if (yml.behavior?.sessionInject) values.push({ key: 'behavior.sessionInject', value: yml.behavior.sessionInject, source: 'memorix.yml' });
+                // Git
+                values.push({ key: 'git.autoHook', value: String(resolved.git.autoHook ?? false), source: configSource });
+                values.push({ key: 'git.skipMergeCommits', value: String(resolved.git.skipMergeCommits ?? true), source: configSource });
 
                 // Server
-                values.push({ key: 'server.transport', value: yml.server?.transport || 'stdio', source: yml.server?.transport ? 'memorix.yml' : 'default' });
-                values.push({ key: 'server.dashboard', value: String(yml.server?.dashboard ?? true), source: yml.server?.dashboard !== undefined ? 'memorix.yml' : 'default' });
+                values.push({ key: 'server.transport', value: resolved.server.transport || 'stdio', source: configSource });
+                values.push({ key: 'server.dashboard', value: String(resolved.server.dashboard ?? true), source: configSource });
 
                 sendJson(res, { files, values });
                 break;
@@ -933,18 +958,10 @@ interface DashboardState {
     dataDir: string;
     projectRoot: string | null;
     projectResolved: boolean;
-    mode: 'standalone' | 'control-plane';
+    mode: 'standalone';
     port: number;
 }
 
-/** Optional coordination instances passed from MCP server */
-export interface TeamInstances {
-    registry: { listAgents: (filter?: any) => any[]; getActiveCount: () => number; getAgent: (id: string) => any };
-    fileLocks: { listLocks: (agentId?: string) => any[]; cleanExpired: () => void };
-    taskManager: { list: (filter?: any) => any[]; getAvailable: () => any[] };
-    messageBus: { getUnreadCount: (agentId: string) => number };
-}
-
 function parseJsonField(value: unknown, fallback: unknown): unknown {
     if (typeof value !== 'string') return value ?? fallback;
     try {
@@ -1002,7 +1019,72 @@ function normalizeDashboardTask(task: any) {
     };
 }
 
-async function buildTeamSnapshot(dataDir: string, projectId: string, scope: string, mode: DashboardState['mode']) {
+type TeamSnapshotStatus = 'ok' | 'degraded' | 'error';
+
+interface TeamSnapshot {
+    status: TeamSnapshotStatus;
+    mode: DashboardState['mode'];
+    readOnly: true;
+    scope: string;
+    agents: any[];
+    activeCount: number;
+    recentCount: number;
+    historicalCount: number;
+    totalAgents: number;
+    recentWindowDays: number;
+    locks: any[];
+    tasks: any[];
+    availableTasks: number;
+    sessions: number;
+    roles: any[];
+    roleOccupancy: any[];
+    handoffs: any[];
+    openTasks: number;
+    openHandoffs: number;
+    totalUnread: number;
+    activeSessions: number;
+    error?: string;
+    errorCode?: string;
+}
+
+function emptyTeamSnapshot(
+    mode: DashboardState['mode'],
+    scope: string,
+    status: Exclude<TeamSnapshotStatus, 'ok'>,
+): TeamSnapshot {
+    return {
+        status,
+        mode,
+        readOnly: true,
+        scope,
+        agents: [],
+        activeCount: 0,
+        recentCount: 0,
+        historicalCount: 0,
+        totalAgents: 0,
+        recentWindowDays: 7,
+        locks: [],
+        tasks: [],
+        availableTasks: 0,
+        sessions: 0,
+        roles: [],
+        roleOccupancy: [],
+        handoffs: [],
+        openTasks: 0,
+        openHandoffs: 0,
+        totalUnread: 0,
+        activeSessions: 0,
+        error: status === 'error' ? 'Coordination state unavailable' : 'Coordination state is incomplete',
+        errorCode: status === 'error' ? 'COORDINATION_STATE_UNAVAILABLE' : 'COORDINATION_STATE_DEGRADED',
+    };
+}
+
+function logTeamSnapshotFailure(scope: string, status: Exclude<TeamSnapshotStatus, 'ok'>): void {
+    const safeScope = scope === 'global' ? 'global' : 'project';
+    console.error('[dashboard] coordination snapshot unavailable', { status, scope: safeScope });
+}
+
+async function buildTeamSnapshot(dataDir: string, projectId: string, scope: string, mode: DashboardState['mode']): Promise<TeamSnapshot> {
     try {
         const { initTeamStore } = await import('../team/team-store.js');
         const teamStore = await initTeamStore(dataDir);
@@ -1028,8 +1110,9 @@ async function buildTeamSnapshot(dataDir: string, projectId: string, scope: stri
         const roleOccupancy = effectiveProjectId ? teamStore.getRoleOccupancy(effectiveProjectId) : [];
         const handoffs = effectiveProjectId ? teamStore.listHandoffs(effectiveProjectId) : [];
         return {
+            status: 'ok',
             mode,
-            readOnly: mode === 'standalone',
+            readOnly: true,
             scope,
             agents: withTier,
             activeCount,
@@ -1050,28 +1133,8 @@ async function buildTeamSnapshot(dataDir: string, projectId: string, scope: stri
             activeSessions: activeCount,
         };
     } catch {
-        return {
-            mode,
-            readOnly: mode === 'standalone',
-            scope,
-            agents: [],
-            activeCount: 0,
-            recentCount: 0,
-            historicalCount: 0,
-            totalAgents: 0,
-            recentWindowDays: 7,
-            locks: [],
-            tasks: [],
-            availableTasks: 0,
-            sessions: 0,
-            roles: [],
-            roleOccupancy: [],
-            handoffs: [],
-            openTasks: 0,
-            openHandoffs: 0,
-            totalUnread: 0,
-            activeSessions: 0,
-        };
+        logTeamSnapshotFailure(scope, 'error');
+        return emptyTeamSnapshot(mode, scope, 'error');
     }
 }
 
@@ -1100,7 +1163,6 @@ export async function startDashboard(
     projectId: string,
     projectName: string,
     autoOpen = true,
-    teamInstances?: TeamInstances,
     projectRoot: string | null = null,
     projectResolved = true,
 ): Promise<void> {
@@ -1111,8 +1173,7 @@ export async function startDashboard(
     const baseDir = getBaseDataDir();
 
     // Mutable state — can be updated via /api/set-current-project
-    const isControlPlane = !!teamInstances;
-    const state: DashboardState = { projectId, projectName, dataDir, projectRoot, projectResolved, mode: isControlPlane ? 'control-plane' : 'standalone', port };
+    const state: DashboardState = { projectId, projectName, dataDir, projectRoot, projectResolved, mode: 'standalone', port };
 
     const server = createServer(async (req, res) => {
         const url = req.url || '/';
@@ -1139,56 +1200,20 @@ export async function startDashboard(
             return;
         }
 
-        if (url.startsWith('/api/team')) {
-            if (!teamInstances) {
-                const parsedUrl = new URL(url, `http://127.0.0.1:${port}`);
-                const scope = parsedUrl.searchParams.get('scope') || 'project';
-                sendJson(res, await buildTeamSnapshot(state.dataDir, state.projectId, scope, state.mode));
-                return;
-            }
-            try {
-                teamInstances.fileLocks.cleanExpired();
-                const agents = teamInstances.registry.listAgents();
-                const locks = teamInstances.fileLocks.listLocks();
-                const tasks = teamInstances.taskManager.list();
-                const available = teamInstances.taskManager.getAvailable();
-
-                // Role occupancy and handoffs from TeamStore (if available)
-                let roles: any[] = [];
-                let roleOccupancy: any[] = [];
-                let handoffs: any[] = [];
-                try {
-                    const { getTeamStore, isTeamStoreInitialized } = await import('../team/team-store.js');
-                    if (isTeamStoreInitialized()) {
-                        const teamStore = getTeamStore();
-                        const projectId = state.projectId;
-                        roles = teamStore.listRoles(projectId);
-                        roleOccupancy = teamStore.getRoleOccupancy(projectId);
-                        handoffs = teamStore.listHandoffs(projectId);
-                    }
-                } catch { /* team store not available in standalone mode */ }
-
+        const parsedUrl = new URL(url, `http://127.0.0.1:${port}`);
+        if (parsedUrl.pathname === '/api/team') {
+            if (req.method !== 'GET') {
                 sendJson(res, {
-                    agents: agents.map((a: any) => ({
-                        ...a,
-                        unread: teamInstances!.messageBus.getUnreadCount(a.id),
-                    })),
-                    activeCount: teamInstances.registry.getActiveCount(),
-                    locks,
-                    tasks,
-                    availableTasks: available.length,
-                    roles,
-                    roleOccupancy,
-                    handoffs,
-                    // Resume data for "Continue this project" area
-                    openTasks: tasks.filter((t: any) => t.status === 'pending' || t.status === 'in_progress').length,
-                    openHandoffs: handoffs.filter((h: any) => h.handoff_status === 'open' || h.handoffStatus === 'open').length,
-                    totalUnread: agents.reduce((sum: number, a: any) => sum + teamInstances!.messageBus.getUnreadCount(a.id), 0),
-                    activeSessions: agents.filter((a: any) => a.status === 'active').length,
-                });
-            } catch {
-                sendJson(res, { agents: [], activeCount: 0, locks: [], tasks: [], availableTasks: 0, roles: [], roleOccupancy: [], handoffs: [] });
+                    status: 'error',
+                    readOnly: true,
+                    error: 'Coordination status is read-only',
+                    errorCode: 'COORDINATION_STATUS_READ_ONLY',
+                }, 405);
+                return;
             }
+            const scope = parsedUrl.searchParams.get('scope') || 'project';
+            const snapshot = await buildTeamSnapshot(state.dataDir, state.projectId, scope, state.mode);
+            sendJson(res, snapshot, snapshot.status === 'error' ? 503 : 200);
             return;
         }
 
@@ -1212,13 +1237,12 @@ export async function startDashboard(
         server.listen(port, '127.0.0.1', () => {
             const url = `http://127.0.0.1:${port}`;
             const resolvedLabel = projectResolved ? 'resolved' : 'unresolved';
-            const modeLabel = isControlPlane ? 'Control Plane' : 'Standalone';
+            const modeLabel = 'Standalone';
             console.error(`  Memorix Dashboard [${modeLabel}]`);
             console.error(`  ───────────────────────`);
             console.error(`  Mode:     ${modeLabel}`);
             console.error(`  Project:  ${projectName} (${projectId}) [${resolvedLabel}]`);
             console.error(`  Local:    ${url}`);
-            if (isControlPlane) console.error(`  MCP:      ${url}/mcp`);
             console.error(`  Data dir: ${dataDir}`);
             console.error(`\n  Press Ctrl+C to stop\n`);
             if (autoOpen) openBrowser(url);