@brunobracaioli/aibrain 0.4.0-beta.4 → 0.4.0-beta.6

package/README.md

@@ -40,6 +40,15 @@ Licensed `aisac claude` sessions also load guardrail hooks as the session plugin
 - **Code:** it ships in this package and runs locally. Nothing comes from the
   server.
 
+Licensed sessions of `aisac claude` and `aisac codex` can also load reviewed MCP
+servers: `github` (read-only, token in `GITHUB_PERSONAL_ACCESS_TOKEN`), `supabase`
+(read-only), `vercel`, `playwright` (pinned, isolated) and `context7`.
+- **Default:** every server is off. `aisac mcp` lists them, `aisac mcp enable|disable
+  <id>` or `aisac mcp reset` changes the next session, and `aisac mcp info <id>` says
+  what a server reaches and how to log in.
+- **Login:** the host does it (`/mcp` in Claude Code, `aisac mcp login <id>` for Codex)
+  and keeps it in its own store. No token reaches `~/.aibrain` or AISAC.
+
 Codex capture also requires the `flock` utility from `util-linux`, normally
 included in Linux/WSL. The launcher and doctor check availability before a
 monitored Codex session starts. Capture coordination is released by the kernel

package/dist/claude-observation.mjs

@@ -16,7 +16,7 @@ export const MAX_LOG_FILES = 3;
 const LOCK_WAIT_MS = 250;
 const LOCK_STALE_MS = 30_000;
 const ADMISSION_MS = 60 * 60 * 1000;
-export const ADAPTER_VERSION = '0.4.0-beta.4';
+export const ADAPTER_VERSION = '0.4.0-beta.6';
 const MAX_DIAGNOSTIC_COUNT = 10_000_000;
 const MAX_DIAGNOSTIC_BYTES = 128 * 1024 * 1024;
 const CHECKPOINT_BACKENDS = new Set(['native_store', 'private_file']);

package/dist/cli.mjs

@@ -36,10 +36,11 @@ import {
   resolvePackLocale,
   writeStoredLocale,
 } from './engineering-pack.mjs';
-import { extensionsSummary, hooksCommand } from './extensions-cli.mjs';
+import { extensionsSummary, hooksCommand, mcpCommand } from './extensions-cli.mjs';
+import { sessionServers } from './mcp-servers.mjs';
 import { anyFormatter } from './guardrails/format.mjs';
 
-const VERSION = '0.4.0-beta.4';
+const VERSION = '0.4.0-beta.6';
 // The command is `aisac`; `aibrain` is an alias installed from the same entry.
 const COMMAND = 'aisac';
 const ENDPOINT = 'https://mcp.ai-brain.aisac.cloud/mcp';
@@ -62,6 +63,9 @@ function usage() {
   console.log(
     'Guardrails: `aisac hooks` lists them (a checklist on a terminal); `aisac hooks enable|disable <id>...` and `aisac hooks reset` change the next `aisac claude` session.',
   );
+  console.log(
+    'MCP catalog: `aisac mcp` lists the reviewed servers (GitHub, Supabase, Vercel, Playwright, Context7); `aisac mcp enable|disable <id>...`, `aisac mcp reset`, `aisac mcp info <id>` and `aisac mcp login <id>` (Codex) change or explain the next session.',
+  );
 }
 
 // Telemetry is opt-in; setup omits the flag to preserve the stored choice.
@@ -547,11 +551,16 @@ async function setup(args) {
 /** Extension state plus whether `format-on-edit` has a formatter in this folder (FR8). */
 async function doctorExtensions() {
   const summary = await extensionsSummary(stateRoot());
-  if (!summary.hooks.includes('format-on-edit')) return { ...summary, formatOnEdit: 'off' };
-  return {
-    ...summary,
-    formatOnEdit: (await anyFormatter(process.cwd())) ? 'ready' : 'no_formatter_found',
-  };
+  // A token server is skipped at launch when its variable is unset (names only).
+  const mcpMissingEnv = sessionServers(summary.mcp, 'claude', process.env).missingEnv.map(
+    (skipped) => skipped.id,
+  );
+  const formatOnEdit = !summary.hooks.includes('format-on-edit')
+    ? 'off'
+    : (await anyFormatter(process.cwd()))
+      ? 'ready'
+      : 'no_formatter_found';
+  return { ...summary, formatOnEdit, mcpMissingEnv };
 }
 
 /** @param {boolean} json */
@@ -735,6 +744,7 @@ async function main(argv) {
     return;
   }
   if (command === 'hooks') return hooksCommand(rest);
+  if (command === 'mcp') return mcpCommand(rest);
   if (command === 'disable') {
     if (rest.length > 0) throw new Error('disable_does_not_accept_options');
     return removeOwnedSetup();

package/dist/extensions-catalog.mjs

@@ -1,9 +1,10 @@
 // @ts-check
 /**
  * The AISAC Engineering extension catalog (spec aisac-engineering-extensions,
- * FR1, FR2). It ships with the client and is the only source of hooks: the
- * server and the licensed pack can neither add nor change entries (ADR-0048).
- * The MCP catalog arrives in E6c.
+ * FR1, FR2, FR7). It ships with the client and is the only source of hooks
+ * and MCP servers: the server and the licensed pack can neither add nor change
+ * entries (ADR-0048). Every change to MCP_CATALOG repeats the FR7 review
+ * recorded in the spec, and CODEOWNERS covers this file.
  */
 
 /** @typedef {'pt-BR' | 'en'} CatalogLocale */
@@ -138,3 +139,161 @@ export function hookById(id) {
 export function hookIds() {
   return HOOK_CATALOG.map((entry) => entry.id);
 }
+
+/**
+ * @typedef {object} McpHttpTransport
+ * @property {'http'} type
+ * @property {string} url Exact URL. Hosts key a stored login by server name and URL.
+ * @property {string} [bearerEnv] Environment variable that holds a bearer token. The
+ *   catalog names it; its value is never stored or read by AISAC.
+ */
+/**
+ * @typedef {object} McpStdioTransport
+ * @property {'stdio'} type
+ * @property {'npx'} command
+ * @property {readonly string[]} args Pinned to an exact package version (FR7).
+ */
+/** @typedef {'host-oauth' | 'optional-oauth' | 'env-token' | 'none'} McpLogin */
+/**
+ * @typedef {object} McpEntry
+ * @property {string} id
+ * @property {false} defaultOn Every catalog server starts off (FR7).
+ * @property {readonly ('claude' | 'codex')[]} clients
+ * @property {string} publisher
+ * @property {string} source The vendor's repository or documentation.
+ * @property {McpHttpTransport | McpStdioTransport} transport
+ * @property {McpLogin} login
+ * @property {string} [setup] A one-time command the user runs before the first use.
+ * @property {Readonly<Record<CatalogLocale, string>>} [loginNote] Why and how this login differs.
+ * @property {Readonly<Record<CatalogLocale, string>>} description
+ * @property {Readonly<Record<CatalogLocale, string>>} reaches What the server can reach (FR7).
+ */
+
+/** Session name of a catalog server, so it never collides with the user's own. */
+export const MCP_SERVER_PREFIX = 'aisac-';
+const PLAYWRIGHT_PACKAGE = '@playwright/mcp@0.0.83';
+
+/**
+ * MCP catalog v1 (spec FR7; the owner chose the list on 2026-11-03). The review of
+ * each entry (source, transport, login, tools, reach) is recorded in the spec.
+ * @type {readonly McpEntry[]}
+ */
+export const MCP_CATALOG = Object.freeze([
+  {
+    id: 'github',
+    defaultOn: false,
+    clients: ['claude', 'codex'],
+    publisher: 'GitHub',
+    source: 'https://github.com/github/github-mcp-server',
+    transport: {
+      type: 'http',
+      url: 'https://api.githubcopilot.com/mcp/readonly',
+      bearerEnv: 'GITHUB_PERSONAL_ACCESS_TOKEN',
+    },
+    login: 'env-token',
+    loginNote: {
+      en: 'GitHub offers no OAuth login for Claude Code or Codex, so this server takes a personal access token. Use a fine-grained token with read-only access to only the repositories you need, and an expiry date: in Claude Code the session’s shell commands can also read this variable.',
+      'pt-BR':
+        'O GitHub não oferece login OAuth para o Claude Code nem para o Codex, então este servidor usa um token de acesso pessoal. Use um token fine-grained, somente leitura, só nos repositórios de que você precisa e com data de validade: no Claude Code os comandos de shell da sessão também conseguem ler essa variável.',
+    },
+    description: {
+      en: "GitHub's hosted server, read-only: repositories, issues, pull requests and users.",
+      'pt-BR':
+        'Servidor hospedado do GitHub, somente leitura: repositórios, issues, pull requests e usuários.',
+    },
+    reaches: {
+      en: 'Reads what your token can see: repository files, commits, branches, releases, issues, pull requests, and user and team profiles. This read-only URL exposes no write tool.',
+      'pt-BR':
+        'Lê o que o seu token enxerga: arquivos, commits, branches e releases dos repositórios, issues, pull requests e perfis de usuários e times. Esta URL somente leitura não expõe ferramenta de escrita.',
+    },
+  },
+  {
+    id: 'supabase',
+    defaultOn: false,
+    clients: ['claude', 'codex'],
+    publisher: 'Supabase',
+    source: 'https://github.com/supabase-community/supabase-mcp',
+    transport: { type: 'http', url: 'https://mcp.supabase.com/mcp?read_only=true' },
+    login: 'host-oauth',
+    description: {
+      en: "Supabase's hosted server, read-only: tables, SQL, logs, advisors and docs.",
+      'pt-BR':
+        'Servidor hospedado da Supabase, somente leitura: tabelas, SQL, logs, advisors e documentação.',
+    },
+    reaches: {
+      en: 'Every organization and project of the Supabase account you log in with: database contents through read-only SQL, migrations, logs, advisors, Edge Functions, project URLs and publishable keys. read_only=true runs SQL as a read-only Postgres role and leaves out the write tools; the login grants the scopes you approve on Supabase.',
+      'pt-BR':
+        'Todas as organizações e projetos da conta Supabase em que você entrar: dados do banco por SQL somente leitura, migrations, logs, advisors, Edge Functions, URLs dos projetos e chaves publicáveis. read_only=true executa o SQL com um papel Postgres somente leitura e deixa de fora as ferramentas de escrita; o login concede os escopos que você aprovar na Supabase.',
+    },
+  },
+  {
+    id: 'vercel',
+    defaultOn: false,
+    clients: ['claude', 'codex'],
+    publisher: 'Vercel',
+    source: 'https://vercel.com/docs/agent-resources/vercel-mcp',
+    transport: { type: 'http', url: 'https://mcp.vercel.com' },
+    login: 'host-oauth',
+    description: {
+      en: "Vercel's hosted server: projects, deployments, logs, domains and environment variables.",
+      'pt-BR':
+        'Servidor hospedado da Vercel: projetos, deploys, logs, domínios e variáveis de ambiente.',
+    },
+    reaches: {
+      en: 'The teams you grant at login, with the access of your Vercel user: projects, deployments, build and runtime logs, domains and DNS, and environment variables, including decrypted values. It also has write tools (deploy, change settings, DNS records) and no read-only mode, so keep the confirmation of each call on.',
+      'pt-BR':
+        'Os times que você liberar no login, com o acesso do seu usuário Vercel: projetos, deploys, logs de build e de execução, domínios e DNS, e variáveis de ambiente, inclusive valores decifrados. Também tem ferramentas de escrita (deploy, configurações, registros DNS) e não tem modo somente leitura, então mantenha a confirmação de cada chamada ligada.',
+    },
+  },
+  {
+    id: 'playwright',
+    defaultOn: false,
+    clients: ['claude', 'codex'],
+    publisher: 'Microsoft',
+    source: 'https://github.com/microsoft/playwright-mcp',
+    transport: {
+      type: 'stdio',
+      command: 'npx',
+      args: ['-y', PLAYWRIGHT_PACKAGE, '--browser', 'chromium', '--headless', '--isolated'],
+    },
+    login: 'none',
+    setup: `npx -y ${PLAYWRIGHT_PACKAGE} install-browser chrome-for-testing`,
+    description: {
+      en: 'A local headless browser driven by Playwright, for testing web pages.',
+      'pt-BR': 'Um navegador local sem janela, controlado pelo Playwright, para testar páginas.',
+    },
+    reaches: {
+      en: 'Runs on your machine with a fresh in-memory profile each session, so no saved logins. It opens any URL the agent asks for, including localhost and your local network, can run JavaScript in the page and upload files from the project. Page content is untrusted input.',
+      'pt-BR':
+        'Roda na sua máquina com um perfil novo em memória a cada sessão, sem logins salvos. Abre qualquer URL que o agente pedir, inclusive localhost e a sua rede local, pode executar JavaScript na página e enviar arquivos do projeto. O conteúdo das páginas é entrada não confiável.',
+    },
+  },
+  {
+    id: 'context7',
+    defaultOn: false,
+    clients: ['claude', 'codex'],
+    publisher: 'Upstash',
+    source: 'https://github.com/upstash/context7',
+    transport: { type: 'http', url: 'https://mcp.context7.com/mcp' },
+    login: 'optional-oauth',
+    description: {
+      en: 'Up-to-date documentation and code examples for libraries, from Context7.',
+      'pt-BR': 'Documentação e exemplos de código atualizados de bibliotecas, do Context7.',
+    },
+    reaches: {
+      en: 'Public library documentation only. What the agent asks (library names and questions) goes to Upstash, so keep secrets and private code out of those questions. It works without login, with lower rate limits.',
+      'pt-BR':
+        'Só documentação pública de bibliotecas. O que o agente pergunta (nomes de bibliotecas e dúvidas) vai para a Upstash, então não coloque segredos nem código privado nessas perguntas. Funciona sem login, com limites de uso menores.',
+    },
+  },
+]);
+
+/** @param {string} id @returns {McpEntry | undefined} */
+export function mcpById(id) {
+  return MCP_CATALOG.find((entry) => entry.id === id);
+}
+
+/** @returns {string[]} */
+export function mcpIds() {
+  return MCP_CATALOG.map((entry) => entry.id);
+}

package/dist/extensions-cli.mjs

@@ -1,26 +1,105 @@
 // @ts-check
 /**
- * `aisac hooks` (spec aisac-engineering-extensions FR4): list, enable,
- * disable and reset guardrail hooks, offline. On a TTY without arguments it
- * opens a checklist. Choices apply to the next session; running sessions
- * keep their set.
+ * `aisac hooks` and `aisac mcp` (spec aisac-engineering-extensions FR4): list,
+ * enable, disable and reset catalog entries, offline. On a TTY without
+ * arguments each opens a checklist. `aisac mcp info` describes one server, and
+ * `aisac mcp login` runs Codex's own login for it. Choices apply to the next
+ * session; running sessions keep their set.
  */
+import { spawn } from 'node:child_process';
 import { emitKeypressEvents } from 'node:readline';
-import { HOOK_CATALOG, hookById, hookIds } from './extensions-catalog.mjs';
+import { hookById, hookIds, mcpById, mcpIds } from './extensions-catalog.mjs';
 import {
   readPreferences,
   resolveHooks,
+  resolveServers,
   unknownHookIds,
+  unknownServerIds,
   writePreferences,
 } from './extensions-preferences.mjs';
 import { readLastLaunch, readStoredLocale, resolvePackLocale } from './engineering-pack.mjs';
+import { codexLoginArgs, serverName, supportsHostLogin } from './mcp-servers.mjs';
+import { resolveNative } from './platform.mjs';
 import { stateRoot } from './state.mjs';
 
+/** @typedef {import('./extensions-catalog.mjs').CatalogLocale} CatalogLocale */
+/** @typedef {import('./extensions-catalog.mjs').McpEntry} McpEntry */
+/** @typedef {import('./extensions-preferences.mjs').ExtensionPreferences} ExtensionPreferences */
+/**
+ * @typedef {object} CatalogItem
+ * @property {{ id: string, description: Readonly<Record<CatalogLocale, string>> }} entry
+ * @property {boolean} enabled
+ * @property {'default' | 'choice'} source
+ */
+/**
+ * @typedef {object} ExtensionKind
+ * @property {'hooks' | 'mcp'} key The command name and the preferences key.
+ * @property {string} title
+ * @property {() => string[]} ids
+ * @property {(preferences: ExtensionPreferences) => CatalogItem[]} resolve
+ * @property {(preferences: ExtensionPreferences) => string[]} unknown
+ * @property {(id: string) => string} column The second column: hook mode or server login.
+ * @property {string} nextSession
+ */
+
 const USAGE_EXIT_CODE = 2;
-const ID_WIDTH = Math.max(...HOOK_CATALOG.map((entry) => entry.id.length));
-const NEXT_SESSION =
-  'Applies to the next `aisac claude` session; running sessions keep their current set.';
-const LICENSE_NOTE = 'Hooks load only with an active AISAC Engineering license.';
+const IO_EXIT_CODE = 1;
+const LICENSE_NOTE = 'Extensions load only with an active AISAC Engineering license.';
+const DEFAULT_COLUMNS = 80;
+const MIN_COLUMNS = 20;
+const ELLIPSIS = '…';
+/** @type {Readonly<Record<McpEntry['login'], string>>} */
+const LOGIN_LABEL = Object.freeze({
+  'host-oauth': 'oauth',
+  'optional-oauth': 'oauth-opt',
+  'env-token': 'env-token',
+  none: 'no-login',
+});
+
+/** @type {ExtensionKind} */
+const HOOKS = {
+  key: 'hooks',
+  title: 'AISAC Engineering hooks (Claude Code)',
+  ids: hookIds,
+  resolve: resolveHooks,
+  unknown: unknownHookIds,
+  column: (id) => hookById(id)?.mode ?? '',
+  nextSession:
+    'Applies to the next `aisac claude` session; running sessions keep their current set.',
+};
+
+/** @type {ExtensionKind} */
+const MCP = {
+  key: 'mcp',
+  title: 'AISAC Engineering MCP servers (Claude Code and Codex)',
+  ids: mcpIds,
+  resolve: resolveServers,
+  unknown: unknownServerIds,
+  column: (id) => {
+    const entry = mcpById(id);
+    return entry === undefined ? '' : LOGIN_LABEL[entry.login];
+  },
+  nextSession:
+    'Applies to the next `aisac claude` or `aisac codex` session; running sessions keep their current set.',
+};
+
+/**
+ * Cut a checklist row to the terminal width. The redraw moves the cursor up one
+ * row per item, which only holds while no row wraps; one column stays free so
+ * no terminal wraps at the last column either.
+ * @param {string} line
+ * @param {number | undefined} columns
+ */
+export function fitLine(line, columns) {
+  const total =
+    typeof columns === 'number' && Number.isInteger(columns) && columns > 0
+      ? columns
+      : DEFAULT_COLUMNS;
+  const width = Math.max(MIN_COLUMNS, total) - 1;
+  const characters = [...line];
+  if (characters.length <= width) return line;
+  return `${characters.slice(0, width - 1).join('')}${ELLIPSIS}`;
+}
 
 /**
  * @typedef {object} ChecklistState
@@ -50,13 +129,19 @@ export function checklistStep(state, key) {
   return { state, done: null };
 }
 
-/** @param {'pt-BR' | 'en'} locale @param {ReturnType<typeof resolveHooks>} hooks @param {ChecklistState} [state] */
-function renderLines(locale, hooks, state) {
-  return hooks.map((hook, index) => {
-    const enabled = state === undefined ? hook.enabled : state.enabled[index];
+/**
+ * @param {ExtensionKind} kind @param {CatalogLocale} locale
+ * @param {CatalogItem[]} items @param {ChecklistState} [state]
+ */
+function renderLines(kind, locale, items, state) {
+  const idWidth = Math.max(...items.map((item) => item.entry.id.length));
+  const columnWidth = Math.max(...items.map((item) => kind.column(item.entry.id).length)) + 1;
+  return items.map((item, index) => {
+    const enabled = state === undefined ? item.enabled : state.enabled[index];
     const pointer = state === undefined ? ' ' : index === state.cursor ? '>' : ' ';
-    const source = state === undefined ? ` ${hook.source.padEnd(7)}` : '';
-    return `${pointer} [${enabled ? 'x' : ' '}] ${hook.entry.id.padEnd(ID_WIDTH)}  ${hook.entry.mode.padEnd(8)}${source}  ${hook.entry.description[locale]}`;
+    const source = state === undefined ? ` ${item.source.padEnd(7)}` : '';
+    const column = kind.column(item.entry.id).padEnd(columnWidth);
+    return `${pointer} [${enabled ? 'x' : ' '}] ${item.entry.id.padEnd(idWidth)}  ${column}${source}  ${item.entry.description[locale]}`;
   });
 }
 
@@ -67,41 +152,42 @@ async function licensedLastLaunch(root) {
 }
 
 /**
- * Store explicit choices, keeping MCP choices as they are.
- * @param {Record<string, boolean>} hooks
+ * Store one kind's explicit choices, keeping the other kind's as they are.
+ * @param {ExtensionKind} kind @param {Record<string, boolean>} choices
  */
-async function saveHooks(hooks) {
+async function saveChoices(kind, choices) {
   const current = await readPreferences(stateRoot());
-  await writePreferences({ hooks, mcp: current.status === 'valid' ? current.mcp : {} });
+  const valid = current.status === 'valid';
+  await writePreferences({
+    hooks: kind.key === 'hooks' ? choices : valid ? current.hooks : {},
+    mcp: kind.key === 'mcp' ? choices : valid ? current.mcp : {},
+  });
   if (current.status === 'invalid')
     console.log('The previous extensions file was invalid and was replaced.');
 }
 
-/** @param {string[]} ids */
-function unknownIds(ids) {
-  return ids.filter((id) => hookById(id) === undefined);
-}
-
-/** @param {boolean} licensed */
-function afterChange(licensed) {
-  console.log(NEXT_SESSION);
+/** @param {ExtensionKind} kind @param {boolean} licensed */
+function afterChange(kind, licensed) {
+  console.log(kind.nextSession);
   if (!licensed) console.log(LICENSE_NOTE);
 }
 
 /**
  * Interactive checklist. Resolves to the new enabled flags, or null on cancel.
- * @param {'pt-BR' | 'en'} locale @param {ReturnType<typeof resolveHooks>} hooks
+ * @param {ExtensionKind} kind @param {CatalogLocale} locale @param {CatalogItem[]} items
  * @returns {Promise<boolean[] | null>}
  */
-function runChecklist(locale, hooks) {
+function runChecklist(kind, locale, items) {
   return new Promise((resolve) => {
-    let state = { cursor: 0, enabled: hooks.map((hook) => hook.enabled) };
-    const header = 'AISAC Engineering hooks: space toggles, enter saves, q cancels.';
+    let state = { cursor: 0, enabled: items.map((item) => item.enabled) };
     const draw = (/** @type {boolean} */ first) => {
-      if (!first) process.stdout.write(`\u001b[${hooks.length}A\u001b[J`);
-      process.stdout.write(`${renderLines(locale, hooks, state).join('\n')}\n`);
+      if (!first) process.stdout.write(`\u001b[${items.length}A\u001b[J`);
+      const rows = renderLines(kind, locale, items, state).map((line) =>
+        fitLine(line, process.stdout.columns),
+      );
+      process.stdout.write(`${rows.join('\n')}\n`);
     };
-    console.log(header);
+    console.log(`${kind.title}: up/down moves, space toggles, enter saves, q cancels.`);
     draw(true);
     emitKeypressEvents(process.stdin);
     process.stdin.setRawMode(true);
@@ -121,17 +207,171 @@ function runChecklist(locale, hooks) {
 }
 
 /**
- * `aisac hooks [list|enable|disable|reset] [ids...] [--json]`.
- * @param {string[]} args
+ * The JSON row of one item.
+ * @param {ExtensionKind} kind @param {CatalogLocale} locale @param {CatalogItem} item
+ */
+function jsonItem(kind, locale, item) {
+  const base = {
+    id: item.entry.id,
+    enabled: item.enabled,
+    source: item.source,
+    description: item.entry.description[locale],
+  };
+  if (kind.key === 'hooks') {
+    const hook = hookById(item.entry.id);
+    return { ...base, mode: hook?.mode, clients: hook?.clients };
+  }
+  const server = mcpById(item.entry.id);
+  return {
+    ...base,
+    server: serverName(item.entry.id),
+    login: server?.login,
+    transport: server?.transport.type === 'stdio' ? 'local' : 'remote',
+    clients: server?.clients,
+  };
+}
+
+/**
+ * What one server reaches and how to log in (FR4 `aisac mcp info`).
+ * @param {McpEntry} entry @param {CatalogLocale} locale @param {CatalogItem | undefined} item
+ */
+export function serverInfo(entry, locale, item) {
+  const name = serverName(entry.id);
+  const { transport } = entry;
+  const variable = transport.type === 'http' ? transport.bearerEnv : undefined;
+  /** @type {{ claude: string, codex: string }} */
+  const login =
+    entry.login === 'none'
+      ? { claude: 'No login.', codex: 'No login.' }
+      : variable !== undefined
+        ? {
+            claude: `Set ${variable} in the shell that runs aisac claude; without it the server is skipped.`,
+            codex: `Set ${variable} in the shell that runs aisac codex; without it the server is skipped.`,
+          }
+        : {
+            claude: `${entry.login === 'optional-oauth' ? 'Optional: ' : ''}in the session, /mcp, choose ${name}, then Authenticate.`,
+            codex: `${entry.login === 'optional-oauth' ? 'Optional: ' : ''}aisac mcp login ${entry.id} (runs Codex's own login with the session settings).`,
+          };
+  return {
+    id: entry.id,
+    server: name,
+    enabled: item?.enabled ?? false,
+    choice: item?.source ?? 'default',
+    publisher: entry.publisher,
+    sourceUrl: entry.source,
+    description: entry.description[locale],
+    transport:
+      transport.type === 'stdio'
+        ? {
+            type: 'local',
+            command: [transport.command, ...transport.args].join(' '),
+            note: 'Pinned to an exact package version; npx downloads it on first use.',
+          }
+        : {
+            type: 'remote',
+            url: transport.url,
+            note: 'Hosted by the vendor: its tools can change without a client release, so keep the confirmation of each call on.',
+          },
+    reaches: entry.reaches[locale],
+    login,
+    ...(variable === undefined ? {} : { tokenVariable: variable }),
+    ...(entry.loginNote === undefined ? {} : { loginNote: entry.loginNote[locale] }),
+    ...(entry.setup === undefined ? {} : { setup: entry.setup }),
+    credentials:
+      'Logins stay in the host’s own credential store (Claude Code or Codex). AISAC never sees them: no token goes to ~/.aibrain or to AISAC.',
+    duplicate: `If you already run your own server for this service, keep one of them (aisac mcp disable ${entry.id}, or remove yours).`,
+    trifecta:
+      'Private data (GitHub, Supabase, Vercel) plus untrusted content (web pages, issues) plus a way out in one session lets injected text reach your data: keep the confirmation of each call on.',
+  };
+}
+
+/** @param {ReturnType<typeof serverInfo>} info */
+function printInfo(info) {
+  console.log(`${info.server}: ${info.description}`);
+  console.log(`State: ${info.enabled ? 'on' : 'off'} (${info.choice})`);
+  console.log(`Publisher: ${info.publisher} (${info.sourceUrl})`);
+  const where = info.transport.type === 'local' ? info.transport.command : info.transport.url;
+  console.log(`Transport: ${info.transport.type}, ${where}. ${info.transport.note}`);
+  console.log(`Reaches: ${info.reaches}`);
+  if (info.loginNote !== undefined) console.log(`Login: ${info.loginNote}`);
+  console.log(`Log in from Claude Code: ${info.login.claude}`);
+  console.log(`Log in from Codex: ${info.login.codex}`);
+  if (info.setup !== undefined) console.log(`Before the first use, run once: ${info.setup}`);
+  console.log(info.credentials);
+  console.log(info.trifecta);
+  console.log(info.duplicate);
+}
+
+/**
+ * `aisac mcp login <id>`: Codex's own login, with the session's settings, so
+ * the next `aisac codex` session finds it. AISAC never sees the credential.
+ * @param {McpEntry} entry
+ */
+async function codexLogin(entry) {
+  const name = serverName(entry.id);
+  if (!supportsHostLogin(entry)) {
+    const variable = entry.transport.type === 'http' ? entry.transport.bearerEnv : undefined;
+    console.error(
+      variable === undefined
+        ? `aisac: ${name} needs no login.`
+        : `aisac: ${name} has no host login; set ${variable} instead (aisac mcp info ${entry.id}).`,
+    );
+    process.exitCode = USAGE_EXIT_CODE;
+    return;
+  }
+  const codex = resolveNative('codex');
+  if (codex === null) {
+    console.error('aisac: codex was not found on PATH.');
+    process.exitCode = IO_EXIT_CODE;
+    return;
+  }
+  console.log(
+    `Logging in to ${name} with Codex; the login stays in Codex's own store. Claude Code logs in inside the session: /mcp, choose ${name}, then Authenticate.`,
+  );
+  process.exitCode = await new Promise((resolve) => {
+    const child = spawn(codex, codexLoginArgs(entry), { stdio: 'inherit' });
+    child.on('error', () => resolve(IO_EXIT_CODE));
+    child.on('exit', (code) => resolve(code ?? IO_EXIT_CODE));
+  });
+}
+
+/**
+ * @param {ExtensionKind} kind @param {string[]} ids
+ * @returns {boolean} true when every id is in the catalog
+ */
+function checkIds(kind, ids) {
+  const known = new Set(kind.ids());
+  const unknown = ids.filter((id) => !known.has(id));
+  if (unknown.length === 0) return true;
+  const noun = kind.key === 'hooks' ? 'hook' : 'MCP server';
+  console.error(
+    `aisac: unknown ${noun} id: ${unknown.join(', ')}. Valid: ${kind.ids().join(', ')}.`,
+  );
+  process.exitCode = USAGE_EXIT_CODE;
+  return false;
+}
+
+/** @param {ExtensionKind} kind */
+function usage(kind) {
+  const extra = kind.key === 'mcp' ? ' | aisac mcp info <id> | aisac mcp login <id>' : '';
+  console.error(
+    `aisac: usage: aisac ${kind.key} [--json] | aisac ${kind.key} enable <id>... | aisac ${kind.key} disable <id>... | aisac ${kind.key} reset${extra}`,
+  );
+  process.exitCode = USAGE_EXIT_CODE;
+}
+
+/**
+ * `aisac hooks|mcp [list|enable|disable|reset|info|login] [ids...] [--json]`.
+ * @param {ExtensionKind} kind @param {string[]} args
  */
-export async function hooksCommand(args) {
+async function extensionCommand(kind, args) {
   const json = args.includes('--json');
   const words = args.filter((arg) => arg !== '--json');
   const [action = 'list', ...ids] = words;
   const root = stateRoot();
   const locale = resolvePackLocale(await readStoredLocale(root));
   const preferences = await readPreferences(root);
-  const hooks = resolveHooks(preferences);
+  const items = kind.resolve(preferences);
   const licensed = await licensedLastLaunch(root);
 
   if (action === 'list' && ids.length === 0) {
@@ -140,65 +380,79 @@ export async function hooksCommand(args) {
         JSON.stringify({
           preferences: preferences.status,
           licensedLastLaunch: licensed,
-          hooks: hooks.map((hook) => ({
-            id: hook.entry.id,
-            enabled: hook.enabled,
-            source: hook.source,
-            mode: hook.entry.mode,
-            clients: hook.entry.clients,
-            description: hook.entry.description[locale],
-          })),
-          unknown: unknownHookIds(preferences),
+          [kind.key === 'hooks' ? 'hooks' : 'servers']: items.map((item) =>
+            jsonItem(kind, locale, item),
+          ),
+          unknown: kind.unknown(preferences),
         }),
       );
       return;
     }
     if (args.length === 0 && process.stdin.isTTY && process.stdout.isTTY) {
-      const chosen = await runChecklist(locale, hooks);
+      const chosen = await runChecklist(kind, locale, items);
       if (chosen === null) return console.log('No change.');
       /** @type {Record<string, boolean>} */
-      const choices = preferences.status === 'valid' ? { ...preferences.hooks } : {};
-      hooks.forEach((hook, index) => {
-        if (chosen[index] !== hook.enabled) choices[hook.entry.id] = chosen[index] === true;
+      const choices = preferences.status === 'valid' ? { ...preferences[kind.key] } : {};
+      items.forEach((item, index) => {
+        if (chosen[index] !== item.enabled) choices[item.entry.id] = chosen[index] === true;
       });
-      await saveHooks(choices);
-      return afterChange(licensed);
+      await saveChoices(kind, choices);
+      return afterChange(kind, licensed);
     }
-    console.log('AISAC Engineering hooks (Claude Code):');
-    console.log(renderLines(locale, hooks).join('\n'));
+    console.log(`${kind.title}:`);
+    console.log(renderLines(kind, locale, items).join('\n'));
     if (preferences.status === 'invalid')
-      console.log('The extensions file is invalid: the defaults apply. Run `aisac hooks reset`.');
+      console.log(
+        `The extensions file is invalid: ${kind.key === 'hooks' ? 'the defaults apply' : 'every server is off'}. Run \`aisac ${kind.key} reset\`.`,
+      );
     console.log(
-      'Change with `aisac hooks enable <id>`, `aisac hooks disable <id>` or `aisac hooks reset`.',
+      `Change with \`aisac ${kind.key} enable <id>\`, \`aisac ${kind.key} disable <id>\` or \`aisac ${kind.key} reset\`.${kind.key === 'mcp' ? ' Details: `aisac mcp info <id>`.' : ''}`,
     );
     if (!licensed) console.log(LICENSE_NOTE);
     return;
   }
   if (action === 'reset' && ids.length === 0) {
-    await saveHooks({});
-    console.log('Hooks reset to the defaults.');
-    return afterChange(licensed);
+    await saveChoices(kind, {});
+    console.log(`${kind.key === 'hooks' ? 'Hooks' : 'MCP servers'} reset to the defaults.`);
+    return afterChange(kind, licensed);
   }
   if ((action === 'enable' || action === 'disable') && ids.length > 0) {
-    const unknown = unknownIds(ids);
-    if (unknown.length > 0) {
-      console.error(
-        `aisac: unknown hook id: ${unknown.join(', ')}. Valid: ${hookIds().join(', ')}.`,
-      );
-      process.exitCode = USAGE_EXIT_CODE;
-      return;
-    }
+    if (!checkIds(kind, ids)) return;
     /** @type {Record<string, boolean>} */
-    const choices = preferences.status === 'valid' ? { ...preferences.hooks } : {};
+    const choices = preferences.status === 'valid' ? { ...preferences[kind.key] } : {};
     for (const id of ids) choices[id] = action === 'enable';
-    await saveHooks(choices);
+    await saveChoices(kind, choices);
     console.log(`${action === 'enable' ? 'Enabled' : 'Disabled'}: ${ids.join(', ')}.`);
-    return afterChange(licensed);
+    return afterChange(kind, licensed);
   }
-  console.error(
-    'aisac: usage: aisac hooks [--json] | aisac hooks enable <id>... | aisac hooks disable <id>... | aisac hooks reset',
-  );
-  process.exitCode = USAGE_EXIT_CODE;
+  const [id] = ids;
+  if (kind.key === 'mcp' && action === 'info' && ids.length === 1 && id !== undefined) {
+    if (!checkIds(kind, ids)) return;
+    const entry = /** @type {McpEntry} */ (mcpById(id));
+    const info = serverInfo(
+      entry,
+      locale,
+      items.find((item) => item.entry.id === id),
+    );
+    if (json) console.log(JSON.stringify(info));
+    else printInfo(info);
+    return;
+  }
+  if (kind.key === 'mcp' && action === 'login' && ids.length === 1 && id !== undefined && !json) {
+    if (!checkIds(kind, ids)) return;
+    return codexLogin(/** @type {McpEntry} */ (mcpById(id)));
+  }
+  usage(kind);
+}
+
+/** @param {string[]} args */
+export function hooksCommand(args) {
+  return extensionCommand(HOOKS, args);
+}
+
+/** @param {string[]} args */
+export function mcpCommand(args) {
+  return extensionCommand(MCP, args);
 }
 
 /** Offline extension summary for `status` and `doctor`. @param {string} root */
@@ -209,6 +463,9 @@ export async function extensionsSummary(root) {
     hooks: resolveHooks(preferences)
       .filter((hook) => hook.enabled)
       .map((hook) => hook.entry.id),
-    unknown: unknownHookIds(preferences),
+    mcp: resolveServers(preferences)
+      .filter((server) => server.enabled)
+      .map((server) => server.entry.id),
+    unknown: [...unknownHookIds(preferences), ...unknownServerIds(preferences)],
   };
 }

package/dist/extensions-preferences.mjs

@@ -9,7 +9,7 @@
 import { lstat, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { atomicJson, ensureStateRoot } from './state.mjs';
-import { CATALOG_ID, HOOK_CATALOG, hookById } from './extensions-catalog.mjs';
+import { CATALOG_ID, HOOK_CATALOG, MCP_CATALOG, hookById, mcpById } from './extensions-catalog.mjs';
 
 export const EXTENSIONS_FILE = 'extensions.json';
 const SCHEMA_VERSION = 1;
@@ -120,3 +120,32 @@ export function enabledHookIds(preferences) {
 export function unknownHookIds(preferences) {
   return Object.keys(preferences.hooks).filter((id) => hookById(id) === undefined);
 }
+
+/**
+ * Each catalog MCP server with its effective state. Every server defaults to
+ * off, and an invalid file switches them all off (FR3).
+ * @param {ExtensionPreferences} preferences
+ */
+export function resolveServers(preferences) {
+  const chosen = preferences.status === 'valid' ? preferences.mcp : {};
+  return MCP_CATALOG.map((entry) => {
+    const choice = chosen[entry.id];
+    return {
+      entry,
+      enabled: choice ?? entry.defaultOn,
+      source: /** @type {'default' | 'choice'} */ (choice === undefined ? 'default' : 'choice'),
+    };
+  });
+}
+
+/** @param {ExtensionPreferences} preferences @returns {string[]} */
+export function enabledServerIds(preferences) {
+  return resolveServers(preferences)
+    .filter((server) => server.enabled)
+    .map((server) => server.entry.id);
+}
+
+/** Server ids stored in the file that this client's catalog does not know. @param {ExtensionPreferences} preferences */
+export function unknownServerIds(preferences) {
+  return Object.keys(preferences.mcp).filter((id) => mcpById(id) === undefined);
+}

package/dist/guardrails/guards.mjs

@@ -36,7 +36,7 @@ const MAX_NESTING = 2;
 const AISAC_PROGRAMS = new Set(['aisac', 'aibrain']);
 const AISAC_PACKAGE = /^@(?:aisac\/cli|brunobracaioli\/aibrain)(?:@\S*)?$/u;
 const EXTENSION_COMMANDS = new Set(['hooks', 'mcp']);
-const EXTENSION_CHANGES = new Set(['enable', 'disable', 'reset']);
+const EXTENSION_CHANGES = new Set(['enable', 'disable', 'reset', 'login']);
 const GIT_OPTIONS_WITH_VALUE = new Set(['-C', '-c', '--git-dir', '--work-tree', '--namespace']);
 const PROTECTED_BRANCHES = new Set(['main', 'master']);
 const GIT_TIMEOUT_MS = 2_000;

package/dist/launch.mjs

@@ -19,6 +19,8 @@ import {
   writeLaunchMarker,
 } from './engineering-pack.mjs';
 import { prepareGuardrails } from './guardrails-plugin.mjs';
+import { CODEX_MCP_ENV, claudeMcpEntries, mcpLaunchLines, sessionServers } from './mcp-servers.mjs';
+import { enabledServerIds, readPreferences } from './extensions-preferences.mjs';
 import {
   CODEX_ENGINEERING_ENV,
   CODEX_ENGINEERING_SKILLS_ROOT_ENV,
@@ -140,6 +142,7 @@ function childEnvironment(root) {
   delete environment[CODEX_MONITOR_CWD];
   delete environment[CODEX_ENGINEERING_ENV];
   delete environment[CODEX_ENGINEERING_SKILLS_ROOT_ENV];
+  delete environment[CODEX_MCP_ENV];
   environment.AIBRAIN_STATE_DIR = resolve(root);
   return environment;
 }
@@ -426,10 +429,22 @@ function waitForChild(child, directory) {
   });
 }
 
+/**
+ * The catalog servers that join this session: the user's enabled choices from
+ * the preferences file. Called only after the license was confirmed.
+ * @param {string} root
+ * @param {'claude' | 'codex'} client
+ * @param {NodeJS.ProcessEnv} environment
+ */
+export async function readSessionServers(root, client, environment) {
+  return sessionServers(enabledServerIds(await readPreferences(root)), client, environment);
+}
+
 /**
  * @typedef {object} LaunchDependencies
  * @property {typeof prepareEngineeringPack} [preparePack] AISAC Engineering pack loader (E4b)
  * @property {typeof prepareGuardrails} [prepareGuardrails] Guardrail hooks plugin writer (E6a)
+ * @property {typeof readSessionServers} [readSessionServers] MCP catalog servers to load (E6c)
  */
 
 /**
@@ -441,6 +456,7 @@ function waitForChild(child, directory) {
 export async function launchClaude(config, root, args, dependencies = {}) {
   const preparePack = dependencies.preparePack ?? prepareEngineeringPack;
   const writeGuardrails = dependencies.prepareGuardrails ?? prepareGuardrails;
+  const readServers = dependencies.readSessionServers ?? readSessionServers;
   const validated = assertConfig(config);
   const launchArgs = await parseClaudeLaunchArgs(args, process.cwd());
   assertClaudeArgs(launchArgs.args);
@@ -556,18 +572,8 @@ export async function launchClaude(config, root, args, dependencies = {}) {
       allow: mergedAllow,
     },
   };
-  const mcp = {
-    mcpServers: {
-      [MCP_ALIAS]: {
-        type: 'http',
-        url: validated.endpoint,
-        headers: { Authorization: `Bearer ${validated.token}` },
-      },
-    },
-  };
   try {
     await privateJson(settingsPath, settings);
-    await privateJson(mcpPath, mcp);
   } catch (error) {
     await rm(directory, { recursive: true, force: true });
     throw error;
@@ -590,6 +596,29 @@ export async function launchClaude(config, root, args, dependencies = {}) {
           () => null,
         );
   if (guardrails !== null) process.stderr.write(`${guardrails.line}\n`);
+  // Catalog servers need the same confirmed license, and never block the launch.
+  const servers =
+    engineering.pluginRoot === null
+      ? null
+      : await readServers(root, 'claude', process.env).catch(() => null);
+  for (const line of servers === null ? [] : mcpLaunchLines(servers, 'claude'))
+    process.stderr.write(`${line}\n`);
+  const mcp = {
+    mcpServers: {
+      ...(servers === null ? {} : claudeMcpEntries(servers.ready)),
+      [MCP_ALIAS]: {
+        type: 'http',
+        url: validated.endpoint,
+        headers: { Authorization: `Bearer ${validated.token}` },
+      },
+    },
+  };
+  try {
+    await privateJson(mcpPath, mcp);
+  } catch (error) {
+    await rm(directory, { recursive: true, force: true });
+    throw error;
+  }
   const environment = childEnvironment(root);
   environment.CLAUDE_CODE_ENABLE_FUNCTION_HOOKS = '1';
   /** @type {import('node:child_process').ChildProcess} */
@@ -630,6 +659,7 @@ export async function launchClaude(config, root, args, dependencies = {}) {
  */
 export async function launchCodex(config, root, args, dependencies = {}) {
   const preparePack = dependencies.preparePack ?? prepareEngineeringPack;
+  const readServers = dependencies.readSessionServers ?? readSessionServers;
   const validated = assertConfig(config);
   assertCodexArgs(args);
   const captureLockPlatform = captureLockPlatformCheck();
@@ -691,8 +721,15 @@ export async function launchCodex(config, root, args, dependencies = {}) {
     hostSupported: supportsCodexEngineering(compatibility.version),
   }).catch(() => ({ pluginRoot: null, codex: null, line: null }));
   if (engineering.line !== null) process.stderr.write(`${engineering.line}\n`);
-  if (engineering.codex != null)
+  if (engineering.codex != null) {
     environment[CODEX_ENGINEERING_ENV] = JSON.stringify(engineering.codex);
+    // Catalog servers need the license the pack confirmed (spec extensions FR6).
+    const servers = await readServers(root, 'codex', environment).catch(() => null);
+    for (const line of servers === null ? [] : mcpLaunchLines(servers, 'codex'))
+      process.stderr.write(`${line}\n`);
+    if (servers !== null && servers.ready.length > 0)
+      environment[CODEX_MCP_ENV] = JSON.stringify(servers.ready.map((entry) => entry.id));
+  }
   environment.AI_BRAIN_MCP_SERVER = MCP_ALIAS;
   environment.CODEX_BIN = executable;
   environment.CODEX_MONITOR_COMMAND = monitor;

package/dist/mcp-servers.mjs

@@ -0,0 +1,165 @@
+// @ts-check
+/**
+ * Session configuration for the MCP catalog (spec aisac-engineering-extensions
+ * FR5.6, FR6, FR7): entries for Claude Code's `--mcp-config` file, and
+ * `-c mcp_servers.*` flags for the app-server that `aisac codex` owns. Only
+ * catalog ids reach this module from outside; every URL, command and argument
+ * comes from the catalog in this package. AISAC never reads or stores a
+ * third-party credential: logins live in the host's own store, and a token
+ * variable is only named, never read here.
+ */
+import { MCP_SERVER_PREFIX, mcpById } from './extensions-catalog.mjs';
+import { tomlBasicString } from './codex-engineering.mjs';
+
+/** @typedef {import('./extensions-catalog.mjs').McpEntry} McpEntry */
+/** @typedef {'claude' | 'codex'} McpClient */
+/**
+ * @typedef {object} SessionServers
+ * @property {McpEntry[]} ready Servers that join the session.
+ * @property {{ id: string, variable: string }[]} missingEnv Skipped: the token variable is unset.
+ */
+
+/** The launcher hands the Codex monitor the ready ids in this variable. */
+export const CODEX_MCP_ENV = 'AISAC_EXTENSIONS_CODEX_MCP';
+const STDIO_STARTUP_TIMEOUT_SEC = 60;
+const MAX_IDS = 16;
+const MAX_IDS_BYTES = 1024;
+
+/** @param {string} id */
+export function serverName(id) {
+  return `${MCP_SERVER_PREFIX}${id}`;
+}
+
+/**
+ * Catalog entries for these ids that support the client. A token server whose
+ * variable is unset is skipped with a reason instead of failing in the host.
+ * @param {readonly string[]} ids
+ * @param {McpClient} client
+ * @param {NodeJS.ProcessEnv} environment
+ * @returns {SessionServers}
+ */
+export function sessionServers(ids, client, environment) {
+  /** @type {SessionServers} */
+  const result = { ready: [], missingEnv: [] };
+  for (const id of new Set(ids)) {
+    const entry = mcpById(id);
+    if (entry === undefined || !entry.clients.includes(client)) continue;
+    const variable = entry.transport.type === 'http' ? entry.transport.bearerEnv : undefined;
+    if (variable !== undefined && !environment[variable]?.trim()) {
+      result.missingEnv.push({ id, variable });
+      continue;
+    }
+    result.ready.push(entry);
+  }
+  return result;
+}
+
+/**
+ * `--mcp-config` entries. A token header uses Claude Code's `${VAR}` expansion,
+ * so the token never reaches the session file.
+ * @param {readonly McpEntry[]} entries
+ * @returns {Record<string, Record<string, unknown>>}
+ */
+export function claudeMcpEntries(entries) {
+  /** @type {Record<string, Record<string, unknown>>} */
+  const servers = {};
+  for (const entry of entries) {
+    const { transport } = entry;
+    servers[serverName(entry.id)] =
+      transport.type === 'stdio'
+        ? { type: 'stdio', command: transport.command, args: [...transport.args] }
+        : {
+            type: 'http',
+            url: transport.url,
+            ...(transport.bearerEnv === undefined
+              ? {}
+              : { headers: { Authorization: `Bearer \${${transport.bearerEnv}}` } }),
+          };
+  }
+  return servers;
+}
+
+/**
+ * Session-only `-c` overrides for the owned Codex app-server.
+ * @param {readonly McpEntry[]} entries
+ * @returns {string[]}
+ */
+export function codexMcpConfigArgs(entries) {
+  return entries.flatMap((entry) => {
+    const key = `mcp_servers.${serverName(entry.id)}`;
+    const { transport } = entry;
+    if (transport.type === 'stdio')
+      return [
+        '-c',
+        `${key}.command=${tomlBasicString(transport.command)}`,
+        '-c',
+        `${key}.args=[${transport.args.map(tomlBasicString).join(',')}]`,
+        '-c',
+        `${key}.startup_timeout_sec=${STDIO_STARTUP_TIMEOUT_SEC}`,
+      ];
+    return [
+      '-c',
+      `${key}.url=${tomlBasicString(transport.url)}`,
+      ...(transport.bearerEnv === undefined
+        ? []
+        : ['-c', `${key}.bearer_token_env_var=${tomlBasicString(transport.bearerEnv)}`]),
+    ];
+  });
+}
+
+/**
+ * The monitor's copy of the ready ids: a JSON array of catalog ids for Codex.
+ * Anything else throws, and the monitor then starts without catalog servers.
+ * @param {string | undefined} raw
+ * @returns {McpEntry[]}
+ */
+export function parseCodexMcp(raw) {
+  if (raw === undefined || raw === '') return [];
+  if (Buffer.byteLength(raw, 'utf8') > MAX_IDS_BYTES) throw new Error('codex_mcp_too_large');
+  const value = JSON.parse(raw);
+  if (!Array.isArray(value) || value.length > MAX_IDS) throw new Error('codex_mcp_invalid');
+  return value.map((id) => {
+    const entry = typeof id === 'string' ? mcpById(id) : undefined;
+    if (entry === undefined || !entry.clients.includes('codex'))
+      throw new Error('codex_mcp_invalid');
+    return entry;
+  });
+}
+
+/**
+ * Arguments for `codex` that log in to one catalog server with the same session
+ * flags `aisac codex` passes, so the next session finds the stored login.
+ * Spike Q5 (2026-11-03, Codex 0.164.0) measured this path end to end.
+ * @param {McpEntry} entry
+ */
+export function codexLoginArgs(entry) {
+  return [...codexMcpConfigArgs([entry]), 'mcp', 'login', serverName(entry.id)];
+}
+
+/** @param {McpEntry} entry */
+export function supportsHostLogin(entry) {
+  return entry.login === 'host-oauth' || entry.login === 'optional-oauth';
+}
+
+/**
+ * Launch lines: counts and names only, never a value.
+ * @param {SessionServers} servers
+ * @param {McpClient} client
+ * @returns {string[]}
+ */
+export function mcpLaunchLines(servers, client) {
+  /** @type {string[]} */
+  const lines = [];
+  const count = servers.ready.length;
+  if (count > 0) {
+    const login = client === 'claude' ? 'log in with /mcp' : 'log in with `aisac mcp login <id>`';
+    lines.push(
+      `AISAC Engineering: ${count} MCP server${count === 1 ? '' : 's'} on (${login}; aisac mcp to change them).`,
+    );
+  }
+  for (const skipped of servers.missingEnv)
+    lines.push(
+      `AISAC Engineering: ${serverName(skipped.id)} skipped: set ${skipped.variable} (aisac mcp info ${skipped.id}).`,
+    );
+  return lines;
+}

package/dist/monitor.mjs

@@ -18,6 +18,7 @@ import {
   codexEngineeringConfigArgs,
   parseCodexEngineering,
 } from './codex-engineering.mjs';
+import { CODEX_MCP_ENV, codexMcpConfigArgs, parseCodexMcp } from './mcp-servers.mjs';
 
 const root = dirname(fileURLToPath(import.meta.url));
 const endpoint = process.env.AIBRAIN_MCP_URL?.trim();
@@ -49,6 +50,15 @@ try {
 } catch {
   engineering = null;
 }
+// MCP catalog servers (E6c) follow the pack: no license, no servers. A malformed
+// value starts the session without them.
+/** @type {import('./mcp-servers.mjs').McpEntry[]} */
+let catalogServers = [];
+try {
+  catalogServers = engineering === null ? [] : parseCodexMcp(process.env[CODEX_MCP_ENV]);
+} catch {
+  catalogServers = [];
+}
 const policyText = process.env.CODEX_CONTEXT_POLICY_JSON;
 let policy;
 if (policyText === undefined) {
@@ -108,6 +118,7 @@ delete env[CODEX_LAUNCH_ENVELOPE];
 delete env[CODEX_APP_SERVER_PROFILE];
 delete env[CODEX_ENGINEERING_ENV];
 delete env[CODEX_ENGINEERING_SKILLS_ROOT_ENV];
+delete env[CODEX_MCP_ENV];
 if (engineering !== null) env[CODEX_ENGINEERING_SKILLS_ROOT_ENV] = engineering.skillsRoot;
 if (launchEnvelope?.profile !== undefined) env[CODEX_APP_SERVER_PROFILE] = launchEnvelope.profile;
 if (policy !== null) env.CODEX_CONTEXT_POLICY_JSON = JSON.stringify(policy);
@@ -130,6 +141,7 @@ const child = spawn(
     'mcp_servers.aibrain_context.bearer_token_env_var="CODEX_RECOVERY_MCP_TOKEN"',
     ...(launchEnvelope === null ? [] : ownedAppServerConfigArgs(launchEnvelope)),
     ...(engineering === null ? [] : codexEngineeringConfigArgs(engineering)),
+    ...codexMcpConfigArgs(catalogServers),
   ],
   { cwd: process.cwd(), env, stdio: 'inherit' },
 );

package/dist/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@brunobracaioli/aibrain",
-  "version": "0.4.0-beta.4",
+  "version": "0.4.0-beta.6",
   "type": "module"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brunobracaioli/aibrain",
-  "version": "0.4.0-beta.4",
+  "version": "0.4.0-beta.6",
   "private": false,
   "description": "AISAC client for Claude Code and Codex: AI Brain memory, context management and AISAC Engineering",
   "license": "UNLICENSED",