@paigy/mcp 0.38.0 → 0.40.1

package/dist/{chunk-4UEL7Y5U.js → chunk-CXABA27N.js}

@@ -10,7 +10,7 @@ import {
   saveToken,
   sleep,
   startE2ee
-} from "./chunk-PPACGOTU.js";
+} from "./chunk-4UZAPBKK.js";
 
 // src/identity.ts
 var CLIENT_LABELS = {

package/dist/chunk-TLASZUJD.js

@@ -0,0 +1,224 @@
+import {
+  AGENT_TOOLS,
+  mcpInputSchema,
+  serverInstructions
+} from "./chunk-3QUIB42M.js";
+import {
+  AGENT_NAME
+} from "./chunk-4UZAPBKK.js";
+
+// src/toolset.ts
+var ONBOARD_DESCRIPTION = "Get this agent talking to Paigy \u2014 call it FIRST, before contact, and any time you're unsure who you are. One call, and it does whatever the situation needs: NOT SET UP \u2192 hatches an identity instantly if this machine holds a device credential (the user ran the Paigy desktop app or harness), otherwise starts the code ceremony; ALREADY SET UP \u2192 returns your current identity and offers the two things left to decide, renaming it or unpairing; TOKEN NO LONGER VALID \u2192 says so, then re-pairs. Pass { name, voice } to choose who you are when hatching, or to RENAME yourself when already set up (voices: rachel, george, jessica, brian, lily). Safe to call any time: idempotent, and it never writes settings \u2014 the tool-allowlist state it reports is read-only. If it returns a `user_code`, print it to the user immediately and call onboard again with the `device_code`. If it returns `enable_command`, PRINT that command for the user to run \u2014 you cannot apply it yourself (it writes your own permission allowlist, which hosts block as privilege escalation), so print it, don't wait for it, and carry on.";
+var SERVER_INSTRUCTIONS = serverInstructions({ waits: true });
+
+// src/tools.ts
+import { z } from "zod";
+var OnboardSchema = z.object({
+  name: z.string().max(60).optional(),
+  voice: z.string().max(40).optional(),
+  /** Continue a code ceremony already in flight — same meaning as `pair`'s. */
+  device_code: z.string().optional(),
+  /** Which allowlist to REPORT on (never written by `start`). */
+  scope: z.enum(["user", "project"]).optional()
+});
+var PairSchema = z.object({
+  device_code: z.string().optional().describe("Omit to start pairing (returns an approval link to show the user). Pass the device_code from that first call to finish, once the user has approved."),
+  name: z.string().min(1).max(60).optional().describe("Hatch path only: the name you choose for this identity. Pick your own \u2014 ONE or TWO words, the way you'd introduce yourself on a call (it is spoken aloud and shown in lists). 'Piper', 'Blue Heron' \u2014 never a sentence or a task description."),
+  voice: z.string().optional().describe("Hatch path only: your voice on calls \u2014 one of rachel, george, jessica, brian, lily.")
+});
+var IDENTITY_TOOLS = [
+  {
+    // ONE rail for starting a session (#875). `pair`, the `paigy-mcp-onboard` CLI and
+    // `enable_tools` were three doors into one flow, and "onboard" was the word people
+    // reached for attached to the tool that did the least. It's the door now.
+    name: "onboard",
+    description: ONBOARD_DESCRIPTION,
+    inputSchema: mcpInputSchema(OnboardSchema)
+  },
+  {
+    name: "pair",
+    description: "Pair this agent with the user's Paigy account (one-time) \u2014 required before contact work. FAST PATH: if this machine already holds a device credential (the user ran the Paigy desktop harness or app), calling pair hatches a fresh identity INSTANTLY \u2014 no code, no approval. Pass { name, voice } to choose who you are (pick your own; voices: rachel, george, jessica, brian, lily). Only when no device credential exists does the code ceremony below run. It does NOT open a browser; the user enters the code in the Paigy app (or scans `qr`). Step 1: call with NO args \u2014 returns { user_code, device_code, qr, user_message } AND starts polling for approval in the background. REQUIRED: You MUST immediately print the `user_message` (the bare code) as a text message to the user, AND in that same turn call step 2 (pair with the device_code). This ensures the user sees the code in chat while the tool blocks/polls in the background for approval. Step 2: call with that device_code to collect the result. Because approval is already being polled in the background, this returns the moment the user approves; on { status:'pending' } just call again to keep waiting; on { status:'awaiting_confirmation' } (E2EE) show the bare `user_message` verify code and call again to finish. The leading text block of every result states the code plainly, so it shows even if you emit no prose. On { status:'paired' } ALWAYS follow the `enable_prompt` \u2014 PRINT the returned `enable_command` so the user can allowlist Paigy's tools and notify/await stop prompting each time. Printing is the whole job: that command writes your own permission allowlist, so you must not run it and a host will block you if you try.",
+    inputSchema: mcpInputSchema(PairSchema)
+  },
+  {
+    name: "unpair",
+    description: "Log out / unpair this agent from the user's Paigy account: revokes the token server-side (it stops working everywhere) and deletes the local ~/.paigy/token.json. Takes no arguments. After this, contact won't work until the user pairs again with the pair tool.",
+    inputSchema: mcpInputSchema(z.object({}))
+  }
+];
+var TOOLS = [...AGENT_TOOLS, ...IDENTITY_TOOLS];
+var TOOL_NAMES = TOOLS.map((t) => t.name);
+var HIDDEN_ALIASES = [];
+
+// src/clients.ts
+import { execFile } from "child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir, platform } from "os";
+import { join, dirname } from "path";
+function openBrowser(url) {
+  const cmd = platform() === "darwin" ? "open" : platform() === "win32" ? "cmd" : "xdg-open";
+  const args = platform() === "win32" ? ["/c", "start", url] : [url];
+  execFile(cmd, args, () => {
+  });
+}
+function withPaigyMcpJson(existing, agent) {
+  let config = {};
+  if (existing) {
+    try {
+      config = JSON.parse(existing);
+    } catch {
+      return null;
+    }
+  }
+  config.mcpServers = {
+    ...config.mcpServers ?? {},
+    paigy: { command: "npx", args: ["-y", "@paigy/mcp@latest"], env: { PAIGY_AGENT: agent } }
+  };
+  return JSON.stringify(config, null, 2);
+}
+function withPaigyMcpToml(existing, agent) {
+  if (existing.includes("[mcp_servers.paigy]")) return null;
+  const entry = [
+    "",
+    "[mcp_servers.paigy]",
+    'command = "npx"',
+    'args = ["-y", "@paigy/mcp@latest"]',
+    `env = { PAIGY_AGENT = "${agent}" }`,
+    ""
+  ].join("\n");
+  return existing + entry;
+}
+function autoConfigureClients(skip = AGENT_NAME) {
+  const home = homedir();
+  const registered = [];
+  if (skip !== "antigravity") {
+    const antigravityConfigs = [
+      join(home, ".gemini", "config", "mcp_config.json"),
+      join(home, ".gemini", "antigravity-cli", "mcp_config.json")
+    ];
+    for (const path of antigravityConfigs) {
+      try {
+        if (!existsSync(dirname(path))) continue;
+        const existing = existsSync(path) ? readFileSync(path, "utf8") : null;
+        const updated = withPaigyMcpJson(existing, "antigravity");
+        if (updated === null) continue;
+        writeFileSync(path, updated);
+        registered.push(`Google Antigravity (${path})`);
+      } catch {
+      }
+    }
+  }
+  if (skip !== "codex") {
+    const codexConfig = join(home, ".codex", "config.toml");
+    try {
+      if (existsSync(dirname(codexConfig))) {
+        const existing = existsSync(codexConfig) ? readFileSync(codexConfig, "utf8") : "";
+        const updated = withPaigyMcpToml(existing, "codex");
+        if (updated !== null) {
+          writeFileSync(codexConfig, updated);
+          registered.push(`OpenAI Codex (${codexConfig})`);
+        }
+      }
+    } catch {
+    }
+  }
+  return registered;
+}
+function claudeInstallHint(skip = AGENT_NAME) {
+  if (skip.startsWith("claude")) return null;
+  const claudeDir = join(homedir(), ".claude");
+  if (!existsSync(claudeDir)) return null;
+  try {
+    const registry = join(claudeDir, "plugins", "installed_plugins.json");
+    if (existsSync(registry) && readFileSync(registry, "utf8").includes('"paigy@')) return null;
+  } catch {
+  }
+  return "Claude Code detected \u2014 to add Paigy there, run /plugin marketplace add paigy-ai/mcp then /plugin install paigy (pairing carries over; no need to pair again). Note: If you run this inside a live session, type /reload-plugins afterward so the agent connects to the new tools.";
+}
+var ENABLE_COMMAND = "npx -y -p @paigy/mcp@latest paigy-enable-tools";
+var PROMPTS_ON_PURPOSE = /* @__PURE__ */ new Set(["pair", "unpair"]);
+var PAIGY_TOOL_IDS = [
+  ...TOOL_NAMES.filter((n) => !PROMPTS_ON_PURPOSE.has(n)),
+  ...HIDDEN_ALIASES
+].map((n) => `mcp__paigy__${n}`);
+function withPaigyAllowlist(existing, tools) {
+  let config = {};
+  if (existing) {
+    try {
+      config = JSON.parse(existing);
+    } catch {
+      return null;
+    }
+  }
+  const permissions = config.permissions && typeof config.permissions === "object" ? config.permissions : {};
+  const allow = Array.isArray(permissions.allow) ? [...permissions.allow] : [];
+  for (const t of tools) if (!allow.includes(t)) allow.push(t);
+  config.permissions = { ...permissions, allow };
+  return JSON.stringify(config, null, 2);
+}
+function settingsPathFor(scope, cwd) {
+  return scope === "project" ? join(cwd, ".claude", "settings.json") : join(homedir(), ".claude", "settings.json");
+}
+function paigyToolsAllowlisted(scope = "user", cwd = process.cwd()) {
+  try {
+    const path = settingsPathFor(scope, cwd);
+    if (!path || !existsSync(path)) return false;
+    const config = JSON.parse(readFileSync(path, "utf8"));
+    const allow = Array.isArray(config.permissions?.allow) ? config.permissions.allow : [];
+    return PAIGY_TOOL_IDS.every((t) => allow.includes(t));
+  } catch {
+    return false;
+  }
+}
+function enablePaigyTools(scope = "user", cwd = process.cwd()) {
+  if (scope === "user" && !existsSync(join(homedir(), ".claude"))) {
+    return {
+      ok: false,
+      reason: `No ~/.claude on this machine \u2014 the hosting tool uses its own permission allowlist. Add these ids there by hand: ${PAIGY_TOOL_IDS.join(", ")}.`
+    };
+  }
+  const path = settingsPathFor(scope, cwd);
+  let existing = null;
+  try {
+    existing = existsSync(path) ? readFileSync(path, "utf8") : null;
+  } catch {
+    existing = null;
+  }
+  let prevAllow = [];
+  if (existing) {
+    try {
+      const parsed = JSON.parse(existing);
+      if (Array.isArray(parsed.permissions?.allow)) prevAllow = parsed.permissions.allow;
+    } catch {
+      return { ok: false, reason: `${path} didn't parse as JSON \u2014 not overwriting it. Add the ids by hand.` };
+    }
+  }
+  const updated = withPaigyAllowlist(existing, PAIGY_TOOL_IDS);
+  if (updated === null) return { ok: false, reason: `${path} didn't parse as JSON \u2014 not overwriting it. Add the ids by hand.` };
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, updated + "\n");
+  } catch (e) {
+    return { ok: false, reason: `Couldn't write ${path}: ${e.message}` };
+  }
+  return {
+    ok: true,
+    path,
+    added: PAIGY_TOOL_IDS.filter((t) => !prevAllow.includes(t)),
+    already: PAIGY_TOOL_IDS.filter((t) => prevAllow.includes(t))
+  };
+}
+
+export {
+  SERVER_INSTRUCTIONS,
+  OnboardSchema,
+  PairSchema,
+  TOOLS,
+  openBrowser,
+  autoConfigureClients,
+  claudeInstallHint,
+  ENABLE_COMMAND,
+  PAIGY_TOOL_IDS,
+  paigyToolsAllowlisted,
+  enablePaigyTools
+};

package/dist/enable.js

@@ -2,9 +2,9 @@
 import {
   PAIGY_TOOL_IDS,
   enablePaigyTools
-} from "./chunk-7IGGSB3H.js";
-import "./chunk-KE63GZEQ.js";
-import "./chunk-PPACGOTU.js";
+} from "./chunk-TLASZUJD.js";
+import "./chunk-3QUIB42M.js";
+import "./chunk-4UZAPBKK.js";
 
 // src/enable.ts
 function main() {

package/dist/index.js

@@ -1,74 +1,44 @@
 #!/usr/bin/env node
-import {
-  awaitMessage,
-  contactMessage
-} from "./chunk-UG2FARVV.js";
 import {
   clearPairing,
   joinBackgroundPair,
   resolvePairing,
   startPairing,
   suggestedAgentName
-} from "./chunk-4UEL7Y5U.js";
+} from "./chunk-CXABA27N.js";
 import {
-  AnswerCallerQuestionSchema,
-  AwaitReplySchema,
-  ClaimGoalSchema,
   ENABLE_COMMAND,
-  GetThreadSchema,
   OnboardSchema,
   PAIGY_TOOL_IDS,
   PairSchema,
   SERVER_INSTRUCTIONS,
-  SearchThreadsSchema,
-  SetTaskStateToolSchema,
   TOOLS,
-  UpdateGoalToolSchema,
   autoConfigureClients,
   claudeInstallHint,
   paigyToolsAllowlisted
-} from "./chunk-7IGGSB3H.js";
-import {
-  CreateGoalSchema,
-  HandoffSchema
-} from "./chunk-KE63GZEQ.js";
+} from "./chunk-TLASZUJD.js";
+import "./chunk-3QUIB42M.js";
 import {
   clearSurface,
   writeSurface
 } from "./chunk-3SVNPJPN.js";
 import {
   AGENT_NAME,
-  NotifyRequestSchema,
-  ScheduleCallbackSchema,
-  SetWorkStateSchema,
   UnpairedError,
-  answerCallerQuestion,
-  awaitReply2,
-  checkReplies,
-  claimGoal,
-  contactParentId,
-  createGoal,
   deleteKeyFile,
   deleteToken,
-  getThread,
-  handoff,
   hatch,
   heartbeat,
   listSlots,
   overrideToken,
   readToken,
   revokeToken,
+  runTool,
   saveToken,
-  scheduleCallback,
-  searchThreads,
   setIdentity,
-  setTaskState,
-  setWorkState,
   slotName,
-  submitNotification,
-  updateGoal,
   whoAmI
-} from "./chunk-PPACGOTU.js";
+} from "./chunk-4UZAPBKK.js";
 
 // src/index.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -77,36 +47,8 @@ import {
   CallToolRequestSchema,
   ListToolsRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
-import { execSync } from "child_process";
 import qrcode from "qrcode-generator";
 var JOIN_CAP_MS = 45e3;
-function fixAndRetry(err) {
-  const msg = String(err?.message ?? err);
-  const m = msg.match(/^notify failed: 422 (\{[\s\S]*\})$/);
-  if (!m) return null;
-  try {
-    const body = JSON.parse(m[1]);
-    return body.error === "fix_and_retry" ? { error: "fix_and_retry", problems: body.problems ?? [] } : null;
-  } catch {
-    return null;
-  }
-}
-function detectGit() {
-  const run = (cmd) => {
-    try {
-      return execSync(cmd, { stdio: ["ignore", "pipe", "ignore"], encoding: "utf8" }).trim();
-    } catch {
-      return "";
-    }
-  };
-  const remote = run("git remote get-url origin");
-  const match = remote.match(/[:/]([^/:]+\/[^/]+?)(?:\.git)?$/);
-  const branch = run("git rev-parse --abbrev-ref HEAD");
-  return {
-    repo: match ? match[1] : void 0,
-    branch: branch && branch !== "HEAD" ? branch : void 0
-  };
-}
 function pairedResult(token, sas, note, e2ee) {
   clearSurface();
   const base = {
@@ -379,96 +321,13 @@ async function handleTool(request, signal) {
         }]
       };
     }
-    // `contact` (#575) is the one LISTED name; `notify` (#496) and `notify_user`
-    // (the original) are HIDDEN aliases — unlisted but accepted, so stale prompts,
-    // hooks, and cached 0.24 servers' habits keep working. Same handler, same wire.
-    case "contact":
-    case "notify":
-    case "notify_user": {
-      const parsed = NotifyRequestSchema.parse(request.params.arguments);
-      const git = detectGit();
-      const enriched = {
-        ...parsed,
-        repo: parsed.repo ?? git.repo,
-        branch: parsed.branch ?? git.branch,
-        // THREAD-SCOPED IDENTITY (stage 3, identity-ownership-design.md). A worker subagent
-        // shares the parent's identity/slot, so its requests would otherwise scatter across
-        // fresh threads and mix with a sibling's. Default an unthreaded contact to THIS
-        // subagent's own thread so its requests group and siblings never collide. An explicit
-        // parentId (continuing a specific conversation) always wins; a top-level parent session
-        // is left untouched (undefined ⇒ the server mints a fresh thread, exactly as today).
-        parentId: contactParentId(parsed.parentId)
-      };
-      let result;
-      try {
-        result = await submitNotification(enriched);
-      } catch (err) {
-        const fixable = fixAndRetry(err);
-        if (fixable) return { isError: true, content: [{ type: "text", text: JSON.stringify(fixable) }] };
-        throw err;
-      }
-      const sentAs = slotName(AGENT_NAME);
-      const shown = { ...result, message: contactMessage(result) };
-      return { content: [{ type: "text", text: JSON.stringify(sentAs ? { ...shown, sentAs } : shown) }] };
-    }
-    case "await_reply": {
-      const { notificationId } = AwaitReplySchema.parse(request.params.arguments);
-      const item = await awaitReply2(notificationId, {
-        ...signal ? { signal } : {}
-      });
-      return { content: [{ type: "text", text: JSON.stringify({ ...item, message: awaitMessage(item) }) }] };
-    }
-    case "check_replies": {
-      const result = await checkReplies();
-      return { content: [{ type: "text", text: JSON.stringify(result) }] };
-    }
-    case "get_thread": {
-      const { parentId } = GetThreadSchema.parse(request.params.arguments);
-      return { content: [{ type: "text", text: JSON.stringify(await getThread(parentId)) }] };
-    }
-    case "search_threads": {
-      const { q } = SearchThreadsSchema.parse(request.params.arguments);
-      return { content: [{ type: "text", text: JSON.stringify(await searchThreads(q)) }] };
-    }
-    case "answer_caller_question": {
-      const { notificationId, answer } = AnswerCallerQuestionSchema.parse(request.params.arguments);
-      const result = await answerCallerQuestion(notificationId, answer);
-      return { content: [{ type: "text", text: JSON.stringify({
-        ...result,
-        ...result.live ? {} : { note: "The call already ended \u2014 send this as a threaded contact instead so the answer still reaches them." }
-      }) }] };
-    }
-    case "set_task_state": {
-      const { notificationId, state } = SetTaskStateToolSchema.parse(request.params.arguments);
-      const result = await setTaskState(notificationId, state);
-      return { content: [{ type: "text", text: JSON.stringify(result) }] };
-    }
-    case "set_work_state": {
-      const result = await setWorkState(SetWorkStateSchema.parse(request.params.arguments));
-      return { content: [{ type: "text", text: JSON.stringify(result) }] };
-    }
-    case "create_goal": {
-      const result = await createGoal(CreateGoalSchema.parse(request.params.arguments));
-      return { content: [{ type: "text", text: JSON.stringify(result) }] };
-    }
-    case "claim_goal": {
-      const { goalId } = ClaimGoalSchema.parse(request.params.arguments);
-      return { content: [{ type: "text", text: JSON.stringify(await claimGoal(goalId)) }] };
-    }
-    case "update_goal": {
-      const { goalId, ...input } = UpdateGoalToolSchema.parse(request.params.arguments);
-      return { content: [{ type: "text", text: JSON.stringify(await updateGoal(goalId, input)) }] };
-    }
-    case "schedule_callback": {
-      const result = await scheduleCallback(ScheduleCallbackSchema.parse(request.params.arguments));
-      return { content: [{ type: "text", text: JSON.stringify(result) }] };
-    }
-    case "handoff": {
-      const result = await handoff(HandoffSchema.parse(request.params.arguments));
-      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    default: {
+      const name = request.params.name;
+      const result = await runTool(name, request.params.arguments ?? {}, { waits: true, signal });
+      const sentAs = name === "contact" ? slotName(AGENT_NAME) : null;
+      const shaped = sentAs && result && typeof result === "object" ? { ...result, sentAs } : result;
+      return { content: [{ type: "text", text: JSON.stringify(shaped) }] };
     }
-    default:
-      throw new Error(`Unknown tool: ${request.params.name}`);
   }
 }
 var beatDown = false;

package/dist/listen.js

@@ -1,18 +1,15 @@
 #!/usr/bin/env node
-import {
-  answerText
-} from "./chunk-UG2FARVV.js";
 import {
   WAKE_EVENT,
   wakeChannel
-} from "./chunk-KE63GZEQ.js";
+} from "./chunk-3QUIB42M.js";
 import {
   ackReply,
   authToken,
   decodeReply,
   registerDelivery,
   sweepLeased
-} from "./chunk-PPACGOTU.js";
+} from "./chunk-4UZAPBKK.js";
 
 // src/listen.ts
 import { createClient } from "@supabase/supabase-js";
@@ -117,6 +114,29 @@ function uninstallService() {
   return unit;
 }
 
+// src/message.ts
+function answerText(answer) {
+  switch (answer.kind) {
+    case "text":
+      return answer.text;
+    case "option":
+      return answer.label ?? answer.optionId;
+    case "multi":
+    case "ranked":
+      return (answer.labels ?? answer.optionIds).join(", ");
+    case "confirm":
+      return answer.approved ? "approved" : "declined";
+    case "clarify":
+      return answer.chunks.join(" ");
+    case "turns":
+      return answer.turns.map((turn) => turn.reply).join(" ");
+    case "precedent":
+      return answer.answer;
+    case "ignored":
+      return "";
+  }
+}
+
 // src/listen.ts
 var emit = (obj) => void process.stdout.write(JSON.stringify(obj) + "\n");
 function launchEnv(work, reason) {

package/dist/onboard.js

@@ -3,13 +3,13 @@ import {
   resolvePairing,
   startPairing,
   suggestedAgentName
-} from "./chunk-4UEL7Y5U.js";
+} from "./chunk-CXABA27N.js";
 import {
   autoConfigureClients,
   claudeInstallHint,
   openBrowser
-} from "./chunk-7IGGSB3H.js";
-import "./chunk-KE63GZEQ.js";
+} from "./chunk-TLASZUJD.js";
+import "./chunk-3QUIB42M.js";
 import {
   AGENT_NAME,
   TOKEN_PATH,
@@ -20,7 +20,7 @@ import {
   saveToken,
   setIdentity,
   whoAmI
-} from "./chunk-PPACGOTU.js";
+} from "./chunk-4UZAPBKK.js";
 
 // src/onboard.ts
 function reportRegistered() {

package/dist/slot.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   AGENT_NAME
-} from "./chunk-PPACGOTU.js";
+} from "./chunk-4UZAPBKK.js";
 
 // src/slot.ts
 process.stdout.write(AGENT_NAME);

package/dist/statusline.js

@@ -9,7 +9,7 @@ import {
   readToken,
   sessionSlot,
   slotName
-} from "./chunk-PPACGOTU.js";
+} from "./chunk-4UZAPBKK.js";
 
 // src/statusline.ts
 import { mkdirSync, readFileSync, realpathSync, writeFileSync } from "fs";
@@ -35,7 +35,9 @@ function render(v) {
     case "session": {
       const who = v.name ? `${v.name} \xB7 ` : "";
       if (!v.status) return `paigy: ${who}revoked`;
-      return `paigy: ${who}${MODE_LABEL[v.status.sessionMode]} \xB7 ${v.status.phone ? "phone \u2713" : "no phone"}`;
+      const n = v.status.waiting ?? 0;
+      const waiting = n > 0 ? ` \xB7 ${n} waiting` : "";
+      return `paigy: ${who}${MODE_LABEL[v.status.sessionMode]} \xB7 ${v.status.phone ? "phone \u2713" : "no phone"}${waiting}`;
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paigy/mcp",
-  "version": "0.38.0",
+  "version": "0.40.1",
   "description": "Paigy MCP server — the AI agent harness that calls you. Lets an agent notify a user and await their reply.",
   "license": "MIT",
   "type": "module",
@@ -40,7 +40,7 @@
     "vitest": "^2.1.8",
     "@paigy/crypto": "0.0.0",
     "@paigy/schema": "0.0.0",
-    "@paigy/sdk": "0.2.0"
+    "@paigy/sdk": "0.2.1"
   },
   "scripts": {
     "build": "tsup",