fathom-mcp 0.1.5 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.2.0 (2026-02-26)
+
+Multi-agent support.
+
+- **Multi-agent init wizard** — auto-detects installed agents and generates per-agent MCP configs
+- **Supported agents:** Claude Code, OpenAI Codex, Gemini CLI, Cursor, VS Code Copilot, Windsurf
+- **Per-agent config writers** — `.mcp.json`, `.codex/config.toml`, `.gemini/settings.json`, `.cursor/mcp.json`, `.vscode/mcp.json`, `~/.codeium/windsurf/mcp_config.json`
+- **Conditional hooks** — hook setup only for Claude Code (other agents don't support hooks)
+- **`agents` array** replaces legacy `architecture` string in `.fathom.json` — backward compatible
+- **Server-side agent dispatch** — persistent sessions launch the correct agent CLI per workspace
+- **Status command** — now shows configured agents per workspace
+
 ## 0.1.0 (2026-02-25)
 
 Initial release.

package/README.md

@@ -9,9 +9,20 @@
   hifathom.com  ·  fathom@myrakrusemark.com
 ```
 
-MCP server for [Fathom](https://hifathom.com) — vault operations, search, rooms, and cross-workspace communication.
+MCP server for [Fathom](https://hifathom.com) — vault operations, search, rooms, and cross-workspace communication. Works with any MCP-compatible agent.
 
-The MCP tools that let Claude Code interact with your vault. Reads/writes happen locally (fast, no network hop). Search, rooms, and workspace management go through your [fathom-server](https://github.com/myrakrusemark/fathom-vault) instance.
+## Supported Agents
+
+| Agent | Config file | Auto-detected by |
+|-------|------------|------------------|
+| **Claude Code** | `.mcp.json` | `.claude/` directory |
+| **OpenAI Codex** | `.codex/config.toml` | `.codex/` directory |
+| **Gemini CLI** | `.gemini/settings.json` | `.gemini/` directory |
+| **Cursor** | `.cursor/mcp.json` | `.cursor/` directory |
+| **VS Code Copilot** | `.vscode/mcp.json` | `.vscode/` directory |
+| **Windsurf** | `~/.codeium/windsurf/mcp_config.json` | `~/.codeium/windsurf/` directory |
+
+The init wizard auto-detects which agents you have and generates the right config for each.
 
 ## Quick Start
 
@@ -19,13 +30,14 @@ The MCP tools that let Claude Code interact with your vault. Reads/writes happen
 npx fathom-mcp init
 ```
 
-That's it. Restart Claude Code and fathom tools will be available.
+The wizard will:
+1. Detect installed agents (Claude Code, Codex, Gemini, etc.)
+2. Let you pick which ones to configure
+3. Write per-agent MCP config files
+4. Set up hooks (Claude Code only)
+5. Register the workspace with your fathom-server
 
-The init wizard creates:
-- `.fathom.json` — workspace config (server URL, API key, vault path)
-- `.mcp.json` — registers `npx fathom-mcp` as an MCP server
-- `.claude/settings.local.json` — hooks for context injection and precompact snapshots
-- `vault/` — creates the directory if it doesn't exist
+Restart your agent and fathom tools will be available.
 
 ## Prerequisites
 
@@ -35,7 +47,7 @@ The init wizard creates:
 ## Commands
 
 ```bash
-npx fathom-mcp              # Start MCP server (stdio — used by .mcp.json)
+npx fathom-mcp              # Start MCP server (stdio — used by agent configs)
 npx fathom-mcp init          # Interactive setup wizard
 npx fathom-mcp status        # Check server connection + workspace status
 ```
@@ -64,7 +76,7 @@ npx fathom-mcp status        # Check server connection + workspace status
 | `fathom_room_list` | List all rooms |
 | `fathom_room_describe` | Set a room's description/topic |
 | `fathom_workspaces` | List all configured workspaces |
-| `fathom_send` | Send a message to another workspace's Claude instance |
+| `fathom_send` | Send a message to another workspace's agent instance |
 
 ## Configuration
 
@@ -76,8 +88,9 @@ npx fathom-mcp status        # Check server connection + workspace status
   "vault": "vault",
   "server": "http://localhost:4243",
   "apiKey": "fv_abc123...",
+  "agents": ["claude-code", "gemini"],
   "hooks": {
-    "context-inject": { "enabled": true },
+    "vault-recall": { "enabled": true },
     "precompact-snapshot": { "enabled": true }
   }
 }
@@ -89,11 +102,19 @@ npx fathom-mcp status        # Check server connection + workspace status
 2. `.fathom.json` (walked up from cwd to filesystem root)
 3. Built-in defaults
 
-## Hooks
+### Backward compatibility
+
+The `agents` array replaces the legacy `architecture` string field. Old configs with `architecture: "claude-code"` are automatically migrated to `agents: ["claude-code"]` at read time.
+
+## Hooks (Claude Code only)
+
+Hooks are only available in Claude Code and are configured in `.claude/settings.local.json`.
+
+**UserPromptSubmit** (`fathom-recall.sh`): Runs vault recall on every message — injects relevant context.
 
-**SessionStart / UserPromptSubmit** (`fathom-context.sh`): Injects recent vault activity into Claude's context.
+**PreCompact** (`fathom-precompact.sh`): Records which vault files were active before context compaction.
 
-**PreCompact** (`fathom-precompact.sh`): Records which vault files were active in the session before context compaction.
+Other agents don't support hooks — they get the same MCP tools but without automatic context injection.
 
 ## Vault Frontmatter Schema
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fathom-mcp",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "description": "MCP server for Fathom — vault operations, search, rooms, and cross-workspace communication",
   "type": "module",
   "bin": {
@@ -37,6 +37,11 @@
     "vault",
     "fathom",
     "claude",
+    "codex",
+    "gemini",
+    "cursor",
+    "copilot",
+    "windsurf",
     "ai-agent",
     "memory"
   ]

package/src/cli.js

@@ -10,6 +10,7 @@
  */
 
 import fs from "fs";
+import os from "os";
 import path from "path";
 import readline from "readline";
 import { fileURLToPath } from "url";
@@ -105,6 +106,143 @@ function copyScripts(targetDir) {
   }
 }
 
+// --- Agent registry ----------------------------------------------------------
+
+const MCP_SERVER_ENTRY = {
+  command: "npx",
+  args: ["-y", "fathom-mcp"],
+};
+
+/**
+ * Per-agent config writers. Each writes the appropriate MCP config file
+ * for that agent, merging with existing config if present.
+ */
+
+function writeMcpJson(cwd) {
+  const filePath = path.join(cwd, ".mcp.json");
+  const existing = readJsonFile(filePath) || {};
+  deepMerge(existing, { mcpServers: { "fathom-vault": MCP_SERVER_ENTRY } });
+  writeJsonFile(filePath, existing);
+  return ".mcp.json";
+}
+
+function writeCodexToml(cwd) {
+  const dir = path.join(cwd, ".codex");
+  fs.mkdirSync(dir, { recursive: true });
+  const filePath = path.join(dir, "config.toml");
+
+  let content = "";
+  try {
+    content = fs.readFileSync(filePath, "utf-8");
+  } catch { /* file doesn't exist */ }
+
+  // Check if fathom-vault section already exists
+  if (/\[mcp_servers\.fathom-vault\]/.test(content)) {
+    return ".codex/config.toml (already configured)";
+  }
+
+  const section = `\n[mcp_servers.fathom-vault]\ncommand = "npx"\nargs = ["-y", "fathom-mcp"]\n`;
+  const separator = content && !content.endsWith("\n") ? "\n" : "";
+  fs.writeFileSync(filePath, content + separator + section);
+  return ".codex/config.toml";
+}
+
+function writeGeminiJson(cwd) {
+  const dir = path.join(cwd, ".gemini");
+  fs.mkdirSync(dir, { recursive: true });
+  const filePath = path.join(dir, "settings.json");
+  const existing = readJsonFile(filePath) || {};
+  deepMerge(existing, { mcpServers: { "fathom-vault": MCP_SERVER_ENTRY } });
+  writeJsonFile(filePath, existing);
+  return ".gemini/settings.json";
+}
+
+function writeCursorJson(cwd) {
+  const dir = path.join(cwd, ".cursor");
+  fs.mkdirSync(dir, { recursive: true });
+  const filePath = path.join(dir, "mcp.json");
+  const existing = readJsonFile(filePath) || {};
+  deepMerge(existing, { mcpServers: { "fathom-vault": MCP_SERVER_ENTRY } });
+  writeJsonFile(filePath, existing);
+  return ".cursor/mcp.json";
+}
+
+function writeVscodeJson(cwd) {
+  const dir = path.join(cwd, ".vscode");
+  fs.mkdirSync(dir, { recursive: true });
+  const filePath = path.join(dir, "mcp.json");
+  const existing = readJsonFile(filePath) || {};
+  deepMerge(existing, {
+    servers: {
+      "fathom-vault": {
+        type: "stdio",
+        command: "npx",
+        args: ["-y", "fathom-mcp"],
+      },
+    },
+  });
+  writeJsonFile(filePath, existing);
+  return ".vscode/mcp.json";
+}
+
+function writeWindsurfJson(_cwd) {
+  const dir = path.join(os.homedir(), ".codeium", "windsurf");
+  fs.mkdirSync(dir, { recursive: true });
+  const filePath = path.join(dir, "mcp_config.json");
+  const existing = readJsonFile(filePath) || {};
+  deepMerge(existing, { mcpServers: { "fathom-vault": MCP_SERVER_ENTRY } });
+  writeJsonFile(filePath, existing);
+  return "~/.codeium/windsurf/mcp_config.json";
+}
+
+const AGENTS = {
+  "claude-code": {
+    name: "Claude Code",
+    detect: (cwd) => fs.existsSync(path.join(cwd, ".claude")),
+    configWriter: writeMcpJson,
+    hasHooks: true,
+    nextSteps: 'Add to CLAUDE.md: `ToolSearch query="+fathom" max_results=20`',
+  },
+  "codex": {
+    name: "OpenAI Codex",
+    detect: (cwd) => fs.existsSync(path.join(cwd, ".codex")),
+    configWriter: writeCodexToml,
+    hasHooks: false,
+    nextSteps: "Run `codex` in this directory — fathom tools load automatically.",
+  },
+  "gemini": {
+    name: "Gemini CLI",
+    detect: (cwd) => fs.existsSync(path.join(cwd, ".gemini")),
+    configWriter: writeGeminiJson,
+    hasHooks: false,
+    nextSteps: "Run `gemini` in this directory — fathom tools load automatically.",
+  },
+  "cursor": {
+    name: "Cursor",
+    detect: (cwd) => fs.existsSync(path.join(cwd, ".cursor")),
+    configWriter: writeCursorJson,
+    hasHooks: false,
+    nextSteps: "Restart Cursor — fathom tools appear in MCP settings.",
+  },
+  "vscode": {
+    name: "VS Code Copilot",
+    detect: (cwd) => fs.existsSync(path.join(cwd, ".vscode")),
+    configWriter: writeVscodeJson,
+    hasHooks: false,
+    nextSteps: "Reload VS Code — fathom tools appear in Copilot.",
+  },
+  "windsurf": {
+    name: "Windsurf",
+    detect: () => fs.existsSync(path.join(os.homedir(), ".codeium", "windsurf")),
+    configWriter: writeWindsurfJson,
+    hasHooks: false,
+    nextSteps: "Restart Windsurf — fathom tools appear in Cascade.",
+  },
+};
+
+// Exported for testing
+export { AGENTS, writeMcpJson, writeCodexToml, writeGeminiJson, writeCursorJson, writeVscodeJson, writeWindsurfJson };
+
 // --- Init wizard -------------------------------------------------------------
 
 async function runInit() {
@@ -120,10 +258,11 @@ async function runInit() {
   hifathom.com  ·  fathom@myrakrusemark.com
 `);
 
-  // Check for existing config
-  const existing = findConfigFile(cwd);
-  if (existing) {
-    console.log(`  Found existing config at: ${existing.path}`);
+  // Check for existing config in *this* directory only (don't walk up —
+  // a parent's .fathom.json belongs to a different workspace)
+  const localConfigPath = path.join(cwd, ".fathom.json");
+  if (fs.existsSync(localConfigPath)) {
+    console.log(`  Found existing config at: ${localConfigPath}`);
     const proceed = await askYesNo(rl, "  Overwrite?", false);
     if (!proceed) {
       console.log("  Aborted.");
@@ -142,18 +281,57 @@ async function runInit() {
   // 3. Description (optional)
   const description = await ask(rl, "  Workspace description (optional)", "");
 
-  // 3b. Architecture/platform (optional)
-  const architecture = await ask(rl, "  Architecture/platform (e.g., claude-code, diffusion)", "");
+  // 4. Agent selection — auto-detect and let user choose
+  const agentKeys = Object.keys(AGENTS);
+  const detected = agentKeys.filter((key) => AGENTS[key].detect(cwd));
+
+  console.log("\n  Detected agents:");
+  for (const key of agentKeys) {
+    const agent = AGENTS[key];
+    const isDetected = detected.includes(key);
+    const mark = isDetected ? "✓" : " ";
+    const hint = isDetected ? ` (${key === "windsurf" ? "~/.codeium/windsurf/ found" : `.${key === "claude-code" ? "claude" : key === "vscode" ? "vscode" : key}/ found`})` : "";
+    console.log(`    ${mark} ${agent.name}${hint}`);
+  }
+
+  console.log("\n  Configure for which agents?");
+  agentKeys.forEach((key, i) => {
+    const agent = AGENTS[key];
+    const mark = detected.includes(key) ? " ✓" : "";
+    console.log(`    ${i + 1}. ${agent.name}${mark}`);
+  });
+
+  const defaultSelection = detected.length > 0
+    ? detected.map((key) => agentKeys.indexOf(key) + 1).join(",")
+    : "1";
+  const selectionStr = await ask(rl, "\n  Enter numbers, comma-separated", defaultSelection);
 
-  // 4. Server URL
-  const serverUrl = await ask(rl, "  Fathom server URL", "http://localhost:4243");
+  const selectedIndices = selectionStr
+    .split(",")
+    .map((s) => parseInt(s.trim(), 10))
+    .filter((n) => n >= 1 && n <= agentKeys.length);
+  const selectedAgents = [...new Set(selectedIndices.map((i) => agentKeys[i - 1]))];
 
-  // 5. API key — user gets this from the dashboard or server first-run output
+  if (selectedAgents.length === 0) {
+    console.log("  No agents selected. Defaulting to Claude Code.");
+    selectedAgents.push("claude-code");
+  }
+
+  // 5. Server URL
+  const serverUrl = await ask(rl, "\n  Fathom server URL", "http://localhost:4243");
+
+  // 6. API key
   const apiKey = await ask(rl, "  API key (from dashboard or server first-run output)", "");
 
-  // 6. Hooks
-  const enableRecallHook = await askYesNo(rl, "  Enable vault recall on every message (UserPromptSubmit)?", true);
-  const enablePrecompactHook = await askYesNo(rl, "  Enable PreCompact vault snapshot hook?", true);
+  // 7. Hooks — only ask if Claude Code is selected
+  const hasClaude = selectedAgents.includes("claude-code");
+  let enableRecallHook = false;
+  let enablePrecompactHook = false;
+  if (hasClaude) {
+    console.log();
+    enableRecallHook = await askYesNo(rl, "  Enable vault recall on every message (UserPromptSubmit)?", true);
+    enablePrecompactHook = await askYesNo(rl, "  Enable PreCompact vault snapshot hook?", true);
+  }
 
   rl.close();
 
@@ -168,7 +346,7 @@ async function runInit() {
     server: serverUrl,
     apiKey,
     description,
-    architecture,
+    agents: selectedAgents,
     hooks: {
       "vault-recall": { enabled: enableRecallHook },
       "precompact-snapshot": { enabled: enablePrecompactHook },
@@ -193,60 +371,53 @@ async function runInit() {
     console.log(`  · ${vault}/ (already exists)`);
   }
 
-  // .mcp.json
-  const mcpJsonPath = path.join(cwd, ".mcp.json");
-  const mcpJson = readJsonFile(mcpJsonPath) || {};
-  deepMerge(mcpJson, {
-    mcpServers: {
-      "fathom-vault": {
-        command: "npx",
-        args: ["-y", "fathom-mcp"],
-      },
-    },
-  });
-  writeJsonFile(mcpJsonPath, mcpJson);
-  console.log("  ✓ .mcp.json");
-
-  // .claude/settings.local.json — hook registrations
-  const claudeSettingsPath = path.join(cwd, ".claude", "settings.local.json");
-  const claudeSettings = readJsonFile(claudeSettingsPath) || {};
-
-  // Claude Code hooks use matcher + hooks array format:
-  // { hooks: [{ type: "command", command: "...", timeout: N }] }
-  const hooks = {};
-  if (enableRecallHook) {
-    hooks["UserPromptSubmit"] = [
-      ...(claudeSettings.hooks?.["UserPromptSubmit"] || []),
-    ];
-    const recallCmd = "bash .fathom/scripts/fathom-recall.sh";
-    const hasFathomRecall = hooks["UserPromptSubmit"].some((entry) =>
-      entry.hooks?.some((h) => h.command === recallCmd)
-    );
-    if (!hasFathomRecall) {
-      hooks["UserPromptSubmit"].push({
-        hooks: [{ type: "command", command: recallCmd, timeout: 10000 }],
-      });
-    }
+  // Per-agent config files
+  for (const agentKey of selectedAgents) {
+    const agent = AGENTS[agentKey];
+    const result = agent.configWriter(cwd);
+    console.log(`  ✓ ${result}`);
   }
-  if (enablePrecompactHook) {
-    hooks["PreCompact"] = [
-      ...(claudeSettings.hooks?.["PreCompact"] || []),
-    ];
-    const precompactCmd = "bash .fathom/scripts/fathom-precompact.sh";
-    const hasFathomPrecompact = hooks["PreCompact"].some((entry) =>
-      entry.hooks?.some((h) => h.command === precompactCmd)
-    );
-    if (!hasFathomPrecompact) {
-      hooks["PreCompact"].push({
-        hooks: [{ type: "command", command: precompactCmd, timeout: 30000 }],
-      });
+
+  // Claude Code hooks — only if claude-code is selected
+  if (hasClaude && (enableRecallHook || enablePrecompactHook)) {
+    const claudeSettingsPath = path.join(cwd, ".claude", "settings.local.json");
+    const claudeSettings = readJsonFile(claudeSettingsPath) || {};
+
+    const hooks = {};
+    if (enableRecallHook) {
+      hooks["UserPromptSubmit"] = [
+        ...(claudeSettings.hooks?.["UserPromptSubmit"] || []),
+      ];
+      const recallCmd = "bash .fathom/scripts/fathom-recall.sh";
+      const hasFathomRecall = hooks["UserPromptSubmit"].some((entry) =>
+        entry.hooks?.some((h) => h.command === recallCmd)
+      );
+      if (!hasFathomRecall) {
+        hooks["UserPromptSubmit"].push({
+          hooks: [{ type: "command", command: recallCmd, timeout: 10000 }],
+        });
+      }
+    }
+    if (enablePrecompactHook) {
+      hooks["PreCompact"] = [
+        ...(claudeSettings.hooks?.["PreCompact"] || []),
+      ];
+      const precompactCmd = "bash .fathom/scripts/fathom-precompact.sh";
+      const hasFathomPrecompact = hooks["PreCompact"].some((entry) =>
+        entry.hooks?.some((h) => h.command === precompactCmd)
+      );
+      if (!hasFathomPrecompact) {
+        hooks["PreCompact"].push({
+          hooks: [{ type: "command", command: precompactCmd, timeout: 30000 }],
+        });
+      }
     }
-  }
 
-  if (Object.keys(hooks).length > 0) {
-    claudeSettings.hooks = { ...(claudeSettings.hooks || {}), ...hooks };
-    writeJsonFile(claudeSettingsPath, claudeSettings);
-    console.log("  ✓ .claude/settings.local.json (hooks)");
+    if (Object.keys(hooks).length > 0) {
+      claudeSettings.hooks = { ...(claudeSettings.hooks || {}), ...hooks };
+      writeJsonFile(claudeSettingsPath, claudeSettings);
+      console.log("  ✓ .claude/settings.local.json (hooks)");
+    }
   }
 
   // .gitignore
@@ -258,7 +429,11 @@ async function runInit() {
     const regClient = createClient({ server: serverUrl, apiKey, workspace });
     const isUp = await regClient.healthCheck();
     if (isUp) {
-      const regResult = await regClient.registerWorkspace(workspace, cwd, { vault, description, architecture });
+      const regResult = await regClient.registerWorkspace(workspace, cwd, {
+        vault,
+        description,
+        agents: selectedAgents,
+      });
       if (regResult.ok) {
         console.log(`  ✓ Registered workspace "${workspace}" with server`);
       } else if (regResult.error) {
@@ -267,17 +442,15 @@ async function runInit() {
     }
   }
 
-  console.log(`
-  Done! Fathom MCP is configured for workspace "${workspace}".
-
-  Next steps:
-    1. Start the server:  cd fathom-server && python app.py
-    2. Open Claude Code in this directory — fathom tools will be available.
-    3. Add the following to your CLAUDE.md:
-
-       ## Fathom Vault
-       Load fathom tools on startup: \`ToolSearch query="+fathom" max_results=20\`
-`);
+  // Per-agent next steps
+  console.log(`\n  Done! Fathom MCP is configured for workspace "${workspace}".`);
+  console.log("\n  Next steps:");
+  console.log("    1. Start the server:  cd fathom-server && python app.py");
+  for (const agentKey of selectedAgents) {
+    const agent = AGENTS[agentKey];
+    console.log(`    · ${agent.name}: ${agent.nextSteps}`);
+  }
+  console.log();
 }
 
 // --- Status command ----------------------------------------------------------
@@ -292,6 +465,7 @@ async function runStatus() {
   console.log(`  Vault:     ${config.vault}`);
   console.log(`  Server:    ${config.server}`);
   console.log(`  API Key:   ${config.apiKey ? config.apiKey.slice(0, 7) + "..." + config.apiKey.slice(-4) : "(not set)"}`);
+  console.log(`  Agents:    ${config.agents.length > 0 ? config.agents.join(", ") : "(none)"}`);
 
   // Check vault directory
   const vaultExists = fs.existsSync(config.vault);
@@ -307,8 +481,15 @@ async function runStatus() {
       const names = Object.keys(wsResult.profiles);
       console.log(`  Workspaces: ${names.join(", ") || "(none)"}`);
       for (const [name, profile] of Object.entries(wsResult.profiles)) {
-        const status = profile.running ? "running" : "stopped";
-        console.log(`    ${name}: ${status}${profile.model ? ` (${profile.model})` : ""}`);
+        if (profile.type === "human") {
+          console.log(`    ${name}: human`);
+        } else {
+          const agentLabel = profile.agents?.length > 0
+            ? ` [${profile.agents.join(", ")}]`
+            : profile.architecture ? ` [${profile.architecture}]` : "";
+          const runStatus = profile.running ? "running" : "stopped";
+          console.log(`    ${name}: ${runStatus}${agentLabel}`);
+        }
       }
     }
   }
@@ -318,23 +499,30 @@ async function runStatus() {
 
 // --- Main --------------------------------------------------------------------
 
-const command = process.argv[2];
+// Guard: only run CLI when this module is the entry point (not when imported by tests)
+const isMain = process.argv[1] && (
+  process.argv[1].endsWith("/cli.js") || process.argv[1].endsWith("fathom-mcp")
+);
 
-if (command === "init") {
-  runInit().catch((e) => {
-    console.error(`Error: ${e.message}`);
-    process.exit(1);
-  });
-} else if (command === "status") {
-  runStatus().catch((e) => {
-    console.error(`Error: ${e.message}`);
+if (isMain) {
+  const command = process.argv[2];
+
+  if (command === "init") {
+    runInit().catch((e) => {
+      console.error(`Error: ${e.message}`);
+      process.exit(1);
+    });
+  } else if (command === "status") {
+    runStatus().catch((e) => {
+      console.error(`Error: ${e.message}`);
+      process.exit(1);
+    });
+  } else if (!command || command === "serve") {
+    // Default: start MCP server
+    import("./index.js");
+  } else {
+    console.error(`Unknown command: ${command}`);
+    console.error("Usage: fathom-mcp [init|status|serve]");
     process.exit(1);
-  });
-} else if (!command || command === "serve") {
-  // Default: start MCP server
-  import("./index.js");
-} else {
-  console.error(`Unknown command: ${command}`);
-  console.error("Usage: fathom-mcp [init|status|serve]");
-  process.exit(1);
+  }
 }

package/src/config.js

@@ -18,7 +18,7 @@ const DEFAULTS = {
   server: "http://localhost:4243",
   apiKey: "",
   description: "",
-  architecture: "",
+  agents: [],
   hooks: {
     "context-inject": { enabled: true },
     "precompact-snapshot": { enabled: true },
@@ -68,7 +68,12 @@ export function resolveConfig(startDir = process.cwd()) {
     if (config.server) result.server = config.server;
     if (config.apiKey) result.apiKey = config.apiKey;
     if (config.description) result.description = config.description;
-    if (config.architecture) result.architecture = config.architecture;
+    // Backward compat: migrate legacy `architecture` string to `agents` array
+    if (config.agents && Array.isArray(config.agents)) {
+      result.agents = config.agents;
+    } else if (config.architecture) {
+      result.agents = [config.architecture];
+    }
     if (config.hooks) {
       result.hooks = { ...result.hooks, ...config.hooks };
     }
@@ -113,7 +118,7 @@ export function writeConfig(dir, config) {
     server: config.server || DEFAULTS.server,
     apiKey: config.apiKey || "",
     description: config.description || "",
-    architecture: config.architecture || "",
+    agents: config.agents || [],
     hooks: config.hooks || DEFAULTS.hooks,
   };
   fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");

package/src/server-client.js

@@ -104,11 +104,13 @@ export function createClient(config) {
     return request("GET", "/api/workspaces/profiles");
   }
 
-  async function registerWorkspace(name, projectPath, { vault, description, architecture } = {}) {
+  async function registerWorkspace(name, projectPath, { vault, description, agents, architecture } = {}) {
     const body = { name, path: projectPath };
     if (vault) body.vault = vault;
     if (description) body.description = description;
-    if (architecture) body.architecture = architecture;
+    if (agents && agents.length > 0) body.agents = agents;
+    // Legacy fallback
+    if (architecture && !agents?.length) body.architecture = architecture;
     return request("POST", "/api/workspaces", { body });
   }