memorix 1.8.0 → 1.8.2

package/src/dashboard/server.ts

@@ -958,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 {
@@ -1027,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);
@@ -1053,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,
@@ -1075,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');
     }
 }
 
@@ -1125,7 +1163,6 @@ export async function startDashboard(
     projectId: string,
     projectName: string,
     autoOpen = true,
-    teamInstances?: TeamInstances,
     projectRoot: string | null = null,
     projectResolved = true,
 ): Promise<void> {
@@ -1136,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 || '/';
@@ -1164,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;
         }
 
@@ -1237,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);

package/src/dashboard/static/index.html

@@ -135,7 +135,7 @@
         </svg>
         <span class="nav-label">Sessions</span>
       </button>
-      <button class="nav-btn" data-page="team" title="Coordination" aria-label="Coordination">
+      <button class="nav-btn" data-page="team" title="Coordination Status" aria-label="Coordination Status">
         <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
           <path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"/>
           <circle cx="9" cy="7" r="4"/>

package/src/llm/provider.ts

@@ -210,6 +210,10 @@ export type LLMConfigScope = 'memory' | 'agent';
 
 export interface InitLLMOptions {
   scope?: LLMConfigScope;
+  /** Resolve project TOML/.env instead of relying on process.cwd(). */
+  projectRoot?: string | null;
+  /** Override the home directory used for global TOML/.env resolution. */
+  homeDir?: string;
 }
 
 /**
@@ -218,20 +222,29 @@ export interface InitLLMOptions {
  */
 export function initLLM(options: InitLLMOptions = {}): LLMConfig | null {
   const scope = options.scope ?? 'memory';
-  const apiKey = scope === 'agent' ? getAgentLLMApiKey() : getLLMApiKey();
+  const configOptions = { projectRoot: options.projectRoot, homeDir: options.homeDir };
+  const apiKey = scope === 'agent'
+    ? getAgentLLMApiKey(configOptions)
+    : getLLMApiKey(configOptions);
   if (!apiKey) {
     currentConfig = null;
     return null;
   }
 
-  const provider = (scope === 'agent' ? getAgentLLMProvider() : getLLMProvider()) as LLMConfig['provider'];
+  const provider = (scope === 'agent'
+    ? getAgentLLMProvider(configOptions)
+    : getLLMProvider(configOptions)) as LLMConfig['provider'];
   const defaults = PROVIDER_DEFAULTS[provider] ?? PROVIDER_DEFAULTS.openai;
 
   currentConfig = {
     provider,
     apiKey,
-    model: scope === 'agent' ? getAgentLLMModel(defaults.model) : getLLMModel(defaults.model),
-    baseUrl: scope === 'agent' ? getAgentLLMBaseUrl(defaults.baseUrl) : getLLMBaseUrl(defaults.baseUrl),
+    model: scope === 'agent'
+      ? getAgentLLMModel(defaults.model, configOptions)
+      : getLLMModel(defaults.model, configOptions),
+    baseUrl: scope === 'agent'
+      ? getAgentLLMBaseUrl(defaults.baseUrl, configOptions)
+      : getLLMBaseUrl(defaults.baseUrl, configOptions),
   };
 
   return currentConfig;

package/src/server/mcp-compat.ts

@@ -0,0 +1,82 @@
+/**
+ * Small MCP 2026-07-28 discovery adapter for the pinned v1 SDK.
+ *
+ * The v1 SDK can route an extension request through its low-level Server, but
+ * it does not implement the modern discovery/cache negotiation itself. Keep
+ * this adapter deliberately narrow: advertise discovery and the existing
+ * legacy tool handlers, while leaving unsupported extensions unadvertised.
+ */
+
+import { RequestSchema, type ServerCapabilities } from '@modelcontextprotocol/sdk/types.js';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod/v4';
+
+export const MCP_MODERN_PROTOCOL_VERSION = '2026-07-28';
+export const MCP_LEGACY_PROTOCOL_VERSION = '2025-11-25';
+export const MCP_OLDEST_LEGACY_PROTOCOL_VERSION = '2024-11-05';
+export const MCP_SERVER_DISCOVER_METHOD = 'server/discover';
+export const MCP_SERVER_INFO_META_KEY = 'io.modelcontextprotocol/serverInfo';
+
+const ServerDiscoverRequestSchema = RequestSchema.extend({
+  method: z.literal(MCP_SERVER_DISCOVER_METHOD),
+  params: z.looseObject({}).optional(),
+});
+
+export interface McpServerInfo {
+  name: string;
+  version: string;
+}
+
+export interface McpDiscoverResult {
+  resultType: 'complete';
+  supportedVersions: string[];
+  capabilities: ServerCapabilities;
+  _meta: {
+    [MCP_SERVER_INFO_META_KEY]: McpServerInfo;
+  };
+  ttlMs: number;
+  cacheScope: 'public' | 'private';
+}
+
+const registeredServers = new WeakSet<McpServer>();
+
+/** Build the wire result without exposing unsupported cache/task features. */
+export function buildMcpDiscoverResult(server: McpServer, serverInfo: McpServerInfo): McpDiscoverResult {
+  // SDK 1.30 exposes this method at runtime but marks it private in its
+  // declaration file. The discovery response must reflect the capabilities
+  // already registered on this exact low-level Server instance.
+  const getCapabilities = (server.server as unknown as {
+    getCapabilities: () => ServerCapabilities;
+  }).getCapabilities.bind(server.server);
+  return {
+    resultType: 'complete',
+    supportedVersions: [
+      MCP_MODERN_PROTOCOL_VERSION,
+      MCP_LEGACY_PROTOCOL_VERSION,
+      MCP_OLDEST_LEGACY_PROTOCOL_VERSION,
+    ],
+    capabilities: getCapabilities(),
+    _meta: {
+      [MCP_SERVER_INFO_META_KEY]: { ...serverInfo },
+    },
+    // v1 has no response-cache negotiation. A zero private TTL is the
+    // conservative result and prevents clients from inventing a shared cache.
+    ttlMs: 0,
+    cacheScope: 'private',
+  };
+}
+
+/**
+ * Register `server/discover` on the v1 low-level Server.
+ *
+ * This is idempotent for a single McpServer instance because HTTP/session
+ * setup can revisit the registration boundary while reusing an object.
+ */
+export function registerMcpDiscovery(server: McpServer, serverInfo: McpServerInfo): void {
+  if (registeredServers.has(server)) return;
+
+  server.server.setRequestHandler(ServerDiscoverRequestSchema, async () => (
+    buildMcpDiscoverResult(server, serverInfo)
+  ));
+  registeredServers.add(server);
+}

package/src/server/mcp-diagnostics.ts

@@ -1,7 +1,8 @@
 /** MCP compatibility diagnostics shared by HTTP and CLI-facing checks. */
 
 export const CURRENT_MCP_PROTOCOL_VERSION = '2026-07-28';
-export const LEGACY_MCP_PROTOCOL_VERSION = '2024-11-05';
+export const LEGACY_MCP_PROTOCOL_VERSION = '2025-11-25';
+export const OLDEST_LEGACY_MCP_PROTOCOL_VERSION = '2024-11-05';
 export const MCP_SERVER_NAME = 'io.github.AVIDS2/memorix';
 
 export interface McpDiagnostics {
@@ -9,13 +10,17 @@ export interface McpDiagnostics {
   protocol: {
     current: string;
     legacy: string;
+    discovery: 'supported';
+    versionlessRequests: 'legacy-compatible';
+    modernResultMetadata: 'discovery-only';
     statelessRequests: 'supported' | 'compatibility-only' | 'unsupported';
     statefulStreamableHttp: 'supported';
   };
   capabilities: {
     tasks: 'supported' | 'unsupported';
     polling: 'supported' | 'unsupported';
-    listCache: 'supported';
+    subscriptions: 'supported' | 'unsupported';
+    listCache: 'supported' | 'unsupported';
     explicitProjectHandle: 'supported';
   };
 }
@@ -27,13 +32,17 @@ export function getMcpDiagnostics(): McpDiagnostics {
     protocol: {
       current: CURRENT_MCP_PROTOCOL_VERSION,
       legacy: LEGACY_MCP_PROTOCOL_VERSION,
-    statelessRequests: 'supported',
+      discovery: 'supported',
+      versionlessRequests: 'legacy-compatible',
+      modernResultMetadata: 'discovery-only',
+      statelessRequests: 'compatibility-only',
       statefulStreamableHttp: 'supported',
     },
     capabilities: {
       tasks: 'unsupported',
       polling: 'unsupported',
-      listCache: 'supported',
+      subscriptions: 'unsupported',
+      listCache: 'unsupported',
       explicitProjectHandle: 'supported',
     },
   };

package/src/server.ts

@@ -62,6 +62,7 @@ import {
   type ProjectBindingController,
   type ProjectBindingSource,
 } from './server/request-context.js';
+import { registerMcpDiscovery } from './server/mcp-compat.js';
 
 // ── Timeout budgets for LLM-heavy paths ──────────────────────────
 const FORMATION_TIMEOUT_MS = parseFormationTimeoutMs(process.env.MEMORIX_FORMATION_TIMEOUT_MS); // Formation pipeline (extract+resolve+evaluate)
@@ -198,7 +199,7 @@ function createDeterministicInstanceId(projectId: string, agentType: string, age
  * Create and configure the Memorix MCP Server.
  */
 /** Optional shared TeamStore — passed by serve-http so all sessions share state */
-export interface SharedTeamInstances {
+export interface SharedTeamStore {
   teamStore: import('./team/team-store.js').TeamStore;
 }
 
@@ -245,7 +246,7 @@ export function shouldAwaitProjectRuntime(toolName: string): boolean {
 export async function createMemorixServer(
   cwd?: string,
   existingServer?: McpServer,
-  sharedTeam?: SharedTeamInstances,
+  sharedTeam?: SharedTeamStore,
   options: CreateMemorixServerOptions = {},
 ): Promise<{
   server: McpServer;
@@ -593,10 +594,12 @@ export async function createMemorixServer(
   };
 
   // Create MCP server (or use existing one from roots-aware flow)
-  const server = existingServer ?? new McpServer({
+  const serverInfo = {
     name: 'memorix',
     version: typeof __MEMORIX_VERSION__ !== 'undefined' ? __MEMORIX_VERSION__ : '1.0.1',
-  });
+  };
+  const server = existingServer ?? new McpServer(serverInfo);
+  registerMcpDiscovery(server, serverInfo);
 
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name: string, ...args: unknown[]) => {
@@ -4420,7 +4423,7 @@ export async function createMemorixServer(
         console.error(`[memorix] Dashboard staticDir: ${staticDir}`);
 
         // Start in background (non-blocking), disable auto-open (we'll open it ourselves)
-        startDashboard(projectDir, portNum, staticDir, project.id, project.name, false, undefined, project.rootPath, projectResolved)
+        startDashboard(projectDir, portNum, staticDir, project.id, project.name, false, project.rootPath, projectResolved)
           .then(() => { dashboardRunning = true; })
           .catch((err) => { console.error('[memorix] Dashboard error:', err); dashboardRunning = false; });
 
@@ -4786,7 +4789,7 @@ export async function createMemorixServer(
   server.registerTool(
     'team_task',
     {
-      title: 'Task Board',
+      title: 'Task Status',
       description:
         'Create, claim, complete, or list tasks in the team task board. Supports dependencies. ' +
         'Action "create": create a task. Action "claim": assign to yourself (atomic, race-safe). ' +