@blenau/mcp 0.1.0 → 0.2.0

package/dist/index.js

@@ -241,6 +241,7 @@ async function apiRequest(method, path, opts = {}) {
     Authorization: `Bearer ${token}`
   };
   if (opts.json !== void 0) headers["Content-Type"] = "application/json";
+  if (opts.workspace) headers["X-Blenau-Workspace"] = opts.workspace;
   let resp;
   try {
     resp = await fetch(url, {
@@ -263,6 +264,15 @@ async function apiRequest(method, path, opts = {}) {
       return { error: "api_error", status_code: resp.status, body: text3 };
     }
   }
+  const echoed = resp.headers.get("X-Blenau-Workspace");
+  if (opts.workspace && echoed && echoed !== opts.workspace) {
+    return {
+      error: "workspace_mismatch",
+      message: `Write targeted ${opts.workspace} but the server resolved ${echoed}. Aborting to avoid a cross-workspace mistake.`,
+      targeted: opts.workspace,
+      resolved: echoed
+    };
+  }
   if (resp.status === 204) return {};
   const text2 = await resp.text();
   if (!text2) return {};
@@ -273,12 +283,117 @@ async function apiRequest(method, path, opts = {}) {
   }
 }
 
+// src/workspace.ts
+var _active = null;
+var _anchor = null;
+var _cache = null;
+var _initialized = false;
+function isServiceMode() {
+  return detectMode() === "service";
+}
+async function listWorkspaces(refresh = false) {
+  if (_cache && !refresh) return _cache;
+  const res = await apiRequest("GET", "/workspaces");
+  if (!res || res.error || !Array.isArray(res.workspaces)) {
+    throw new Error(
+      typeof res?.error === "string" ? res.error : "could not list workspaces"
+    );
+  }
+  _cache = res.workspaces;
+  return _cache;
+}
+async function resolve(slugOrId) {
+  const find = (ws) => ws.find((w) => w.id === slugOrId || w.slug === slugOrId) ?? null;
+  let hit = find(await listWorkspaces());
+  if (!hit) hit = find(await listWorkspaces(true));
+  return hit;
+}
+async function ensureInit() {
+  if (_initialized || isServiceMode()) return;
+  _initialized = true;
+  const pin = process.env.BLENAU_WORKSPACE;
+  if (pin) {
+    const w = await resolve(pin);
+    if (w) {
+      _active = w;
+      _anchor = w;
+      return;
+    }
+  }
+  const all = await listWorkspaces();
+  const only = all[0];
+  if (all.length === 1 && only) {
+    _active = only;
+    _anchor = only;
+  }
+}
+function activeWorkspace() {
+  return _active;
+}
+function pinned() {
+  return !!process.env.BLENAU_WORKSPACE;
+}
+async function setActive(slugOrId, confirm = false) {
+  await ensureInit();
+  const w = await resolve(slugOrId);
+  if (!w) {
+    return { error: `Unknown workspace "${slugOrId}".`, workspaces: await listWorkspaces() };
+  }
+  const differsFromAnchor = !_anchor || _anchor.id !== w.id;
+  if (differsFromAnchor && !confirm) {
+    return {
+      status: "confirmation_required",
+      from: _anchor?.name ?? null,
+      to: w.name,
+      message: `Switch the write target to "${w.name}"${_anchor ? ` (currently "${_anchor.name}")` : ""}? Re-call with confirm:true. Reads don't need this \u2014 only writes go to the active workspace.`
+    };
+  }
+  _active = w;
+  if (!pinned()) _anchor = w;
+  return w;
+}
+async function readTarget(arg) {
+  await ensureInit();
+  if (arg) {
+    const w = await resolve(arg);
+    return w?.id ?? arg;
+  }
+  return _active?.id;
+}
+async function writeTarget(arg, confirm = false) {
+  await ensureInit();
+  let target = _active;
+  if (arg) {
+    const w = await resolve(arg);
+    if (!w) return { error: `Unknown workspace "${arg}".`, message: "Pick a valid workspace.", workspaces: await listWorkspaces() };
+    target = w;
+  }
+  if (!target) {
+    return {
+      message: "No active workspace. Choose one with set_active_workspace before writing.",
+      workspaces: (await listWorkspaces()).filter((w) => w.can_write)
+    };
+  }
+  const differsFromAnchor = !_anchor || _anchor.id !== target.id;
+  if (differsFromAnchor && !confirm) {
+    return {
+      status: "confirmation_required",
+      from: _anchor?.name ?? null,
+      to: target.name,
+      message: `About to write to "${target.name}"${_anchor ? ` but the active workspace is "${_anchor.name}"` : ""}. Re-call with confirm:true, or switch deliberately with set_active_workspace.`
+    };
+  }
+  return { id: target.id };
+}
+
 // src/server.ts
 var INSTRUCTIONS = `You are connected to a Blenau knowledge brain \u2014 a structured, versioned, provenance-tracked knowledge base shared across agents and humans.
 
 GOLDEN RULE \u2014 search FIRST, write LATER.
 Before calling ingest_document or crystallize_session, ALWAYS run search_knowledge with the topic(s) of the content you plan to write. The brain already holds docs on many subjects; creating a new file when one exists fragments the knowledge and degrades future searches.
 
+WORKSPACES \u2014 you may belong to several. Reads accept an optional \`workspace\` (slug or id) to look in a specific one; call list_workspaces() to see them. WRITES go to the ACTIVE workspace. To write in a different one, either switch deliberately with set_active_workspace (a visible checkpoint), or pass \`workspace\` + \`confirm:true\` on the write. Every write response is verified to have landed in the intended workspace \u2014 if you get a workspace_mismatch or confirmation_required, do NOT retry blindly; surface it to the user.
+
 Routing: a workspace can have several connected GitHub repos, each with a path_prefix. Call list_repos() BEFORE writing to a specific repo and prefix your path accordingly. Edits use optimistic locking: fetch get_section right before edit_section and pass expected_version. For images/binaries prefer create_asset_upload (stream bytes via curl) over upload_asset (base64, tiny icons only). Always cite external material via the sources argument.`;
 var sourceSchema = z.array(
   z.object({
@@ -288,180 +403,238 @@ var sourceSchema = z.array(
     retrieved_at: z.string().optional()
   })
 ).optional();
+var wsArg = z.string().optional().describe("Workspace slug or id to act in. Reads roam freely; writes require confirm when it differs from the active workspace.");
+var confirmArg = z.boolean().optional().describe("Set true to confirm a write to a workspace other than the active one.");
 function text(result) {
   return { content: [{ type: "text", text: JSON.stringify(result) }] };
 }
+async function rd(method, path, opts = {}, argWorkspace) {
+  if (isServiceMode()) return apiRequest(method, path, opts);
+  const workspace = await readTarget(argWorkspace);
+  return apiRequest(method, path, { ...opts, workspace });
+}
+async function wr(method, path, opts = {}, argWorkspace, confirm) {
+  if (isServiceMode()) return apiRequest(method, path, opts);
+  const target = await writeTarget(argWorkspace, confirm);
+  if (!("id" in target)) return target;
+  return apiRequest(method, path, { ...opts, workspace: target.id });
+}
 function buildServer() {
   const server = new McpServer(
-    { name: "Blenau", version: "0.1.0" },
+    { name: "Blenau", version: "0.2.0" },
     { instructions: INSTRUCTIONS }
   );
   server.tool(
-    "list_repos",
-    "List all GitHub repos connected to this workspace. Returns each repo with id, repo (org/name), label, path_prefix, installation_id, doc_count, created_at. Call this BEFORE writing (ingest_document, crystallize_session, smart_crystallize) when you intend to land content in a specific repo \u2014 your path must start with that repo's path_prefix. Read-only.",
+    "list_workspaces",
+    "List the workspaces you belong to, with your role and whether you can write in each, and which is currently active. Call this to discover where you can read/write. Read-only.",
     {},
-    async () => text(await apiRequest("GET", "/github/repos"))
+    async () => {
+      if (isServiceMode()) return text(await apiRequest("GET", "/workspaces"));
+      const workspaces = await listWorkspaces(true);
+      const active = activeWorkspace();
+      return text({ active: active?.id ?? null, active_name: active?.name ?? null, workspaces });
+    }
+  );
+  server.tool(
+    "set_active_workspace",
+    "Set the ACTIVE workspace \u2014 where writes go. Switching to a workspace other than the current one needs confirm:true (the switch is a visible checkpoint). Reads don't need this. In service mode the workspace is pinned by the token.",
+    { workspace: z.string(), confirm: z.boolean().optional() },
+    async ({ workspace, confirm }) => {
+      if (isServiceMode()) return text({ error: "workspace pinned by service token" });
+      return text(await setActive(workspace, confirm ?? false));
+    }
+  );
+  server.tool(
+    "list_repos",
+    "List all GitHub repos connected to a workspace. Returns each repo with id, repo (org/name), label, path_prefix, installation_id, doc_count, created_at. Call this BEFORE writing to land content in a specific repo. Read-only.",
+    { workspace: wsArg },
+    async ({ workspace }) => text(await rd("GET", "/github/repos", {}, workspace))
   );
   server.tool(
     "search_knowledge",
     "Search the knowledge base semantically. Returns ranked results with relevance scores.",
-    { query: z.string(), top_k: z.number().int().default(10) },
-    async ({ query, top_k }) => text(await apiRequest("POST", "/knowledge/search", { json: { query, top_k } }))
+    { query: z.string(), top_k: z.number().int().default(10), workspace: wsArg },
+    async ({ query, top_k, workspace }) => text(await rd("POST", "/knowledge/search", { json: { query, top_k } }, workspace))
   );
   server.tool(
     "get_document",
     "Get a document by its path, including all sections.",
-    { path: z.string() },
-    async ({ path }) => text(await apiRequest("GET", `/knowledge/documents/by-path/${path}`))
+    { path: z.string(), workspace: wsArg },
+    async ({ path, workspace }) => text(await rd("GET", `/knowledge/documents/by-path/${path}`, {}, workspace))
   );
   server.tool(
     "get_document_structure",
     "Get the outline (headings tree) of a document without full content.",
-    { path: z.string() },
-    async ({ path }) => text(await apiRequest("GET", `/knowledge/structure/${path}`))
+    { path: z.string(), workspace: wsArg },
+    async ({ path, workspace }) => text(await rd("GET", `/knowledge/structure/${path}`, {}, workspace))
   );
   server.tool(
     "get_section",
     "Get a specific section by path and heading. Returns content + version hash for editing.",
-    { path: z.string(), heading: z.string() },
-    async ({ path, heading }) => text(await apiRequest("GET", `/knowledge/section/${path}`, { params: { heading } }))
+    { path: z.string(), heading: z.string(), workspace: wsArg },
+    async ({ path, heading, workspace }) => text(await rd("GET", `/knowledge/section/${path}`, { params: { heading } }, workspace))
+  );
+  server.tool(
+    "list_documents",
+    "List all documents in the knowledge base with their status.",
+    { workspace: wsArg },
+    async ({ workspace }) => text(await rd("GET", "/knowledge/documents", {}, workspace))
+  );
+  server.tool(
+    "list_assets",
+    "List the image references in a doc and whether each resolves in GitHub. Returns { doc_path, doc_id, assets: [...] }.",
+    { doc_path: z.string(), workspace: wsArg },
+    async ({ doc_path, workspace }) => text(await rd("GET", "/assets/list", { params: { doc_path } }, workspace))
+  );
+  server.tool(
+    "verify_asset",
+    "Check that ONE asset reference resolves (exists in GitHub \u2192 will render). relative_path is the path exactly as written in the markdown. Returns { resolves, asset_path, raw_url }.",
+    { doc_path: z.string(), relative_path: z.string(), workspace: wsArg },
+    async ({ doc_path, relative_path, workspace }) => text(await rd("GET", "/assets/resolve", { params: { doc_path, relative_path } }, workspace))
+  );
+  server.tool(
+    "audit_links",
+    "Audit the knowledge base for orphan documents, one-way links, unlinked-but-similar pairs, docs missing citations, and recurring concepts lacking a doc. Read-only.",
+    { workspace: wsArg },
+    async ({ workspace }) => text(await rd("GET", "/github/audit-links", {}, workspace))
+  );
+  server.tool(
+    "suggest_crosslinks",
+    "Suggest markdown cross-links to add in a specific document. Returns the top 5 semantically-similar sections from other documents not currently linked, with ready-to-paste snippets. Read-only.",
+    { path: z.string(), workspace: wsArg },
+    async ({ path, workspace }) => {
+      const doc = await rd("GET", `/knowledge/documents/by-path/${path}`, {}, workspace);
+      if (!doc || typeof doc !== "object" || "error" in doc) return text(doc ?? { error: "lookup_failed" });
+      const docId = doc.id ?? doc.document_id;
+      if (!docId) return text({ error: `Document not found: ${path}` });
+      const out = await rd("GET", `/github/suggest-crosslinks/${docId}`, {}, workspace);
+      if (out && typeof out === "object" && "suggestions" in out && !("document_path" in out)) {
+        out.document_path = path;
+      }
+      return text(out);
+    }
+  );
+  server.tool(
+    "get_audit_log",
+    "Get the audit log for a workspace. Shows who did what and when.",
+    { limit: z.number().int().default(50), event_type: z.string().optional(), workspace: wsArg },
+    async ({ limit, event_type, workspace }) => text(
+      await rd(
+        "GET",
+        "/knowledge/audit-log",
+        { params: { limit, ...event_type ? { event_type } : {} } },
+        workspace
+      )
+    )
   );
   server.tool(
     "ingest_document",
-    "Ingest a document into the knowledge base. Runs full pipeline (parse, chunk, embed, index). Routing: path matches a connected repo by longest path_prefix; call list_repos() first to discover prefixes. auto_link=True rewrites bare textual mentions of known document paths into markdown links. sources: list of {type, ref, title?, retrieved_at?} describing external material; appended as a `## Fuentes` section and stored in provenance.",
+    "Ingest a document into the knowledge base (parse, chunk, embed, index). Routing: path matches a connected repo by longest path_prefix; call list_repos() first. auto_link rewrites bare mentions into links. sources: external material appended as a `## Fuentes` section. Writes go to the active workspace.",
     {
       path: z.string(),
       title: z.string(),
       content: z.string(),
       source_type: z.string().default("manual"),
       auto_link: z.boolean().default(false),
-      sources: sourceSchema
+      sources: sourceSchema,
+      workspace: wsArg,
+      confirm: confirmArg
     },
-    async ({ path, title, content, source_type, auto_link, sources }) => text(
-      await apiRequest("POST", "/knowledge/ingest-enhanced", {
-        json: { path, title, content, source_type, auto_link, sources: sources ?? null }
-      })
+    async ({ path, title, content, source_type, auto_link, sources, workspace, confirm }) => text(
+      await wr(
+        "POST",
+        "/knowledge/ingest-enhanced",
+        { json: { path, title, content, source_type, auto_link, sources: sources ?? null } },
+        workspace,
+        confirm
+      )
     )
   );
   server.tool(
     "crystallize_session",
-    "Crystallize knowledge from an agent session into a single structured document. DEPRECATED for multi-topic sessions \u2014 prefer smart_crystallize. output_path is the folder under which the file is created (default docs/crystallized); prefix it with the target repo's path_prefix in multi-repo workspaces. sources: same shape as ingest_document.sources.",
+    "Crystallize a session into a single structured document. Prefer smart_crystallize for multi-topic sessions. output_path is the folder (default docs/crystallized). Writes go to the active workspace.",
     {
       session_context: z.string(),
       title: z.string().default("Crystallized Knowledge"),
       output_path: z.string().default("docs/crystallized"),
-      sources: sourceSchema
-    },
-    async ({ session_context, title, output_path, sources }) => text(
-      await apiRequest("POST", "/knowledge/crystallize-enhanced", {
-        json: { session_context, title, output_path, sources: sources ?? null }
-      })
-    )
-  );
-  server.tool(
-    "create_asset_upload",
-    'PREFERRED way to attach an image / PDF / binary to a doc. Returns a short-lived upload_url; transfer the LOCAL file with one curl command so bytes never pass through you (e.g. `curl -F file=@/path/img.webp "<upload_url>"`; add -F insert_heading / -F insert_position to embed). Asset names are predictable (assets/<filename>); a content hash is appended only on a real collision. Embedding is idempotent. Size limit 1 MB \u2014 compress locally first if larger. Params: doc_path (routes the commit), filename, content_type (optional MIME).',
-    { doc_path: z.string(), filename: z.string(), content_type: z.string().default("") },
-    async ({ doc_path, filename, content_type }) => text(
-      await apiRequest("POST", "/assets/upload-url", {
-        params: { doc_path, filename, content_type }
-      })
-    )
-  );
-  server.tool(
-    "list_assets",
-    "List the image references in a doc and whether each resolves in GitHub. Returns { doc_path, doc_id, assets: [...] }. resolves:false means the markdown points at a path that isn't committed (the usual broken-image cause).",
-    { doc_path: z.string() },
-    async ({ doc_path }) => text(await apiRequest("GET", "/assets/list", { params: { doc_path } }))
-  );
-  server.tool(
-    "verify_asset",
-    "Check that ONE asset reference resolves (exists in GitHub \u2192 will render). relative_path is the path exactly as written in the markdown (e.g. assets/diagram.webp). Returns { resolves, asset_path, raw_url }.",
-    { doc_path: z.string(), relative_path: z.string() },
-    async ({ doc_path, relative_path }) => text(await apiRequest("GET", "/assets/resolve", { params: { doc_path, relative_path } }))
-  );
-  server.tool(
-    "delete_asset",
-    "Delete an asset FILE from the repo. Does NOT rewrite document references \u2014 if the doc still links it, remove that markdown separately via edit_section. relative_path is the path as written in the markdown. Returns { deleted, asset_path }.",
-    { doc_path: z.string(), relative_path: z.string() },
-    async ({ doc_path, relative_path }) => text(await apiRequest("DELETE", "/assets/file", { params: { doc_path, relative_path } }))
-  );
-  server.tool(
-    "upload_asset",
-    "LEGACY base64 upload \u2014 TINY assets only (<= 64 KB, e.g. a small SVG icon). For photos/screenshots or anything larger, use create_asset_upload instead. Commits the asset under an assets/ subdirectory of the doc's repo and returns a markdown snippet with a RELATIVE path. Params: doc_path, filename, content_base64 (data-URL prefix accepted), alt_text.",
-    {
-      doc_path: z.string(),
-      filename: z.string(),
-      content_base64: z.string(),
-      alt_text: z.string().default("")
+      sources: sourceSchema,
+      workspace: wsArg,
+      confirm: confirmArg
     },
-    async ({ doc_path, filename, content_base64, alt_text }) => text(
-      await apiRequest("POST", "/assets/upload", {
-        json: { doc_path, filename, content_base64, alt_text }
-      })
+    async ({ session_context, title, output_path, sources, workspace, confirm }) => text(
+      await wr(
+        "POST",
+        "/knowledge/crystallize-enhanced",
+        { json: { session_context, title, output_path, sources: sources ?? null } },
+        workspace,
+        confirm
+      )
     )
   );
   server.tool(
     "smart_crystallize",
-    "Intelligently crystallize a session into the brain. Splits the session into topical blocks, searches existing docs per topic, and routes each block to edit/append/create. Opens ONE PR PER AFFECTED REPO if repos are connected. Prefer this over crystallize_session whenever the session spans multiple subjects. Call list_repos() first to nudge create paths toward the right path_prefix.",
-    { session_context: z.string(), repo_hint: z.string().optional() },
-    async ({ session_context, repo_hint }) => text(
-      await apiRequest("POST", "/knowledge/smart-crystallize", {
-        json: { session_context, repo_hint: repo_hint ?? null }
-      })
+    "Intelligently crystallize a session: split into topical blocks, search existing docs per topic, route each to edit/append/create. Opens one PR per affected repo. Writes go to the active workspace.",
+    { session_context: z.string(), repo_hint: z.string().optional(), workspace: wsArg, confirm: confirmArg },
+    async ({ session_context, repo_hint, workspace, confirm }) => text(
+      await wr(
+        "POST",
+        "/knowledge/smart-crystallize",
+        { json: { session_context, repo_hint: repo_hint ?? null } },
+        workspace,
+        confirm
+      )
     )
   );
-  server.tool(
-    "list_documents",
-    "List all documents in the knowledge base with their status.",
-    {},
-    async () => text(await apiRequest("GET", "/knowledge/documents"))
-  );
   server.tool(
     "edit_section",
-    "Edit a section with optimistic locking. Pass the version from get_section to prevent conflicts.",
+    "Edit a section with optimistic locking. Pass the version from get_section to prevent conflicts. Writes go to the active workspace.",
     {
       path: z.string(),
       heading: z.string(),
       new_content: z.string(),
-      expected_version: z.string()
+      expected_version: z.string(),
+      workspace: wsArg,
+      confirm: confirmArg
     },
-    async ({ path, heading, new_content, expected_version }) => text(
-      await apiRequest("POST", "/knowledge/edit-section", {
-        json: { path, heading, new_content, expected_version }
-      })
+    async ({ path, heading, new_content, expected_version, workspace, confirm }) => text(
+      await wr(
+        "POST",
+        "/knowledge/edit-section",
+        { json: { path, heading, new_content, expected_version } },
+        workspace,
+        confirm
+      )
     )
   );
   server.tool(
-    "audit_links",
-    "Audit the knowledge base for orphan documents, one-way links, pairs of documents with high semantic similarity that are not linked in markdown, documents missing source citations, and recurring concepts that lack their own dedicated doc. Returns orphan_documents, one_way_only, similar_but_unlinked, missing_sources, data_gaps. Read-only.",
-    {},
-    async () => text(await apiRequest("GET", "/github/audit-links"))
+    "create_asset_upload",
+    'PREFERRED way to attach an image/PDF/binary. Returns a short-lived upload_url; transfer the LOCAL file with one curl command (e.g. `curl -F file=@/path/img.webp "<upload_url>"`). Size limit 1 MB. The workspace is sealed into the upload_url at mint. Writes go to the active workspace.',
+    { doc_path: z.string(), filename: z.string(), content_type: z.string().default(""), workspace: wsArg, confirm: confirmArg },
+    async ({ doc_path, filename, content_type, workspace, confirm }) => text(
+      await wr("POST", "/assets/upload-url", { params: { doc_path, filename, content_type } }, workspace, confirm)
+    )
   );
   server.tool(
-    "suggest_crosslinks",
-    "Suggest markdown cross-links to add in a specific document. Returns the top 5 semantically-similar sections from other documents that aren't currently linked from this doc, with ready-to-paste markdown snippets. Read-only.",
-    { path: z.string() },
-    async ({ path }) => {
-      const doc = await apiRequest("GET", `/knowledge/documents/by-path/${path}`);
-      if (!doc || typeof doc !== "object" || "error" in doc) return text(doc ?? { error: "lookup_failed" });
-      const docId = doc.id ?? doc.document_id;
-      if (!docId) return text({ error: `Document not found: ${path}` });
-      const out = await apiRequest("GET", `/github/suggest-crosslinks/${docId}`);
-      if (out && typeof out === "object" && "suggestions" in out && !("document_path" in out)) {
-        out.document_path = path;
-      }
-      return text(out);
-    }
+    "upload_asset",
+    "LEGACY base64 upload \u2014 TINY assets only (<= 64 KB). For anything larger use create_asset_upload. Writes go to the active workspace.",
+    {
+      doc_path: z.string(),
+      filename: z.string(),
+      content_base64: z.string(),
+      alt_text: z.string().default(""),
+      workspace: wsArg,
+      confirm: confirmArg
+    },
+    async ({ doc_path, filename, content_base64, alt_text, workspace, confirm }) => text(
+      await wr("POST", "/assets/upload", { json: { doc_path, filename, content_base64, alt_text } }, workspace, confirm)
+    )
   );
   server.tool(
-    "get_audit_log",
-    "Get the audit log for this workspace. Shows who did what and when.",
-    { limit: z.number().int().default(50), event_type: z.string().optional() },
-    async ({ limit, event_type }) => text(
-      await apiRequest("GET", "/knowledge/audit-log", {
-        params: { limit, ...event_type ? { event_type } : {} }
-      })
+    "delete_asset",
+    "Delete an asset FILE from the repo. Does NOT rewrite document references. relative_path is the path as written in the markdown. Writes go to the active workspace.",
+    { doc_path: z.string(), relative_path: z.string(), workspace: wsArg, confirm: confirmArg },
+    async ({ doc_path, relative_path, workspace, confirm }) => text(
+      await wr("DELETE", "/assets/file", { params: { doc_path, relative_path } }, workspace, confirm)
     )
   );
   return server;
@@ -473,7 +646,7 @@ async function runStdioServer() {
 }
 
 // src/index.ts
-var VERSION = "0.1.0";
+var VERSION = "0.2.0";
 function rejectInService(action) {
   if (detectMode() === "service") {
     process.stderr.write(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blenau/mcp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Blenau MCP server + CLI. Connects agents (Claude Code, Cursor, …) to the Blenau knowledge brain over stdio, with credentials in the OS keychain — never a token in a config file or URL.",
   "type": "module",
   "repository": {
@@ -13,7 +13,7 @@
   },
   "author": "Blenau (Ganemo)",
   "bin": {
-    "blenau": "dist/index.js"
+    "blenau-mcp": "dist/index.js"
   },
   "main": "dist/index.js",
   "files": [