enigma-memory 0.1.18 → 0.1.22

package/apps/desktop/electron-main.cjs

@@ -0,0 +1,217 @@
+// Enigma Sovereign Terminal — Dedicated Electron Desktop Application Window
+// Owns the dynamic localhost server and the enigma:// private-session protocol.
+
+const { app, BrowserWindow, shell, safeStorage } = require('electron');
+const path = require('node:path');
+const { pathToFileURL } = require('node:url');
+
+const PROTOCOL_SCHEME = 'enigma';
+const TEST_MODE = process.env.ENIGMA_ELECTRON_HANDOFF_TEST === '1';
+const HANDOFF_MODULE_URL = pathToFileURL(
+  path.join(__dirname, '..', '..', 'packages', 'mcp-server', 'src', 'private-handoff.js')
+).href;
+
+let mainWindow = null;
+let desktopServerInstance = null;
+let desktopServerInfo = null;
+let pendingHandoffUrl = process.env.ENIGMA_ELECTRON_HANDOFF_TEST_URL || findHandoffArgument(process.argv);
+let protocolRegistered = false;
+
+function findHandoffArgument(argv) {
+  return Array.isArray(argv)
+    ? argv.find((value) => typeof value === 'string' && value.toLowerCase().startsWith('enigma://private')) || null
+    : null;
+}
+
+function registerPrivateProtocol() {
+  if (process.defaultApp && process.argv[1]) {
+    protocolRegistered = app.setAsDefaultProtocolClient(
+      PROTOCOL_SCHEME,
+      process.execPath,
+      [path.resolve(process.argv[1])]
+    );
+  } else {
+    protocolRegistered = app.setAsDefaultProtocolClient(PROTOCOL_SCHEME);
+  }
+}
+
+async function closeDesktopServer() {
+  const instance = desktopServerInstance;
+  desktopServerInstance = null;
+  desktopServerInfo = null;
+  if (instance) await instance.close();
+}
+
+async function workspaceUrlForHandoff(protocolUrl) {
+  if (!desktopServerInfo) throw new Error('Enigma desktop server is not ready.');
+  const { createWorkspaceUrlFromProtocol } = await import(HANDOFF_MODULE_URL);
+  return createWorkspaceUrlFromProtocol(protocolUrl, desktopServerInfo.url);
+}
+
+async function openPrivateHandoff(protocolUrl) {
+  if (!protocolUrl) return;
+  pendingHandoffUrl = protocolUrl;
+  if (!app.isReady()) return;
+  if (!mainWindow || mainWindow.isDestroyed() || !desktopServerInfo) {
+    await createMainWindow();
+    return;
+  }
+  const target = await workspaceUrlForHandoff(protocolUrl);
+  pendingHandoffUrl = null;
+  await mainWindow.loadURL(target);
+  if (mainWindow.isMinimized()) mainWindow.restore();
+  mainWindow.show();
+  mainWindow.focus();
+}
+
+async function verifyElectronHandoff() {
+  const state = await mainWindow.webContents.executeJavaScript(`
+    new Promise((resolve, reject) => {
+      const startedAt = Date.now();
+      const inspect = () => {
+        const route = document.querySelector('#workspaceRouteSelect');
+        const active = document.querySelector('.workspace-view.active');
+        if (active?.dataset.workspaceView === 'chat' && route && !route.disabled && route.value) {
+          resolve({
+            href: location.href,
+            activeTab: document.querySelector('.nav-tab-btn.active')?.id || null,
+            activeView: active.dataset.workspaceView,
+            selectedRoute: route.selectedOptions[0]?.textContent || null,
+            externalScripts: Array.from(document.scripts).map((script) => script.src).filter(Boolean),
+            sessionStorageEntries: sessionStorage.length
+          });
+          return;
+        }
+        if (Date.now() - startedAt > 8000) {
+          reject(new Error('Workspace route did not become ready.'));
+          return;
+        }
+        setTimeout(inspect, 50);
+      };
+      inspect();
+    })
+  `);
+  console.log('ENIGMA_ELECTRON_HANDOFF ' + JSON.stringify({
+    ...state,
+    dynamicPort: desktopServerInfo.port,
+    protocolRegistered,
+  }));
+  await closeDesktopServer();
+  if (mainWindow && !mainWindow.isDestroyed()) mainWindow.destroy();
+  app.exit(0);
+}
+
+async function createMainWindow() {
+  if (mainWindow && !mainWindow.isDestroyed()) return mainWindow;
+  const { createDesktopServer } = await import('./src/server.mjs');
+  const defaultUserDataBundle = process.env.ENIGMA_BUNDLE_PATH
+    || path.join(app.getPath('userData'), 'vault', 'bundle.json');
+
+  let serverOptions;
+  if (TEST_MODE) {
+    serverOptions = {
+      port: 0,
+      inMemoryOnly: true,
+      modelAdapters: [{
+        id: 'electron-handoff-fixture',
+        provider: 'Enigma Electron',
+        models: ['enigma-code'],
+        async invoke(input) {
+          return { text: `Electron handoff fixture: ${input.prompt}` };
+        },
+      }],
+    };
+  } else {
+    if (!safeStorage.isEncryptionAvailable()) {
+      throw new Error('OS secure storage unavailable; refusing to start with weak host-bound key custody.');
+    }
+    serverOptions = {
+      port: 0,
+      bundlePath: defaultUserDataBundle,
+      safeStorage,
+    };
+  }
+
+  desktopServerInstance = createDesktopServer(serverOptions);
+  desktopServerInfo = await desktopServerInstance.listen();
+  mainWindow = new BrowserWindow({
+    width: 1240,
+    height: 780,
+    minWidth: 900,
+    minHeight: 600,
+    show: !TEST_MODE,
+    backgroundColor: '#07090e',
+    title: 'Enigma Sovereign AI Memory Terminal',
+    autoHideMenuBar: true,
+    webPreferences: {
+      nodeIntegration: false,
+      contextIsolation: true,
+      sandbox: true,
+    },
+  });
+
+  mainWindow.webContents.setWindowOpenHandler(({ url }) => {
+    if (url.toLowerCase().startsWith('enigma://private')) {
+      openPrivateHandoff(url).catch(() => {});
+    } else {
+      shell.openExternal(url);
+    }
+    return { action: 'deny' };
+  });
+
+  const target = pendingHandoffUrl
+    ? await workspaceUrlForHandoff(pendingHandoffUrl)
+    : desktopServerInfo.url;
+  pendingHandoffUrl = null;
+  await mainWindow.loadURL(target);
+
+  mainWindow.on('closed', async () => {
+    mainWindow = null;
+    await closeDesktopServer();
+  });
+
+  if (TEST_MODE) await verifyElectronHandoff();
+  return mainWindow;
+}
+
+if (!TEST_MODE) registerPrivateProtocol();
+const hasSingleInstanceLock = app.requestSingleInstanceLock();
+if (!hasSingleInstanceLock) {
+  app.quit();
+} else {
+  app.on('second-instance', (_event, argv) => {
+    const handoffUrl = findHandoffArgument(argv);
+    if (handoffUrl) {
+      openPrivateHandoff(handoffUrl).catch(() => {});
+    } else if (mainWindow && !mainWindow.isDestroyed()) {
+      if (mainWindow.isMinimized()) mainWindow.restore();
+      mainWindow.show();
+      mainWindow.focus();
+    }
+  });
+
+  app.on('open-url', (event, url) => {
+    event.preventDefault();
+    if (typeof url === 'string' && url.toLowerCase().startsWith('enigma://private')) {
+      openPrivateHandoff(url).catch(() => {});
+    }
+  });
+
+  app.whenReady()
+    .then(() => createMainWindow())
+    .catch((error) => {
+      console.error(`Enigma desktop startup failed: ${error.message}`);
+      app.exit(1);
+    });
+
+  app.on('activate', () => {
+    if (BrowserWindow.getAllWindows().length === 0) {
+      createMainWindow().catch(() => {});
+    }
+  });
+}
+
+app.on('window-all-closed', async () => {
+  await closeDesktopServer();
+  if (process.platform !== 'darwin') app.quit();
+});

package/apps/desktop/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "enigma-desktop-app",
+  "version": "0.1.22",
+  "description": "Enigma Sovereign AI Memory Terminal Dedicated Desktop Application",
+  "type": "module",
+  "main": "electron-main.cjs",
+  "private": true,
+  "scripts": {
+    "start": "electron electron-main.cjs",
+    "build": "node src/launch-electron.mjs"
+  }
+}

package/apps/desktop/src/app.js

@@ -17,6 +17,7 @@ export const DESKTOP_SCREENS = Object.freeze([
 const CLIENT_TEMPLATES = Object.freeze([
   Object.freeze({ id: 'claude-desktop', name: 'Claude Desktop', kind: 'mcp-client' }),
   Object.freeze({ id: 'cursor', name: 'Cursor', kind: 'mcp-client' }),
+  Object.freeze({ id: 'kimi-k3', name: 'Kimi K3', kind: 'mcp-client' }),
   Object.freeze({ id: 'vscode', name: 'VS Code', kind: 'mcp-client' }),
   Object.freeze({ id: 'browser-bridge', name: 'Browser bridge', kind: 'extension' })
 ]);
@@ -76,6 +77,21 @@ export function createDesktopState(options = {}) {
     clients: [],
     memories: [],
     search: { query: '', results: [] },
+    agentTurn: {
+      status: 'idle',
+      adapters: [],
+      adapter_id: '',
+      provider: '',
+      model: '',
+      context_refs: [],
+      receipt_refs: [],
+      memory_id: '',
+      result_preview: '',
+      error_code: '',
+      error_message: '',
+      completed_at: '',
+      note: 'Agent turns execute only through an explicitly configured provider/model adapter.'
+    },
     verifier: {
       status: 'idle',
       evidence: [],
@@ -95,6 +111,17 @@ export function createDesktopState(options = {}) {
       peers: 0,
       relays: 0,
       last_witness_at: '',
+      federation: {
+        started: false,
+        scope: '',
+        destination_hex: '',
+        transport_id: '',
+        listen_port: null,
+        registered_peers: 0,
+        active_grants: 0,
+        pending_queries: 0,
+        persisted: false
+      },
       note: 'Mesh status is local telemetry until matched to witness receipts.'
     },
     enterprise: {
@@ -141,8 +168,18 @@ export function desktopReducer(state = createDesktopState(), action = {}) {
       return importBundleState(state, action);
     case 'bundle/export':
       return exportBundleState(state, action);
+    case 'agent/adapters':
+      return setAgentAdaptersState(state, action);
+    case 'agent/turn-started':
+      return startAgentTurnState(state, action);
+    case 'agent/turn-completed':
+      return completeAgentTurnState(state, action);
+    case 'agent/turn-failed':
+      return failAgentTurnState(state, action);
     case 'mesh/update':
       return updateMeshState(state, action);
+    case 'mesh/federation-update':
+      return updateFederationState(state, action);
     case 'enterprise/update':
       return updateEnterpriseState(state, action);
     case 'draft/set':
@@ -167,6 +204,7 @@ export function renderDesktopModel(state = createDesktopState()) {
       vault: state.vault.status,
       mcp: state.mcp.status,
       clients: connectedClients.length,
+      agentTurn: state.agentTurn.status,
       memories: activeMemories.length,
       deleted: deletedMemories.length,
       verifier: verifierOk ? 'shape-clean' : state.verifier.status,
@@ -187,6 +225,28 @@ export function renderDesktopModel(state = createDesktopState()) {
         ],
         memories: state.memories.map(renderMemoryRow)
       },
+      agentTurn: {
+        title: 'Operational agent turn',
+        status: state.agentTurn.status,
+        adapters: state.agentTurn.adapters.map((adapter) => ({
+          ...adapter,
+          models: adapter.models.slice()
+        })),
+        selection: {
+          adapter_id: state.agentTurn.adapter_id,
+          provider: state.agentTurn.provider,
+          model: state.agentTurn.model
+        },
+        context_refs: state.agentTurn.context_refs.map((ref) => ({ ...ref })),
+        receipt_refs: state.agentTurn.receipt_refs.map((ref) => ({ ...ref })),
+        memory_id: state.agentTurn.memory_id,
+        result_preview: state.agentTurn.result_preview,
+        error: state.agentTurn.error_code
+          ? { code: state.agentTurn.error_code, message: state.agentTurn.error_message }
+          : null,
+        completed_at: state.agentTurn.completed_at,
+        note: state.agentTurn.note
+      },
       mcp: {
         title: 'MCP server status',
         status: state.mcp.status,
@@ -230,6 +290,7 @@ export function renderDesktopModel(state = createDesktopState()) {
         peers: state.mesh.peers,
         relays: state.mesh.relays,
         last_witness_at: state.mesh.last_witness_at,
+        federation: { ...state.mesh.federation },
         note: state.mesh.note
       },
       enterprise: {
@@ -268,6 +329,22 @@ export function searchMemories(query, options = {}) {
   return { ...options, query, type: 'memory/search' };
 }
 
+export function setAgentAdapters(adapters = []) {
+  return { adapters, type: 'agent/adapters' };
+}
+
+export function startAgentTurn(selection = {}, options = {}) {
+  return { ...options, selection, type: 'agent/turn-started' };
+}
+
+export function completeAgentTurn(turn = {}, options = {}) {
+  return { ...options, turn, type: 'agent/turn-completed' };
+}
+
+export function failAgentTurn(error = {}, options = {}) {
+  return { ...options, error, type: 'agent/turn-failed' };
+}
+
 export function verifyReceipts(input = {}, options = {}) {
   return { ...options, input, type: 'receipts/verify' };
 }
@@ -292,6 +369,10 @@ export function updateMeshStatus(mesh = {}, options = {}) {
   return { ...options, mesh, type: 'mesh/update' };
 }
 
+export function updateFederationStatus(federation = {}, options = {}) {
+  return { ...options, federation, type: 'mesh/federation-update' };
+}
+
 export function updateEnterpriseStatus(enterprise = {}, options = {}) {
   return { ...options, enterprise, type: 'enterprise/update' };
 }
@@ -316,6 +397,10 @@ export const desktopActions = Object.freeze({
   removeMemory: deleteMemory,
   searchMemories,
   searchMemory: searchMemories,
+  setAgentAdapters,
+  startAgentTurn,
+  completeAgentTurn,
+  failAgentTurn,
   verifyReceipts,
   verifyReceiptOutput: verifyReceipts,
   connectClient,
@@ -326,6 +411,7 @@ export const desktopActions = Object.freeze({
   exportBundle,
   exportDesktopBundle: exportBundle,
   updateMeshStatus,
+  updateFederationStatus,
   updateEnterpriseStatus,
   selectDesktopScreen,
   setDesktopDraft
@@ -360,6 +446,10 @@ export const desktopApi = Object.freeze({
   removeMemory,
   searchMemories,
   searchMemory,
+  setAgentAdapters,
+  startAgentTurn,
+  completeAgentTurn,
+  failAgentTurn,
   verifyReceipts,
   verifyReceiptOutput,
   connectClient,
@@ -368,7 +458,10 @@ export const desktopApi = Object.freeze({
   importBundle,
   importDesktopBundle,
   exportBundle,
-  exportDesktopBundle
+  exportDesktopBundle,
+  updateMeshStatus,
+  updateFederationStatus,
+  updateEnterpriseStatus
 });
 
 if (typeof globalThis !== 'undefined') {
@@ -605,6 +698,7 @@ function importBundleState(state, action) {
       evidence: state.verifier.evidence.concat(importedVerifierEvidence),
       errors: state.verifier.errors.concat(importedVerifierEvidence.flatMap((item) => item.errors.map((error) => `${item.receipt_id || `receipt[${item.index}]`}: ${error}`)))
     } : state.verifier,
+
     importExport: { ...state.importExport, import_status: 'imported', import_errors: [] },
     vault: {
       ...state.vault,
@@ -616,6 +710,136 @@ function importBundleState(state, action) {
     }
   });
 }
+function setAgentAdaptersState(state, action) {
+  const adapters = Array.isArray(action.adapters)
+    ? action.adapters
+      .map((adapter) => ({
+        id: cleanString(adapter?.id),
+        provider: cleanString(adapter?.provider),
+        models: normalizeStringList(adapter?.models)
+      }))
+      .filter((adapter) => adapter.id && adapter.provider && adapter.models.length > 0)
+    : [];
+  return bump({
+    ...state,
+    agentTurn: {
+      ...state.agentTurn,
+      adapters
+    },
+    notice: adapters.length > 0
+      ? `${adapters.length} configured model adapter${adapters.length === 1 ? '' : 's'} available.`
+      : 'No provider/model adapter is configured; agent turns fail closed.'
+  });
+}
+
+function startAgentTurnState(state, action) {
+  const selection = action.selection && typeof action.selection === 'object'
+    ? action.selection
+    : {};
+  return bump({
+    ...state,
+    activeScreen: 'vault',
+    agentTurn: {
+      ...state.agentTurn,
+      status: 'running',
+      adapter_id: cleanString(selection.adapterId ?? selection.adapter_id),
+      provider: cleanString(selection.provider),
+      model: cleanString(selection.model),
+      context_refs: [],
+      receipt_refs: [],
+      memory_id: '',
+      result_preview: '',
+      error_code: '',
+      error_message: '',
+      completed_at: ''
+    },
+    notice: 'Executing authenticated retrieval → provider invocation → encrypted persistence.'
+  });
+}
+
+function completeAgentTurnState(state, action) {
+  const turn = action.turn && typeof action.turn === 'object' ? action.turn : {};
+  const adapter = turn.adapter && typeof turn.adapter === 'object' ? turn.adapter : {};
+  const contextRefs = Array.isArray(turn.context?.refs)
+    ? turn.context.refs.map((ref) => ({ ...ref }))
+    : [];
+  const receiptRefs = Array.isArray(turn.receiptRefs)
+    ? turn.receiptRefs.map((ref) => ({ ...ref }))
+    : [];
+  const completedAt = cleanString(action.now) || INITIAL_NOW;
+  return bump({
+    ...state,
+    activeScreen: 'vault',
+    agentTurn: {
+      ...state.agentTurn,
+      status: 'completed',
+      adapter_id: cleanString(adapter.id) || state.agentTurn.adapter_id,
+      provider: cleanString(adapter.provider) || state.agentTurn.provider,
+      model: cleanString(adapter.model) || state.agentTurn.model,
+      context_refs: contextRefs,
+      receipt_refs: receiptRefs,
+      memory_id: cleanString(turn.memory?.id),
+      result_preview: clamp(modelResultText(turn.result), 240),
+      error_code: '',
+      error_message: '',
+      completed_at: completedAt
+    },
+    notice: `Agent turn completed with ${contextRefs.length} context ref${contextRefs.length === 1 ? '' : 's'} and ${receiptRefs.length} receipt ref${receiptRefs.length === 1 ? '' : 's'}.`
+  });
+}
+
+function failAgentTurnState(state, action) {
+  const error = action.error && typeof action.error === 'object' ? action.error : {};
+  return bump({
+    ...state,
+    activeScreen: 'vault',
+    agentTurn: {
+      ...state.agentTurn,
+      status: 'failed',
+      error_code: cleanString(error.code) || 'AGENT_TURN_FAILED',
+      error_message: cleanString(error.message) || 'Agent turn failed',
+      completed_at: cleanString(action.now) || INITIAL_NOW
+    },
+    notice: cleanString(error.message) || 'Agent turn failed closed.'
+  });
+}
+
+function updateFederationState(state, action) {
+  const federation = action.federation && typeof action.federation === 'object'
+    ? action.federation
+    : {};
+  const endpoint = federation.endpoint && typeof federation.endpoint === 'object'
+    ? federation.endpoint
+    : {};
+  const transport = federation.transport && typeof federation.transport === 'object'
+    ? federation.transport
+    : {};
+  return bump({
+    ...state,
+    activeScreen: 'mesh',
+    mesh: {
+      ...state.mesh,
+      federation: {
+        started: federation.started === true,
+        scope: cleanString(federation.scope),
+        destination_hex: cleanString(endpoint.destinationHex),
+        transport_id: cleanString(transport.id),
+        listen_port: normalizePort(transport.listenPort),
+        registered_peers: Array.isArray(federation.registeredPeers)
+          ? federation.registeredPeers.length
+          : 0,
+        active_grants: Array.isArray(federation.activeGrantIds)
+          ? federation.activeGrantIds.length
+          : 0,
+        pending_queries: normalizeNonNegativeInteger(federation.pendingQueries, 0),
+        persisted: federation.persisted === true
+      }
+    },
+    notice: federation.started === true
+      ? 'Encrypted, signed GhostMesh federation bridge is running.'
+      : 'GhostMesh federation bridge is configured but stopped.'
+  });
+}
 
 function exportBundleState(state, action) {
   const now = cleanString(action.now) || INITIAL_NOW;
@@ -1012,6 +1236,21 @@ function screenLabel(screen) {
     case 'enterprise': return 'Enterprise';
     default: return screen;
   }
+
+}
+function modelResultText(result) {
+  if (typeof result === 'string') return result;
+  if (!result || typeof result !== 'object') return '';
+  for (const key of ['text', 'outputText', 'output_text', 'content']) {
+    if (typeof result[key] === 'string') return result[key];
+  }
+  if (Array.isArray(result.content)) {
+    return result.content
+      .map((part) => typeof part === 'string' ? part : part?.text)
+      .filter((part) => typeof part === 'string')
+      .join('');
+  }
+  return '';
 }
 
 function cleanString(value) {
@@ -1102,13 +1341,14 @@ function renderHtml(model, state) {
         ${renderMetric('MCP', model.summary.mcp)}
         ${renderMetric('Clients', model.summary.clients)}
         ${renderMetric('Receipt inspector', model.summary.verifier)}
+        ${renderMetric('Agent turn', model.summary.agentTurn)}
       </dl>
     </header>
     <nav class="screen-nav" aria-label="Desktop screens">
       ${model.navigation.map((item) => `<button class="screen-tab${item.active ? ' is-active' : ''}" type="button" data-screen="${escapeHtml(item.id)}">${escapeHtml(item.label)}</button>`).join('')}
     </nav>
     <main>
-      ${renderVaultScreen(model.screens.vault, state)}
+      ${renderVaultScreen(model.screens.vault, model.screens.agentTurn, state)}
       ${renderMcpScreen(model.screens.mcp)}
       ${renderClientsScreen(model.screens.clients)}
       ${renderImportExportScreen(model.screens.importExport, state)}
@@ -1127,13 +1367,19 @@ function renderScreen(id, title, body) {
   return `<section class="screen-card" id="screen-${escapeHtml(id)}"><div class="screen-heading"><p>${escapeHtml(screenLabel(id))}</p><h2>${escapeHtml(title)}</h2></div>${body}</section>`;
 }
 
-function renderVaultScreen(screen, state) {
+function renderVaultScreen(screen, agentTurn, state) {
   const memories = screen.memories.length ? screen.memories.map((memory) => `
     <li class="memory-row${memory.deleted ? ' is-deleted' : ''}">
       <div><strong>${escapeHtml(memory.descriptor)}</strong><span>${escapeHtml(memory.address)}</span></div>
       <code>${escapeHtml(memory.body_fingerprint)}</code>
       <button type="button" data-delete-memory="${escapeHtml(memory.address)}" ${memory.deleted ? 'disabled' : ''}>Delete + prove</button>
     </li>`).join('') : '<li class="empty-row">No memory descriptors yet.</li>';
+  const contextRefs = agentTurn.context_refs.length
+    ? escapeHtml(JSON.stringify(agentTurn.context_refs, null, 2))
+    : 'No context refs observed.';
+  const receiptRefs = agentTurn.receipt_refs.length
+    ? escapeHtml(JSON.stringify(agentTurn.receipt_refs, null, 2))
+    : 'No receipt refs observed.';
 
   return renderScreen('vault', screen.title, `
     <div class="two-column">
@@ -1155,6 +1401,19 @@ function renderVaultScreen(screen, state) {
         <button type="submit">Remember descriptor</button>
       </form>
     </div>
+    <div class="panel status-panel">
+      <span class="status-pill">${escapeHtml(agentTurn.status)}</span>
+      <h3>${escapeHtml(agentTurn.title)}</h3>
+      <p>${escapeHtml(agentTurn.note)}</p>
+      <dl class="detail-list">
+        ${renderMetric('Adapter', agentTurn.selection.adapter_id || 'not configured')}
+        ${renderMetric('Provider', agentTurn.selection.provider || 'not configured')}
+        ${renderMetric('Model', agentTurn.selection.model || 'not configured')}
+        ${renderMetric('Persisted memory', agentTurn.memory_id || 'not observed')}
+      </dl>
+      <h4>Context refs</h4><pre>${contextRefs}</pre>
+      <h4>Receipt refs</h4><pre>${receiptRefs}</pre>
+    </div>
     <form class="inline-form" data-form="search">
       <label>Search descriptors <input name="query" value="${escapeHtml(state.search.query)}" placeholder="tag, address, fingerprint"></label>
       <button type="submit">Search</button>
@@ -1224,7 +1483,8 @@ function renderDeleteProveScreen(screen) {
 }
 
 function renderMeshScreen(screen) {
-  return renderScreen('mesh', screen.title, `<div class="panel status-panel"><span class="status-pill">${escapeHtml(screen.status)}</span><p>${escapeHtml(screen.note)}</p><dl class="detail-list">${renderMetric('Peers', screen.peers)}${renderMetric('Relays', screen.relays)}${renderMetric('Last witness', screen.last_witness_at || 'not observed')}</dl><button type="button" data-action="mesh-online">Mark local mesh online</button></div>`);
+  const federation = screen.federation;
+  return renderScreen('mesh', screen.title, `<div class="panel status-panel"><span class="status-pill">${escapeHtml(screen.status)}</span><p>${escapeHtml(screen.note)}</p><dl class="detail-list">${renderMetric('Peers', screen.peers)}${renderMetric('Relays', screen.relays)}${renderMetric('Last witness', screen.last_witness_at || 'not observed')}${renderMetric('Federation bridge', federation.started ? 'running' : 'stopped')}${renderMetric('Federation scope', federation.scope || 'not initialized')}${renderMetric('Local bridge port', federation.listen_port || 'not listening')}${renderMetric('Registered federation peers', federation.registered_peers)}${renderMetric('Active grants', federation.active_grants)}${renderMetric('Pending queries', federation.pending_queries)}${renderMetric('Encrypted state', federation.persisted ? 'persistent' : 'ephemeral')}</dl></div>`);
 }
 
 function renderEnterpriseScreen(screen) {
@@ -1249,9 +1509,6 @@ function wireDesktopEvents(root, state, dispatch) {
         case 'stop-mcp':
           dispatch(stopMcp({ now }));
           break;
-        case 'mesh-online':
-          dispatch(updateMeshStatus({ status: 'online', peers: 3, relays: 1, last_witness_at: now }, { now }));
-          break;
         case 'enterprise-demo':
           dispatch(updateEnterpriseStatus({ status: 'configured', tenant_id: 'tenant_local', policy_id: 'policy_desktop', siem: 'ready' }, { now }));
           break;