youmd 0.6.19 → 0.6.26

package/dist/mcp/server.js

@@ -6,11 +6,12 @@
  * An MCP where the context is you. Every agent that connects gets structured,
  * portable identity context: who you are, how you work, what you sound like.
  *
- * Resources: identity, profile sections, preferences, voice, directives,
- *            memories, projects, skills
- * Tools:     add_memory, update_section, search_memories, use_skill,
- *            compile_bundle, push_bundle, get_project_context,
- *            add_source, create_context_link, list_projects, get_remote_status
+ * Resources: identity, agent brief, profile sections, preferences, voice,
+ *            directives, memories, projects, skills
+ * Tools:     whoami, get_agent_brief, add_memory, update_section,
+ *            search_memories, use_skill, compile_bundle, push_bundle, get_project_context,
+ *            add_source, create_context_link, list_projects, get_remote_status,
+ *            get_stack_manifest, get_stack_capabilities, route_stack_request, smoke_stack
  *
  * Transport: stdio (for Claude Code, Cursor, any MCP client)
  *
@@ -52,14 +53,32 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MEMORY_CATEGORIES = exports.DURABLE_MEMORY_CATEGORIES = exports.AGENT_BRIEF_MEMORY_CAP = void 0;
+exports.activeBundleExists = activeBundleExists;
+exports.getInstalledSkills = getInstalledSkills;
+exports.orderBriefMemories = orderBriefMemories;
+exports.briefOneLine = briefOneLine;
+exports.fetchMemoriesEnvelope = fetchMemoriesEnvelope;
+exports.fetchPrivateContextEnvelope = fetchPrivateContextEnvelope;
+exports.apiRequest = apiRequest;
+exports.setMcpClientName = setMcpClientName;
+exports.resolveAgentName = resolveAgentName;
+exports.buildWhoamiSummaryFromYouJson = buildWhoamiSummaryFromYouJson;
+exports.buildAgentBrief = buildAgentBrief;
+exports.formatAgentBriefMarkdown = formatAgentBriefMarkdown;
 exports.startMcpServer = startMcpServer;
 const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+// T14: CLI tool registry — single source of truth for future tool additions.
+const registry_js_1 = require("./registry.js");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const config_1 = require("../lib/config");
 const project_1 = require("../lib/project");
+const projectContext_1 = require("../lib/projectContext");
+const youstack_1 = require("../lib/youstack");
+const MCP_SERVER_VERSION = "0.6.23";
 function getCurrentProject() {
     const root = (0, project_1.findProjectsRoot)();
     if (!root)
@@ -89,13 +108,27 @@ function readJsonOr(filePath, fallback) {
     }
 }
 function getBundleDir() {
-    return (0, config_1.getLocalBundleDir)();
+    const localDir = (0, config_1.getLocalBundleDir)();
+    if ((0, config_1.bundleLooksInitialized)(localDir))
+        return localDir;
+    const homeDir = (0, config_1.getHomeBundleDir)();
+    if ((0, config_1.bundleLooksInitialized)(homeDir))
+        return homeDir;
+    return localDir;
+}
+function activeBundleExists() {
+    return (0, config_1.bundleLooksInitialized)(getBundleDir());
 }
 function getYouJson() {
     const bundleDir = getBundleDir();
     const youJsonPath = path.join(bundleDir, "you.json");
     return readJsonOr(youJsonPath, {});
 }
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+}
 function getYouMd() {
     const bundleDir = getBundleDir();
     return readFileOr(path.join(bundleDir, "you.md"), "");
@@ -145,9 +178,61 @@ function getInstalledSkills() {
     }
     return skills;
 }
-async function fetchMemories(category, limit) {
-    if (!(0, config_1.isAuthenticated)())
-        return [];
+function tryLoadCurrentYouStack(inputPath) {
+    try {
+        return (0, youstack_1.loadYouStackManifest)(inputPath);
+    }
+    catch {
+        return null;
+    }
+}
+// Mirror of the canonical convex/lib/agentContext.ts assembly. The CLI is a
+// separately published npm package and cannot import the convex module at
+// runtime; cli/src/__tests__/agent-context-parity.test.ts asserts the two
+// implementations never drift (cap, durable set, ordering, one-line collapse,
+// identity summary). Exported for that parity test.
+/** Max memories rendered into the agent brief (parity with hosted MCP). */
+exports.AGENT_BRIEF_MEMORY_CAP = 20;
+/** Categories considered durable — surfaced ahead of newer ephemeral notes. */
+exports.DURABLE_MEMORY_CATEGORIES = new Set([
+    "preference",
+    "decision",
+    "goal",
+    "fact",
+]);
+function asBriefMemories(memories) {
+    return memories.filter((m) => !!m &&
+        typeof m === "object" &&
+        typeof m.category === "string" &&
+        typeof m.content === "string");
+}
+/** Durable categories first, preserving server order (newest-first) within each group. */
+function orderBriefMemories(memories) {
+    const durable = [];
+    const rest = [];
+    for (const memory of memories) {
+        (exports.DURABLE_MEMORY_CATEGORIES.has(memory.category) ? durable : rest).push(memory);
+    }
+    return [...durable, ...rest];
+}
+/** Collapse memory content to a single line capped at `max` chars. */
+function briefOneLine(content, max = 200) {
+    const collapsed = content.replace(/\s+/g, " ").trim();
+    return collapsed.length > max ? `${collapsed.slice(0, max - 1).trimEnd()}…` : collapsed;
+}
+async function fetchMemoriesEnvelope(category, limit) {
+    if (!(0, config_1.isAuthenticated)()) {
+        return {
+            readiness: {
+                status: "auth_required",
+                ready: false,
+                reason: "Memory search needs an authenticated You.md session or API key.",
+                fallback: "Use public identity, project-context files, or run `youmd login` before retrying protected memory search.",
+            },
+            memories: [],
+            count: 0,
+        };
+    }
     const config = (0, config_1.readGlobalConfig)();
     const siteUrl = (0, config_1.getConvexSiteUrl)();
     const params = new URLSearchParams();
@@ -160,15 +245,241 @@ async function fetchMemories(category, limit) {
             headers: { Authorization: `Bearer ${config.token}` },
             signal: AbortSignal.timeout(10000),
         });
-        if (!res.ok)
-            return [];
+        if (!res.ok) {
+            return {
+                readiness: {
+                    status: "unavailable",
+                    ready: false,
+                    reason: `Memory search failed with HTTP ${res.status}.`,
+                    fallback: "Use project-context files or local stack files first, then retry protected memory search when auth/server access is healthy.",
+                },
+                memories: [],
+                count: 0,
+            };
+        }
         const data = await res.json();
-        return (data.memories || data) || [];
+        const memories = (data.memories || data) || [];
+        return {
+            readiness: {
+                status: "ready",
+                ready: true,
+                reason: memories.length > 0 ? "Protected memory search succeeded." : "Protected memory search succeeded but found no matching memories.",
+                fallback: memories.length > 0 ? "None needed." : "If nothing matched, fall back to public identity, project-context files, or a narrower keyword query.",
+            },
+            memories,
+            count: memories.length,
+        };
     }
     catch {
-        return [];
+        return {
+            readiness: {
+                status: "unavailable",
+                ready: false,
+                reason: "Memory search could not reach the protected You.md memories endpoint.",
+                fallback: "Use public identity, project-context files, or local stack context first, then retry protected memory search later.",
+            },
+            memories: [],
+            count: 0,
+        };
     }
 }
+async function fetchPrivateContextEnvelope() {
+    if (!(0, config_1.isAuthenticated)()) {
+        return {
+            readiness: {
+                status: "auth_required",
+                ready: false,
+                reason: "Private context needs an authenticated You.md session or API key.",
+                fallback: "Use local stack files, project-context files, public identity, or run `youmd login` before retrying protected private-context access.",
+            },
+            privateContext: null,
+            summary: {
+                hasNotes: false,
+                linkCount: 0,
+                projectCount: 0,
+            },
+        };
+    }
+    const config = (0, config_1.readGlobalConfig)();
+    const siteUrl = (0, config_1.getConvexSiteUrl)();
+    try {
+        const res = await fetch(`${siteUrl}/api/v1/me/private`, {
+            headers: { Authorization: `Bearer ${config.token}` },
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!res.ok) {
+            return {
+                readiness: {
+                    status: "unavailable",
+                    ready: false,
+                    reason: `Private context fetch failed with HTTP ${res.status}.`,
+                    fallback: "Use local stack files, project-context files, or public identity first, then retry protected private-context access when auth/server access is healthy.",
+                },
+                privateContext: null,
+                summary: {
+                    hasNotes: false,
+                    linkCount: 0,
+                    projectCount: 0,
+                },
+            };
+        }
+        const privateContext = await res.json();
+        const links = privateContext && typeof privateContext === "object" && privateContext.internalLinks && typeof privateContext.internalLinks === "object"
+            ? Object.keys(privateContext.internalLinks).length
+            : 0;
+        const projects = Array.isArray(privateContext?.privateProjects) ? privateContext.privateProjects.length : 0;
+        const hasNotes = typeof privateContext?.privateNotes === "string" && privateContext.privateNotes.trim().length > 0;
+        return {
+            readiness: {
+                status: "ready",
+                ready: true,
+                reason: privateContext
+                    ? "Protected private context fetch succeeded."
+                    : "Protected private context fetch succeeded but no private context is stored yet.",
+                fallback: privateContext
+                    ? "None needed."
+                    : "If private context is empty, fall back to local stack files, project-context files, or public identity.",
+            },
+            privateContext,
+            summary: {
+                hasNotes,
+                linkCount: links,
+                projectCount: projects,
+            },
+        };
+    }
+    catch {
+        return {
+            readiness: {
+                status: "unavailable",
+                ready: false,
+                reason: "Private context fetch could not reach the protected You.md private-context endpoint.",
+                fallback: "Use local stack files, project-context files, or public identity first, then retry protected private-context access later.",
+            },
+            privateContext: null,
+            summary: {
+                hasNotes: false,
+                linkCount: 0,
+                projectCount: 0,
+            },
+        };
+    }
+}
+function fetchProjectContextEnvelope(projectName) {
+    // Reads route through the single project-context engine: the repo
+    // project-context/ directory is overlaid on the global store, repo wins
+    // on file conflicts, and readers see the union (PRODUCT-AUDIT #14).
+    if (projectName) {
+        const ctx = (0, projectContext_1.readMergedProjectContext)({ projectName });
+        if (!ctx) {
+            const hasAnyRoot = !!(0, project_1.findProjectsRoot)() || !!(0, projectContext_1.findRepoContextRoot)();
+            if (!hasAnyRoot) {
+                return {
+                    readiness: {
+                        status: "not_found",
+                        ready: false,
+                        reason: "No projects directory was found for the requested named project.",
+                        fallback: "Use local project-context files from the current repo, public identity, or a current project detection flow before retrying a named project lookup.",
+                    },
+                    project: {
+                        name: projectName,
+                        source: "named",
+                    },
+                    projectContext: null,
+                };
+            }
+            return {
+                readiness: {
+                    status: "not_found",
+                    ready: false,
+                    reason: `Project context for ${projectName} was not found or is incomplete.`,
+                    fallback: "Use local repo instructions, project-context files, or confirm the named project exists before retrying.",
+                },
+                project: {
+                    name: projectName,
+                    source: "named",
+                },
+                projectContext: null,
+            };
+        }
+        return {
+            readiness: {
+                status: "ready",
+                ready: true,
+                reason: `Project context for ${projectName} is available.`,
+                fallback: "None needed.",
+            },
+            project: {
+                name: projectName,
+                source: "named",
+            },
+            projectContext: ctx,
+        };
+    }
+    const current = getCurrentProject();
+    if (!current) {
+        // No managed project matches the cwd — the repo overlay alone may
+        // still provide the context union.
+        const repoCtx = (0, projectContext_1.readMergedProjectContext)({});
+        if (repoCtx) {
+            return {
+                readiness: {
+                    status: "ready",
+                    ready: true,
+                    reason: `Project context for ${repoCtx.meta.name} is available.`,
+                    fallback: "None needed.",
+                },
+                project: {
+                    name: repoCtx.meta.name,
+                    source: "current",
+                },
+                projectContext: repoCtx,
+            };
+        }
+        return {
+            readiness: {
+                status: "not_found",
+                ready: false,
+                reason: "No current project was detected from the working directory.",
+                fallback: "Use local project-context files in the current repo, pass an explicit project name, or fall back to public identity and stack files.",
+            },
+            project: {
+                name: null,
+                source: "current",
+            },
+            projectContext: null,
+        };
+    }
+    const ctx = (0, projectContext_1.readMergedProjectContext)({ projectName: current.name }) || (0, project_1.readProjectContext)(current.dir);
+    if (!ctx) {
+        return {
+            readiness: {
+                status: "not_found",
+                ready: false,
+                reason: `Project context for ${current.name} was detected but could not be read.`,
+                fallback: "Use repo-local instructions and project-context markdown files directly, then repair the named project bundle before retrying.",
+            },
+            project: {
+                name: current.name,
+                source: "current",
+            },
+            projectContext: null,
+        };
+    }
+    return {
+        readiness: {
+            status: "ready",
+            ready: true,
+            reason: `Project context for ${current.name} is available.`,
+            fallback: "None needed.",
+        },
+        project: {
+            name: current.name,
+            source: "current",
+        },
+        projectContext: ctx,
+    };
+}
 async function apiRequest(path, opts) {
     const config = (0, config_1.readGlobalConfig)();
     const siteUrl = (0, config_1.getConvexSiteUrl)();
@@ -183,6 +494,36 @@ async function apiRequest(path, opts) {
     });
     return res.json();
 }
+/**
+ * Agent attribution. Resolution order:
+ *   1. YOUMD_AGENT_NAME env (set by generated MCP configs per host)
+ *   2. MCP clientInfo.name from the initialize handshake
+ *   3. "MCP Agent" — honest unknown instead of misattributing to one host
+ */
+let mcpClientName = null;
+function setMcpClientName(name) {
+    mcpClientName = typeof name === "string" && name.trim() ? name.trim() : null;
+}
+/** Friendly display names for well-known MCP clientInfo.name values. */
+const CLIENT_NAME_MAP = {
+    "claude-code": "Claude Code",
+    "claude": "Claude Code",
+    "claude-desktop": "Claude Desktop",
+    "cursor": "Cursor",
+    "cursor-vscode": "Cursor",
+    "codex": "Codex",
+    "codex-cli": "Codex",
+    "windsurf": "Windsurf",
+};
+function resolveAgentName() {
+    const envName = process.env.YOUMD_AGENT_NAME?.trim();
+    if (envName)
+        return envName;
+    if (mcpClientName) {
+        return CLIENT_NAME_MAP[mcpClientName.toLowerCase()] || mcpClientName;
+    }
+    return "MCP Agent";
+}
 /**
  * Fire-and-forget activity logger. Logs every MCP tool call so the user can
  * see which agents are using their you.md identity via `youmd logs` or the
@@ -199,10 +540,10 @@ async function logMcpActivity(action, resource, details) {
             headers: {
                 Authorization: `Bearer ${config.token}`,
                 "Content-Type": "application/json",
-                "User-Agent": "youmd-mcp/0.6.19",
+                "User-Agent": "youmd-mcp/0.6.23",
             },
             body: JSON.stringify({
-                agentName: process.env.YOUMD_AGENT_NAME || "Claude Code",
+                agentName: resolveAgentName(),
                 agentSource: "mcp",
                 action,
                 resource,
@@ -217,7 +558,7 @@ async function logMcpActivity(action, resource, details) {
     }
 }
 // Valid memory categories enforced by add_memory
-const MEMORY_CATEGORIES = [
+exports.MEMORY_CATEGORIES = [
     "fact",
     "preference",
     "decision",
@@ -233,24 +574,43 @@ const MEMORY_CATEGORIES = [
  * first call an agent makes so it can orient on the user in <1 tool round.
  */
 function buildWhoamiSummary() {
-    const youJson = getYouJson();
-    const identity = youJson.identity || {};
-    const preferences = youJson.preferences || {};
-    const agentPrefs = preferences.agent || {};
-    const directives = youJson.agent_directives || {};
+    return buildWhoamiSummaryFromYouJson(getYouJson());
+}
+/**
+ * Pure whoami summary from a youJson bundle. Mirror of the canonical
+ * extractIdentityCore + renderIdentitySummary in convex/lib/agentContext.ts;
+ * exported for the agent-context parity test.
+ */
+function buildWhoamiSummaryFromYouJson(youJson) {
+    const identity = asRecord(youJson.identity);
+    const preferences = asRecord(youJson.preferences);
+    const agentPrefs = asRecord(preferences.agent);
+    const directives = asRecord(youJson.agent_directives);
     const projects = Array.isArray(youJson.projects) ? youJson.projects : [];
-    const name = identity.name || youJson.username || "(unknown)";
-    const role = identity.tagline || identity.bio?.short || "";
-    const stack = directives.default_stack || "";
-    const tone = agentPrefs.tone || "";
-    const avoidList = Array.isArray(agentPrefs.avoid) ? agentPrefs.avoid : [];
+    const bio = asRecord(identity.bio);
+    const name = typeof identity.name === "string"
+        ? identity.name
+        : typeof youJson.username === "string" ? youJson.username : "(unknown)";
+    const role = typeof identity.tagline === "string"
+        ? identity.tagline
+        : typeof bio.short === "string" ? bio.short : "";
+    const stack = typeof directives.default_stack === "string" ? directives.default_stack : "";
+    const tone = typeof agentPrefs.tone === "string" ? agentPrefs.tone : "";
+    const avoidList = Array.isArray(agentPrefs.avoid)
+        ? agentPrefs.avoid.filter((item) => typeof item === "string")
+        : [];
     const avoid = avoidList.join(", ");
     const topProjects = projects
         .slice(0, 3)
-        .map((p) => (typeof p === "string" ? p : p?.name || ""))
+        .map((project) => {
+        if (typeof project === "string")
+            return project;
+        const record = asRecord(project);
+        return typeof record.name === "string" ? record.name : "";
+    })
         .filter(Boolean)
         .join(", ");
-    const goal = directives.current_goal || "";
+    const goal = typeof directives.current_goal === "string" ? directives.current_goal : "";
     const lines = [];
     lines.push(`Name: ${name}`);
     if (role)
@@ -282,67 +642,317 @@ function buildIdentityMarkdown() {
         return md;
     // Fallback: synthesize from youJson if you.md is missing
     const youJson = getYouJson();
-    const identity = youJson.identity || {};
+    const identity = asRecord(youJson.identity);
+    const bio = asRecord(identity.bio);
     const parts = [];
-    parts.push(`# ${identity.name || youJson.username || "Identity"}`);
-    if (identity.tagline)
+    const title = typeof identity.name === "string"
+        ? identity.name
+        : typeof youJson.username === "string" ? youJson.username : "Identity";
+    parts.push(`# ${title}`);
+    if (typeof identity.tagline === "string")
         parts.push(identity.tagline);
-    if (identity.bio?.long || identity.bio?.medium || identity.bio?.short) {
-        parts.push(`\n## About\n\n${identity.bio.long || identity.bio.medium || identity.bio.short}`);
+    const about = typeof bio.long === "string"
+        ? bio.long
+        : typeof bio.medium === "string"
+            ? bio.medium
+            : typeof bio.short === "string" ? bio.short : "";
+    if (about) {
+        parts.push(`\n## About\n\n${about}`);
     }
     return parts.join("\n") + "\n";
 }
-/**
- * Find the nearest project-context/ directory by walking up from cwd.
- * Also treats a `.youmd-project` marker file as a valid project root.
- * Returns the directory that contains project-context/ or the marker.
- */
-function findLocalProjectContextRoot(startDir = process.cwd()) {
-    let dir = startDir;
-    // Walk up at most 8 levels to avoid runaway searches
-    for (let i = 0; i < 8; i++) {
-        const contextDir = path.join(dir, "project-context");
-        const marker = path.join(dir, ".youmd-project");
-        if (fs.existsSync(contextDir) && fs.statSync(contextDir).isDirectory()) {
-            return dir;
-        }
-        if (fs.existsSync(marker)) {
-            return dir;
-        }
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return null;
-}
 /**
  * Returns true if the current cwd has local project context available
  * (either via project-context/ directory or a .youmd-project marker).
+ * Detection and reads route through the single project-context engine
+ * (lib/projectContext.ts) — repo files overlay the global store.
  */
 function hasLocalProjectContext() {
-    return findLocalProjectContextRoot() !== null;
+    return (0, projectContext_1.findRepoContextRoot)() !== null;
 }
 /**
- * Read a single project-context markdown file. Tries project-context/<name>.md
- * in the detected project root. Returns empty string if not found.
+ * Read a single project-context markdown file via the engine's overlay
+ * union (repo project-context/ wins over the global overlay; legacy
+ * top-level repo files still resolve). Returns empty string if not found.
  */
 function readLocalProjectContextFile(name) {
-    const root = findLocalProjectContextRoot();
-    if (!root)
-        return "";
+    const resolved = (0, projectContext_1.resolveProjectContext)();
+    return (0, projectContext_1.readContextFile)(resolved, name)?.content || "";
+}
+function firstContentLines(content, limit = 3) {
+    const lines = content
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith("---") && !line.startsWith("#") && !line.startsWith("<!--"));
+    return lines.slice(0, limit).join(" ").slice(0, 280);
+}
+function readBriefFile(root, relativePath) {
+    const filePath = path.join(root, relativePath);
+    if (!fs.existsSync(filePath)) {
+        return { path: relativePath, exists: false };
+    }
+    try {
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory()) {
+            return { path: relativePath, exists: true, summary: "directory" };
+        }
+        const content = fs.readFileSync(filePath, "utf-8");
+        return {
+            path: relativePath,
+            exists: true,
+            chars: content.length,
+            summary: firstContentLines(content),
+        };
+    }
+    catch {
+        return { path: relativePath, exists: true, summary: "unreadable" };
+    }
+}
+function readProjectFile(root, relativePath) {
+    const filePath = path.join(root, relativePath);
+    return readFileOr(filePath, "");
+}
+function collectInstructionFiles(root) {
     const candidates = [
-        path.join(root, "project-context", `${name}.md`),
-        path.join(root, "project-context", `${name.toUpperCase()}.md`),
-        path.join(root, `${name}.md`),
-        path.join(root, `${name.toUpperCase()}.md`),
+        "AGENTS.md",
+        "CLAUDE.md",
+        ".you/AGENT.md",
+        ".you/STACK-MAP.md",
+        ".cursor/rules/youmd.mdc",
+        ".cursor/rules/youmd.md",
+        ".claude/skills/youmd",
+        ".codex/skills/youmd",
     ];
-    for (const candidate of candidates) {
-        if (fs.existsSync(candidate)) {
-            return readFileOr(candidate, "");
+    return candidates
+        .map((candidate) => readBriefFile(root, candidate))
+        .filter((file) => file.exists);
+}
+function collectContextFiles(root) {
+    const candidates = [
+        "project-context/CURRENT_STATE.md",
+        "project-context/feature-requests-active.md",
+        "project-context/TODO.md",
+        "project-context/FEATURES.md",
+        "project-context/CHANGELOG.md",
+        "project-context/PRD.md",
+        "project-context/ARCHITECTURE.md",
+        "project-context/STYLE_GUIDE.md",
+        "project-context/BRANDING.md",
+    ];
+    return candidates
+        .map((candidate) => readBriefFile(root, candidate))
+        .filter((file) => file.exists);
+}
+function extractOpenTodos(content, limit = 8) {
+    const todos = [];
+    for (const line of content.split("\n")) {
+        const match = line.match(/^\s*-\s+\[\s\]\s+(.+)$/);
+        if (match)
+            todos.push(match[1].trim());
+        if (todos.length >= limit)
+            break;
+    }
+    return todos;
+}
+function extractActiveRequests(content, limit = 6) {
+    const requests = [];
+    const chunks = content.split(/\n(?=###\s+)/g);
+    for (const chunk of chunks) {
+        const titleMatch = chunk.match(/^###\s+(.+)$/m);
+        if (!titleMatch)
+            continue;
+        const statusMatch = chunk.match(/\*\*Status:\*\*\s*([^\n]+)/);
+        const status = statusMatch?.[1]?.trim() || "UNKNOWN";
+        if (/^(DONE|VERIFIED BY USER|DECIDED|N\/A)/i.test(status))
+            continue;
+        requests.push(`${titleMatch[1].trim()} [${status}]`);
+        if (requests.length >= limit)
+            break;
+    }
+    return requests;
+}
+function extractSectionBullets(content, heading, limit = 6) {
+    const lines = content.split("\n");
+    const start = lines.findIndex((line) => line.trim().toLowerCase() === `## ${heading.toLowerCase()}`);
+    if (start < 0)
+        return [];
+    const bullets = [];
+    for (const line of lines.slice(start + 1)) {
+        if (/^##\s+/.test(line))
+            break;
+        const match = line.match(/^\s*-\s+(.+)$/);
+        if (match)
+            bullets.push(match[1].trim());
+        if (bullets.length >= limit)
+            break;
+    }
+    return bullets;
+}
+function buildProjectBrief() {
+    const detected = (0, config_1.detectProjectContext)();
+    const fallbackRoot = (0, projectContext_1.findRepoContextRoot)();
+    const root = detected?.root || fallbackRoot;
+    if (!root)
+        return null;
+    const activeRequests = extractActiveRequests(readProjectFile(root, "project-context/feature-requests-active.md"));
+    const openTodos = extractOpenTodos(readProjectFile(root, "project-context/TODO.md"));
+    const knownIssues = extractSectionBullets(readProjectFile(root, "project-context/CURRENT_STATE.md"), "Known Issues");
+    return {
+        name: detected?.name || path.basename(root),
+        root,
+        marker: detected?.marker || "project-context",
+        instructionFiles: collectInstructionFiles(root),
+        contextFiles: collectContextFiles(root),
+        activeRequests,
+        openTodos,
+        knownIssues,
+    };
+}
+async function buildAgentBrief(options = {}) {
+    const project = buildProjectBrief();
+    const installedSkills = getInstalledSkills().map((skill) => skill.name).sort();
+    const nextMoves = [];
+    if (project?.activeRequests.length) {
+        nextMoves.push(`Address the top active request: ${project.activeRequests[0]}`);
+    }
+    if (project?.openTodos.length) {
+        nextMoves.push(`Use the first open TODO as backlog context: ${project.openTodos[0]}`);
+    }
+    if (project && project.contextFiles.length === 0) {
+        nextMoves.push("Bootstrap project-context with: youmd skill init-project --mode additive");
+    }
+    if (!installedSkills.includes("youstack-start")) {
+        nextMoves.push("Install the YouStack starter skill with: youmd skill install youstack-start");
+    }
+    if (nextMoves.length === 0) {
+        nextMoves.push("Read the project instructions, pick the highest-signal task, and act end-to-end.");
+    }
+    const brief = {
+        generatedAt: new Date().toISOString(),
+        user: {
+            summary: buildWhoamiSummary(),
+            authenticated: (0, config_1.isAuthenticated)(),
+            bundleDir: getBundleDir(),
+            bundleInitialized: activeBundleExists(),
+        },
+        environment: {
+            cwd: process.cwd(),
+            mcpVersion: MCP_SERVER_VERSION,
+        },
+        project,
+        skills: {
+            installed: installedSkills,
+            recommended: [
+                "youstack-start",
+                "project-context-init",
+                "proactive-context-fill",
+                "voice-sync",
+                "you-logs",
+            ],
+        },
+        nextMoves: nextMoves.slice(0, 5),
+        reminders: [
+            "Read the whole user request before acting; split multi-part asks into tracked items.",
+            "Prefer local project instructions and project-context files before asking for context.",
+            "When making changes, update TODO, FEATURES, CHANGELOG, active requests, and PROMPTS before closing.",
+            "Do not claim files were written or pushed unless the tool call actually succeeded.",
+        ],
+    };
+    // Memories are included by default (parity with hosted get_agent_brief:
+    // the brief must surface memory CONTENT, not a count — opt out explicitly).
+    if (options.includeMemories !== false) {
+        const memoryResult = await fetchMemoriesEnvelope(undefined, exports.AGENT_BRIEF_MEMORY_CAP * 3);
+        brief.memoriesReadiness = memoryResult.readiness;
+        brief.memories = orderBriefMemories(asBriefMemories(memoryResult.memories))
+            .slice(0, exports.AGENT_BRIEF_MEMORY_CAP);
+    }
+    return brief;
+}
+function renderFileList(files) {
+    if (files.length === 0)
+        return "- none detected";
+    return files.map((file) => {
+        const detail = file.summary ? ` - ${file.summary}` : "";
+        const chars = typeof file.chars === "number" ? ` (${file.chars} chars)` : "";
+        return `- ${file.path}${chars}${detail}`;
+    }).join("\n");
+}
+function renderList(items, empty) {
+    if (items.length === 0)
+        return `- ${empty}`;
+    return items.map((item) => `- ${item}`).join("\n");
+}
+function formatAgentBriefMarkdown(brief, maxChars = 6000) {
+    const project = brief.project;
+    const lines = [];
+    lines.push("# YouStack Agent Brief");
+    lines.push("");
+    lines.push("## User");
+    lines.push(brief.user.summary || "(no identity summary available)");
+    lines.push("");
+    lines.push(`- authenticated: ${brief.user.authenticated ? "yes" : "no"}`);
+    lines.push(`- bundle: ${brief.user.bundleInitialized ? brief.user.bundleDir : "not initialized"}`);
+    lines.push(`- cwd: ${brief.environment.cwd}`);
+    lines.push("");
+    lines.push("## Project");
+    if (project) {
+        lines.push(`- name: ${project.name}`);
+        lines.push(`- root: ${project.root}`);
+        lines.push(`- marker: ${project.marker}`);
+        lines.push("");
+        lines.push("### Instruction Files");
+        lines.push(renderFileList(project.instructionFiles));
+        lines.push("");
+        lines.push("### Project Context");
+        lines.push(renderFileList(project.contextFiles));
+        lines.push("");
+        lines.push("### Active Requests");
+        lines.push(renderList(project.activeRequests, "none detected"));
+        lines.push("");
+        lines.push("### Open TODOs");
+        lines.push(renderList(project.openTodos, "none detected"));
+        if (project.knownIssues.length > 0) {
+            lines.push("");
+            lines.push("### Known Issues");
+            lines.push(renderList(project.knownIssues, "none detected"));
         }
     }
-    return "";
+    else {
+        lines.push("- no local project detected");
+    }
+    lines.push("");
+    lines.push("## Skills");
+    lines.push(`- installed: ${brief.skills.installed.length > 0 ? brief.skills.installed.join(", ") : "none"}`);
+    lines.push(`- recommended: ${brief.skills.recommended.join(", ")}`);
+    lines.push("");
+    if (brief.memories) {
+        // Render actual memory content lines, not a bare count (parity with the
+        // hosted get_agent_brief).
+        lines.push(`## Memories (${brief.memories.length})`);
+        if (brief.memories.length === 0) {
+            lines.push("- none recorded yet");
+        }
+        else {
+            for (const memory of brief.memories) {
+                lines.push(`- [${memory.category}] ${briefOneLine(memory.content)}`);
+            }
+        }
+        if (brief.memoriesReadiness && !brief.memoriesReadiness.ready) {
+            lines.push(`- readiness: ${brief.memoriesReadiness.status} (${brief.memoriesReadiness.reason})`);
+            lines.push(`- fallback: ${brief.memoriesReadiness.fallback}`);
+        }
+        lines.push("");
+    }
+    lines.push("## Next Moves");
+    lines.push(renderList(brief.nextMoves, "read instructions, then act"));
+    lines.push("");
+    lines.push("## Reminders");
+    lines.push(renderList(brief.reminders, "none"));
+    let markdown = lines.join("\n");
+    if (markdown.length > maxChars) {
+        markdown = markdown.slice(0, Math.max(0, maxChars - 32)).trimEnd() + "\n\n[truncated]";
+    }
+    return markdown;
 }
 // ---------------------------------------------------------------------------
 // MCP Server
@@ -350,13 +960,18 @@ function readLocalProjectContextFile(name) {
 async function startMcpServer() {
     const server = new index_js_1.Server({
         name: "youmd",
-        version: "0.5.0",
+        version: MCP_SERVER_VERSION,
     }, {
         capabilities: {
             resources: {},
             tools: {},
         },
     });
+    // Capture clientInfo.name from the initialize handshake for activity
+    // attribution (fallback when YOUMD_AGENT_NAME isn't set by the host config).
+    server.oninitialized = () => {
+        setMcpClientName(server.getClientVersion()?.name);
+    };
     // ── LIST RESOURCES ─────────────────────────────────────────────────
     server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => {
         const resources = [];
@@ -373,6 +988,27 @@ async function startMcpServer() {
             description: "Human-readable you.md identity (you.md format)",
             mimeType: "text/markdown",
         });
+        resources.push({
+            uri: "youmd://agent/brief",
+            name: "agent-brief",
+            description: "YouStack startup brief for local agents: compact identity, project instructions, active requests, open TODOs, installed skills, and next moves",
+            mimeType: "text/markdown",
+        });
+        const currentStack = tryLoadCurrentYouStack();
+        if (currentStack) {
+            resources.push({
+                uri: "youmd://stacks/current/manifest",
+                name: "stacks/current/manifest",
+                description: "Current local YouStack manifest discovered from cwd",
+                mimeType: "application/json",
+            });
+            resources.push({
+                uri: "youmd://stacks/current/capabilities",
+                name: "stacks/current/capabilities",
+                description: "Current local YouStack capability map",
+                mimeType: "application/json",
+            });
+        }
         // Profile sections
         const sections = getSectionFiles();
         for (const section of sections) {
@@ -385,6 +1021,12 @@ async function startMcpServer() {
         }
         // Memories (if authenticated)
         if ((0, config_1.isAuthenticated)()) {
+            resources.push({
+                uri: "youmd://private-context",
+                name: "private-context",
+                description: "Protected private context — notes, internal links, and private projects with readiness/fallback guidance",
+                mimeType: "application/json",
+            });
             resources.push({
                 uri: "youmd://memories",
                 name: "memories",
@@ -505,9 +1147,55 @@ async function startMcpServer() {
                     }],
             };
         }
+        // youmd://agent/brief
+        if (uri === "youmd://agent/brief") {
+            const brief = await buildAgentBrief();
+            void logMcpActivity("read", "agent/brief");
+            return {
+                contents: [{
+                        uri,
+                        mimeType: "text/markdown",
+                        text: formatAgentBriefMarkdown(brief),
+                    }],
+            };
+        }
+        if (uri === "youmd://stacks/current/manifest") {
+            const loaded = tryLoadCurrentYouStack();
+            if (!loaded)
+                throw new Error("no local YouStack manifest found from current directory");
+            void logMcpActivity("read", "stacks/current/manifest");
+            return {
+                contents: [{
+                        uri,
+                        mimeType: "application/json",
+                        text: JSON.stringify({
+                            manifestPath: loaded.manifestPath,
+                            rootDir: loaded.rootDir,
+                            manifest: loaded.manifest,
+                            validation: loaded.validation,
+                        }, null, 2),
+                    }],
+            };
+        }
+        if (uri === "youmd://stacks/current/capabilities") {
+            const loaded = tryLoadCurrentYouStack();
+            if (!loaded)
+                throw new Error("no local YouStack manifest found from current directory");
+            void logMcpActivity("read", "stacks/current/capabilities");
+            return {
+                contents: [{
+                        uri,
+                        mimeType: "application/json",
+                        text: JSON.stringify({
+                            stack: loaded.manifest.slug,
+                            capabilities: (0, youstack_1.getYouStackCapabilities)(loaded.manifest),
+                        }, null, 2),
+                    }],
+            };
+        }
         // youmd://memories
         if (uri === "youmd://memories" || uri === "youmd://memories/all") {
-            const memories = await fetchMemories(undefined, 50);
+            const memories = await fetchMemoriesEnvelope(undefined, 50);
             return {
                 contents: [{
                         uri,
@@ -519,7 +1207,7 @@ async function startMcpServer() {
         // youmd://memories/{category}
         const memCatMatch = uri.match(/^youmd:\/\/memories\/(.+)$/);
         if (memCatMatch) {
-            const memories = await fetchMemories(memCatMatch[1], 50);
+            const memories = await fetchMemoriesEnvelope(memCatMatch[1], 50);
             return {
                 contents: [{
                         uri,
@@ -528,6 +1216,16 @@ async function startMcpServer() {
                     }],
             };
         }
+        if (uri === "youmd://private-context") {
+            const privateContext = await fetchPrivateContextEnvelope();
+            return {
+                contents: [{
+                        uri,
+                        mimeType: "application/json",
+                        text: JSON.stringify(privateContext, null, 2),
+                    }],
+            };
+        }
         // youmd://project/current/{file} — local project-context files from cwd
         const localProjMatch = uri.match(/^youmd:\/\/project\/current\/(prd|todo|features|decisions|changelog)$/);
         if (localProjMatch) {
@@ -545,10 +1243,7 @@ async function startMcpServer() {
         }
         // youmd://projects/current
         if (uri === "youmd://projects/current") {
-            const current = getCurrentProject();
-            if (!current)
-                throw new Error("no project detected in current directory");
-            const ctx = (0, project_1.readProjectContext)(current.dir);
+            const ctx = fetchProjectContextEnvelope();
             return {
                 contents: [{
                         uri,
@@ -560,11 +1255,7 @@ async function startMcpServer() {
         // youmd://projects/{name}
         const projMatch = uri.match(/^youmd:\/\/projects\/(.+)$/);
         if (projMatch) {
-            const root = (0, project_1.findProjectsRoot)();
-            if (!root)
-                throw new Error("no projects directory found");
-            const projDir = (0, project_1.getProjectDir)(root, projMatch[1]);
-            const ctx = (0, project_1.readProjectContext)(projDir);
+            const ctx = fetchProjectContextEnvelope(projMatch[1]);
             return {
                 contents: [{
                         uri,
@@ -610,42 +1301,33 @@ async function startMcpServer() {
     server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
         return {
             tools: [
+                // whoami, get_identity, list_skills, list_projects, get_section,
+                // get_project_context, get_stack_manifest, get_stack_capabilities,
+                // route_stack_request, smoke_stack — migrated to registry.ts (T14).
                 {
-                    name: "whoami",
-                    description: "Return a compact ~500-char identity summary: name, role, stack, tone, things to avoid, top projects, and current goal. This is the FIRST tool you should call when starting a new conversation — it gives you just enough context to orient on the user before deciding whether to pull the full identity bundle. Returns plain text, not JSON.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {},
-                    },
-                },
-                {
-                    name: "get_identity",
-                    description: "Get the user's complete you.md identity bundle. Returns compact (default), full JSON, or human-readable markdown. For the fastest orient, call whoami first; call get_identity when you need full detail (preferences, voice, directives, projects).",
+                    name: "get_agent_brief",
+                    description: "Return a YouStack startup brief for local agents. Use immediately after whoami when starting Claude Code, Codex, Cursor, or another MCP-backed session. It combines compact identity, the user's recent durable memories (rendered inline by default), current repo instructions, project-context active requests, open TODOs, installed skills, and recommended next moves so the agent can act without asking the user to re-explain the project.",
                     inputSchema: {
                         type: "object",
                         properties: {
                             format: {
                                 type: "string",
-                                enum: ["compact", "full", "json", "markdown"],
-                                description: "Output format: compact (500-char summary, default — same as whoami), full/json (complete identity bundle as JSON), markdown (human-readable markdown).",
+                                enum: ["markdown", "json"],
+                                description: "Output format. markdown is default and best for agent context; json is best for automation.",
                             },
-                        },
-                    },
-                },
-                {
-                    name: "get_section",
-                    description: "Read a specific identity section by path. Use when you need just ONE section rather than the full bundle. Returns markdown content for the requested section. Available paths: profile/about, profile/projects, profile/now, profile/values, profile/links, preferences/agent, preferences/writing, voice/voice, directives/agent.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            section: {
-                                type: "string",
-                                description: "Section path: profile/about, profile/projects, profile/now, profile/values, profile/links, preferences/agent, preferences/writing, voice/voice, directives/agent",
+                            includeMemories: {
+                                type: "boolean",
+                                description: "Include up to 20 memories (category + content, durable categories first, then newest) plus retrieval readiness/fallback guidance. Default true.",
+                            },
+                            maxChars: {
+                                type: "number",
+                                description: "Maximum markdown characters when format=markdown. Default 6000.",
                             },
                         },
-                        required: ["section"],
                     },
                 },
+                // get_stack_manifest, get_stack_capabilities, route_stack_request,
+                // smoke_stack, get_identity, get_section — migrated to registry.ts (T14).
                 {
                     name: "update_section",
                     description: "Update a section of the user's identity. Writes markdown content to the local .youmd/ directory. Use after the user explicitly asks to change their profile, preferences, voice, or directives. Always confirm changes with the user before calling. Does NOT auto-push — call push_bundle afterward if the user wants to publish.",
@@ -664,60 +1346,8 @@ async function startMcpServer() {
                         required: ["section", "content"],
                     },
                 },
-                {
-                    name: "add_memory",
-                    description: "Save a memory about the user — facts, preferences, decisions, or context learned during this conversation. Memories persist across sessions and inform ALL future agent interactions. Use proactively when you learn something important about the user (a preference, a decision, a project detail). Requires authentication.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            category: {
-                                type: "string",
-                                enum: [...MEMORY_CATEGORIES],
-                                description: "Memory category. Must be one of: fact, preference, decision, project, goal, insight, context, relationship.",
-                            },
-                            content: {
-                                type: "string",
-                                description: "The memory content — be specific and actionable",
-                            },
-                            tags: {
-                                type: "array",
-                                items: { type: "string" },
-                                description: "Optional tags for searchability",
-                            },
-                        },
-                        required: ["category", "content"],
-                    },
-                },
-                {
-                    name: "search_memories",
-                    description: "Search the user's memories by category or list all active memories. Returns an array of memory objects with category, content, tags, and timestamps. Use to check what you already know before asking the user a question they may have answered before.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            category: {
-                                type: "string",
-                                description: "Filter by category (optional): fact, preference, decision, project, goal, insight, context",
-                            },
-                            limit: {
-                                type: "number",
-                                description: "Max results (default 30)",
-                            },
-                        },
-                    },
-                },
-                {
-                    name: "get_project_context",
-                    description: "Get the full project context for the current or named project — PRD, TODO, features, decisions, changelog, and project memories. Returns a JSON object with all project-context/ files. Use when starting work on a project to understand what has been built, what is planned, and what decisions have been made.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            project: {
-                                type: "string",
-                                description: "Project name. Omit to auto-detect from current directory.",
-                            },
-                        },
-                    },
-                },
+                // add_memory, search_memories, get_private_context — migrated to registry.ts (T14).
+                // get_project_context — migrated to registry.ts (T14).
                 {
                     name: "add_project_memory",
                     description: "Save a memory scoped to a specific project. Unlike add_memory (which is global), project memories are stored locally in the project-context/ directory and only surface when working on that project. Use for architecture decisions, bug context, and feature-specific learnings.",
@@ -740,20 +1370,7 @@ async function startMcpServer() {
                         required: ["category", "content"],
                     },
                 },
-                {
-                    name: "use_skill",
-                    description: "Render an identity-aware skill — returns the skill content with the user's identity interpolated into {{var}} placeholders. Returns rendered markdown with instructions the agent should follow. Use when the user asks to generate a CLAUDE.md, sync voice, scaffold a project, or run a self-improvement review.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            name: {
-                                type: "string",
-                                description: "Skill name: voice-sync, claude-md-generator, project-context-init, meta-improve, proactive-context-fill, you-logs",
-                            },
-                        },
-                        required: ["name"],
-                    },
-                },
+                // use_skill — migrated to registry.ts (T14).
                 {
                     name: "compile_bundle",
                     description: "Recompile the local identity bundle from profile/, preferences/, voice/, directives/ files into you.json + you.md. Call after update_section to regenerate the compiled bundle. Returns compilation stats including version, section count, and files read.",
@@ -783,132 +1400,80 @@ async function startMcpServer() {
                         properties: {},
                     },
                 },
-                {
-                    name: "list_skills",
-                    description: "List all installed identity-aware skills with their names. Use to discover what skills are available before calling use_skill. Returns a simple list of installed skill names.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {},
-                    },
-                },
-                {
-                    name: "add_source",
-                    description: "Register an identity data source (LinkedIn, GitHub, X, website, blog, YouTube). Links an external profile to the user's identity so it can be scraped and indexed. Requires authentication. Use when the user wants to connect a new social profile or website to their identity.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            sourceType: {
-                                type: "string",
-                                enum: ["website", "linkedin", "x", "github", "blog", "youtube"],
-                                description: "Type of source to register",
-                            },
-                            sourceUrl: {
-                                type: "string",
-                                description: "Full URL to the source (e.g., https://github.com/username)",
-                            },
-                        },
-                        required: ["sourceType", "sourceUrl"],
-                    },
-                },
-                {
-                    name: "create_context_link",
-                    description: "Generate a shareable context link for agents. The link gives any agent temporary or permanent read access to the user's identity context. Use when the user wants to share their identity with a third-party agent or service. Returns a URL that can be passed to any agent.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            scope: {
-                                type: "string",
-                                enum: ["public", "full"],
-                                description: "Access scope: public (profile only) or full (includes memories, preferences, directives). Default: public",
-                            },
-                            ttl: {
-                                type: "string",
-                                enum: ["1h", "24h", "7d", "30d", "never"],
-                                description: "Time-to-live for the link. Default: 24h",
-                            },
-                        },
-                    },
-                },
-                {
-                    name: "list_projects",
-                    description: "List all detected projects with their metadata. Returns project names found in the projects root directory. Use to discover available projects before calling get_project_context with a specific project name.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {},
-                    },
-                },
-                {
-                    name: "get_remote_status",
-                    description: "Check sync status between local identity bundle and the remote you.md server. Returns whether the user is authenticated, whether the local bundle exists, and the current version info. Use to diagnose sync issues or confirm a push was successful.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {},
-                    },
-                },
-                {
-                    name: "get_activity_log",
-                    description: "Get the user's recent agent activity log. Use this to see which agents have connected to their you.md identity and what they did. Returns an array of activity events with agent name, action, resource, timestamp. Useful for: showing the user proof their identity context is being used by other agents, debugging integration issues, auditing access.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            limit: { type: "number", description: "Max events (default 30)" },
-                            agentName: { type: "string", description: "Filter by agent name (e.g. 'Claude Code')" },
-                            action: { type: "string", description: "Filter by action (read|write|push|memory_add)" },
-                        },
-                    },
-                },
+                // list_skills — migrated to registry.ts (T14).
+                // add_source, create_context_link — migrated to registry.ts (T14).
+                // list_projects — migrated to registry.ts (T14).
+                // get_remote_status, get_activity_log — migrated to registry.ts (T14).
             ],
+            // T14: registry tools appended; inline tools above remain until migration.
+            ...registry_js_1.CLI_MCP_TOOLS.map(({ name, description, inputSchema }) => ({
+                name,
+                description,
+                inputSchema,
+            })),
         };
     });
     // ── CALL TOOL ──────────────────────────────────────────────────────
     server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
         const { name, arguments: args } = request.params;
+        // T14: Try registry dispatch first (grows as tools are migrated out of the switch).
+        const registrySpec = registry_js_1.CLI_MCP_TOOLS.find((t) => t.name === name);
+        if (registrySpec) {
+            const ctx = {
+                logActivity: (action, resource, details) => {
+                    void logMcpActivity(action, resource, details);
+                },
+                authenticated: (0, config_1.isAuthenticated)(),
+                // Injected helpers — avoids circular import (registry cannot import server).
+                fetchMemoriesEnvelope,
+                fetchPrivateContextEnvelope,
+                apiRequest,
+                memoryCategories: exports.MEMORY_CATEGORIES,
+                resolveAgentName,
+                getInstalledSkills,
+                activeBundleExists,
+                getYouJson,
+                fetchActivityLog: (params) => {
+                    const config = (0, config_1.readGlobalConfig)();
+                    return fetch(`${(0, config_1.getConvexSiteUrl)()}/api/v1/me/activity?${params}`, {
+                        headers: { Authorization: `Bearer ${config.token}` },
+                        signal: AbortSignal.timeout(10000),
+                    });
+                },
+            };
+            const result = await registrySpec.handler((args || {}), ctx);
+            return { content: result.content, isError: result.isError };
+        }
+        // whoami, get_identity, get_section, list_skills, list_projects,
+        // get_project_context, get_stack_manifest, get_stack_capabilities,
+        // route_stack_request, smoke_stack — dispatched via registry above (T14).
         switch (name) {
-            case "whoami": {
-                void logMcpActivity("read", "identity:compact");
-                return {
-                    content: [{
-                            type: "text",
-                            text: buildWhoamiSummary(),
-                        }],
-                };
-            }
-            case "get_identity": {
-                const format = args?.format || "compact";
-                void logMcpActivity("read", "identity:" + format);
-                if (format === "markdown") {
-                    return { content: [{ type: "text", text: buildIdentityMarkdown() }] };
-                }
-                if (format === "full" || format === "json") {
+            case "get_agent_brief": {
+                const briefArgs = (args || {});
+                const includeMemories = briefArgs.includeMemories !== false;
+                const brief = await buildAgentBrief({ includeMemories });
+                void logMcpActivity("read", "agent/brief", {
+                    format: briefArgs.format || "markdown",
+                    includeMemories,
+                });
+                if (briefArgs.format === "json") {
                     return {
                         content: [{
                                 type: "text",
-                                text: JSON.stringify(getYouJson(), null, 2),
+                                text: JSON.stringify(brief, null, 2),
                             }],
                     };
                 }
-                // compact (default) — matches whoami output
+                const maxChars = typeof briefArgs.maxChars === "number" && briefArgs.maxChars > 500
+                    ? Math.min(briefArgs.maxChars, 20000)
+                    : 6000;
                 return {
                     content: [{
                             type: "text",
-                            text: buildWhoamiSummary(),
+                            text: formatAgentBriefMarkdown(brief, maxChars),
                         }],
                 };
             }
-            case "get_section": {
-                const section = args.section;
-                const parts = section.split("/");
-                if (parts.length !== 2) {
-                    return { content: [{ type: "text", text: "invalid section path — use format: dir/slug (e.g., profile/about)" }], isError: true };
-                }
-                const filePath = path.join(getBundleDir(), parts[0], `${parts[1]}.md`);
-                const content = readFileOr(filePath, "");
-                if (!content) {
-                    return { content: [{ type: "text", text: `section not found: ${section}` }], isError: true };
-                }
-                void logMcpActivity("read_section", section);
-                return { content: [{ type: "text", text: content }] };
-            }
             case "update_section": {
                 const section = args.section;
                 const content = args.content;
@@ -926,78 +1491,7 @@ async function startMcpServer() {
                 void logMcpActivity("write", section);
                 return { content: [{ type: "text", text: `updated ${section}` }] };
             }
-            case "add_memory": {
-                const { category, content: memContent, tags } = args;
-                if (!(0, config_1.isAuthenticated)()) {
-                    return { content: [{ type: "text", text: "not authenticated — run youmd login first" }], isError: true };
-                }
-                // Validate category against known enum. Reject unknown categories so
-                // we don't pollute the memory store with one-off tags masquerading as
-                // categories.
-                if (!category || !MEMORY_CATEGORIES.includes(category)) {
-                    return {
-                        content: [{
-                                type: "text",
-                                text: `invalid category: ${category || "(missing)"}. valid categories: ${MEMORY_CATEGORIES.join(", ")}`,
-                            }],
-                        isError: true,
-                    };
-                }
-                try {
-                    const result = await apiRequest("/api/v1/me/memories", {
-                        method: "POST",
-                        body: {
-                            memories: [{
-                                    category,
-                                    content: memContent,
-                                    source: "mcp",
-                                    sourceAgent: "youmd-mcp",
-                                    tags,
-                                }],
-                        },
-                    });
-                    void logMcpActivity("memory_add", category);
-                    return { content: [{ type: "text", text: `memory saved: [${category}] ${memContent.slice(0, 80)}${memContent.length > 80 ? "..." : ""}` }] };
-                }
-                catch (err) {
-                    return { content: [{ type: "text", text: `failed to save memory: ${err instanceof Error ? err.message : "unknown error"}` }], isError: true };
-                }
-            }
-            case "search_memories": {
-                const { category, limit } = (args || {});
-                const memories = await fetchMemories(category, limit || 30);
-                void logMcpActivity("read", "memories");
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify(memories, null, 2),
-                        }],
-                };
-            }
-            case "get_project_context": {
-                const projectName = args?.project;
-                try {
-                    if (projectName) {
-                        const root = (0, project_1.findProjectsRoot)();
-                        if (!root)
-                            throw new Error("no projects directory found");
-                        const projDir = (0, project_1.getProjectDir)(root, projectName);
-                        const ctx = (0, project_1.readProjectContext)(projDir);
-                        void logMcpActivity("read", "project/" + projectName);
-                        return { content: [{ type: "text", text: JSON.stringify(ctx, null, 2) }] };
-                    }
-                    const current = getCurrentProject();
-                    if (!current) {
-                        return { content: [{ type: "text", text: "no project detected in current directory" }], isError: true };
-                    }
-                    const ctx = (0, project_1.readProjectContext)(current.dir);
-                    void logMcpActivity("read", "project/current");
-                    return { content: [{ type: "text", text: JSON.stringify(ctx, null, 2) }] };
-                }
-                catch (err) {
-                    return { content: [{ type: "text", text: `project error: ${err instanceof Error ? err.message : "unknown"}` }], isError: true };
-                }
-            }
+            // add_memory, search_memories, get_private_context — dispatched via registry (T14).
             case "add_project_memory": {
                 const { project: projName, category, content: memContent } = args;
                 try {
@@ -1022,17 +1516,7 @@ async function startMcpServer() {
                     return { content: [{ type: "text", text: `error: ${err instanceof Error ? err.message : "unknown"}` }], isError: true };
                 }
             }
-            case "use_skill": {
-                const skillName = args.name;
-                const skills = getInstalledSkills();
-                const skill = skills.find((s) => s.name === skillName);
-                if (!skill) {
-                    const available = skills.map((s) => s.name).join(", ") || "none installed";
-                    return { content: [{ type: "text", text: `skill not found: ${skillName}. available: ${available}` }], isError: true };
-                }
-                void logMcpActivity("skill_use", "skill/" + skillName);
-                return { content: [{ type: "text", text: skill.rendered || skill.raw }] };
-            }
+            // use_skill — dispatched via registry (T14).
             case "compile_bundle": {
                 try {
                     const { compileBundle, writeBundle } = await Promise.resolve().then(() => __importStar(require("../lib/compiler")));
@@ -1138,138 +1622,7 @@ async function startMcpServer() {
                     };
                 }
             }
-            case "list_skills": {
-                const skills = getInstalledSkills();
-                if (skills.length === 0) {
-                    return { content: [{ type: "text", text: "no skills installed. run: youmd skill install voice-sync" }] };
-                }
-                const list = skills.map((s) => `- ${s.name}`).join("\n");
-                void logMcpActivity("read", "skills");
-                return { content: [{ type: "text", text: `installed skills:\n${list}` }] };
-            }
-            case "add_source": {
-                if (!(0, config_1.isAuthenticated)()) {
-                    return { content: [{ type: "text", text: "not authenticated — run youmd login first" }], isError: true };
-                }
-                const { sourceType, sourceUrl } = args;
-                try {
-                    const result = await apiRequest("/api/v1/me/sources", {
-                        method: "POST",
-                        body: { sourceType, sourceUrl },
-                    });
-                    void logMcpActivity("write", "source/" + sourceType);
-                    return { content: [{ type: "text", text: `source registered: [${sourceType}] ${sourceUrl}` }] };
-                }
-                catch (err) {
-                    return { content: [{ type: "text", text: `failed to add source: ${err instanceof Error ? err.message : "unknown error"}` }], isError: true };
-                }
-            }
-            case "create_context_link": {
-                if (!(0, config_1.isAuthenticated)()) {
-                    return { content: [{ type: "text", text: "not authenticated — run youmd login first" }], isError: true };
-                }
-                const { scope, ttl } = (args || {});
-                try {
-                    const result = await apiRequest("/api/v1/me/context-links", {
-                        method: "POST",
-                        body: { scope: scope || "public", ttl: ttl || "24h" },
-                    });
-                    const link = result.url || result.link || JSON.stringify(result);
-                    void logMcpActivity("write", "context-link", { scope: scope || "public" });
-                    return { content: [{ type: "text", text: `context link created: ${link}\nscope: ${scope || "public"}, ttl: ${ttl || "24h"}` }] };
-                }
-                catch (err) {
-                    return { content: [{ type: "text", text: `failed to create context link: ${err instanceof Error ? err.message : "unknown error"}` }], isError: true };
-                }
-            }
-            case "list_projects": {
-                try {
-                    const root = (0, project_1.findProjectsRoot)();
-                    if (!root) {
-                        return { content: [{ type: "text", text: "no projects directory found" }], isError: true };
-                    }
-                    const projects = (0, project_1.listProjects)(root);
-                    if (projects.length === 0) {
-                        return { content: [{ type: "text", text: "no projects detected. create one with: youmd project init <name>" }] };
-                    }
-                    const current = getCurrentProject();
-                    const list = projects.map((p) => {
-                        const marker = current && current.name === p ? " (current)" : "";
-                        return `- ${p}${marker}`;
-                    }).join("\n");
-                    void logMcpActivity("read", "projects");
-                    return { content: [{ type: "text", text: `projects:\n${list}` }] };
-                }
-                catch (err) {
-                    return { content: [{ type: "text", text: `error listing projects: ${err instanceof Error ? err.message : "unknown"}` }], isError: true };
-                }
-            }
-            case "get_remote_status": {
-                const authenticated = (0, config_1.isAuthenticated)();
-                const bundleExists = (0, config_1.localBundleExists)();
-                const youJson = getYouJson();
-                const version = youJson?.version || "unknown";
-                const status = {
-                    authenticated,
-                    localBundleExists: bundleExists,
-                    localVersion: version,
-                };
-                if (authenticated) {
-                    try {
-                        const remote = await apiRequest("/api/v1/me/status");
-                        status.remote = remote;
-                    }
-                    catch {
-                        status.remote = "unreachable";
-                    }
-                }
-                void logMcpActivity("read", "status");
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify(status, null, 2),
-                        }],
-                };
-            }
-            case "get_activity_log": {
-                if (!(0, config_1.isAuthenticated)()) {
-                    return { content: [{ type: "text", text: "not authenticated — run youmd login first" }], isError: true };
-                }
-                const config = (0, config_1.readGlobalConfig)();
-                const params = new URLSearchParams();
-                const activityArgs = (args || {});
-                if (activityArgs.limit)
-                    params.set("limit", String(activityArgs.limit));
-                if (activityArgs.agentName)
-                    params.set("agent", String(activityArgs.agentName));
-                if (activityArgs.action)
-                    params.set("action", String(activityArgs.action));
-                const res = await fetch(`${(0, config_1.getConvexSiteUrl)()}/api/v1/me/activity?${params}`, {
-                    headers: { Authorization: `Bearer ${config.token}` },
-                    signal: AbortSignal.timeout(10000),
-                });
-                if (!res.ok) {
-                    return { content: [{ type: "text", text: `failed to fetch activity log: ${res.status}` }], isError: true };
-                }
-                const data = await res.json();
-                const events = data.activity || [];
-                if (events.length === 0) {
-                    return { content: [{ type: "text", text: "No activity yet. Agents will appear here when they connect to your you.md identity." }] };
-                }
-                const formatted = events.slice(0, 30).reverse().map((e) => {
-                    const time = new Date(e.createdAt).toTimeString().slice(0, 5);
-                    const versions = e.bundleVersionBefore && e.bundleVersionAfter
-                        ? ` v${e.bundleVersionBefore}→v${e.bundleVersionAfter}`
-                        : '';
-                    return `${time}  ${e.agentName.padEnd(16)}  ${e.action.padEnd(12)}  ${e.resource || ''}${versions}`;
-                }).join('\n');
-                return {
-                    content: [{
-                            type: "text",
-                            text: `── recent agent activity (${events.length} events) ──\n\n${formatted}`,
-                        }],
-                };
-            }
+            // add_source, create_context_link, get_remote_status, get_activity_log — dispatched via registry (T14).
             default:
                 throw new Error(`unknown tool: ${name}`);
         }