@paigy/mcp 0.40.2 → 0.40.3

package/dist/{chunk-647HS22P.js → chunk-4JDG67EF.js}

@@ -2,10 +2,10 @@ import {
   AGENT_TOOLS,
   mcpInputSchema,
   serverInstructions
-} from "./chunk-FFI3AIZE.js";
+} from "./chunk-V3VVCML7.js";
 import {
   AGENT_NAME
-} from "./chunk-YJEJZT56.js";
+} from "./chunk-6QQHTUKJ.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.";

package/dist/{chunk-YJEJZT56.js → chunk-6QQHTUKJ.js}

@@ -14,7 +14,7 @@ import { closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, statS
 import { homedir } from "os";
 import { join } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
-import { createClient } from "@supabase/supabase-js";
+import { WebSocket } from "undici";
 var require2 = __sdkCreateRequire(import.meta.url);
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -3590,14 +3590,14 @@ var CreateGoalSchema = z2.object({
    *  worked"). It could not have been: this door took no parent, so the only route was
    *  create -> claim -> `update_goal`, three calls with a lease in the middle, and every agent
    *  took the short one. The hierarchy has been modelled since Goals existed and had been used
-   *  ZERO times in 2,031 of them. Absent still means a root, which is what every caller meant
-   *  before this existed. The writer refuses a Goal belonging to another account. */
+   *  ZERO times in 2,031 of them. Absent, the server judges it against the caller's open Goals
+   *  (`apps/api/src/goal/intake.ts`). The writer refuses a Goal belonging to another account. */
   parentGoalId: z2.string().uuid().optional()
 });
 var CreateGoalToolSchema = CreateGoalSchema.extend({
   idempotencyKey: CreateGoalSchema.shape.idempotencyKey.optional().describe("Optional. One is minted per call; pass your own only so a retry lands on the same Goal.")
 }).strict();
-var CREATE_GOAL_DESCRIPTION = "Create a durable Goal for an outcome. Pass parentGoalId to create it UNDER an existing Goal \u2014 do that whenever the work is part of something already being tracked, rather than minting a root and leaving the relationship unsaid; absent means a root. Admission only: the owner must claim it before doing work, then update it as it advances. Returns an admission receipt with goalId, current state, revision, ownerParticipant, and the next step; no Goal content or execution lease.";
+var CREATE_GOAL_DESCRIPTION = "Create a durable Goal for an outcome. Without parentGoalId it is placed against your open Goals: if one already IS this work, that Goal comes back (existing: true) and nothing new is created \u2014 continue it; if the work belongs under one, it is created there (parentGoalId in the receipt); otherwise it is a root. Pass parentGoalId yourself to put it under a specific Goal. Admission only: the owner must claim it before doing work, then update it as it advances. Returns an admission receipt with goalId, current state, revision, ownerParticipant, and the next step; no Goal content or execution lease.";
 var UpdateGoalSchema = z2.object({
   revision: z2.number().int().positive(),
   changes: z2.object({
@@ -3925,9 +3925,6 @@ function deriveAsk(req) {
 }
 var NotifyStatusSchema = z3.enum(["pending", "answered", "ignored"]);
 var AgentStateSchema = z3.enum(["idle", "in_progress", "completed", "needs_input"]);
-var SetTaskStateSchema = z3.object({
-  state: z3.enum(["in_progress", "completed", "needs_input"])
-});
 var TurnSchema = z3.object({
   prompt: z3.string(),
   reply: z3.string()
@@ -4057,101 +4054,6 @@ var AwaitItemSchema = z3.discriminatedUnion("type", [
   })
 ]);
 var CallbackTriggerSchema = z3.enum(["on_done", "on_blocked", "scheduled"]);
-var PendingRepliesSchema = z3.object({
-  replies: z3.array(
-    z3.object({
-      parentId: z3.string(),
-      notificationId: z3.string(),
-      workId: z3.string().uuid().optional(),
-      decisionId: z3.string().uuid().optional(),
-      answer: UserAnswerSchema,
-      /** E2EE: the sealed answer (opaque envelope + plaintext `ignored` hint) when the
-       *  pairing is E2EE — the agent opens it and re-derives the real answer. Absent =
-       *  plaintext answer (in `answer`). See AwaitItemSchema's reply variant. */
-      sealed: z3.lazy(() => SealedAnswerSchema).optional(),
-      /** The call record rendered for THIS agent: the raw words the shaped answer was
-       *  mapped from, filtered to its own claims. See AwaitItemSchema's reply variant. */
-      transcript: z3.string().optional(),
-      /** Coverage report (#396): which declared `points` this answer addressed. */
-      covered: z3.array(z3.string()).optional()
-    })
-  ),
-  pending: z3.array(
-    z3.object({ parentId: z3.string(), notificationId: z3.string(), createdAt: z3.string() })
-  ),
-  /** WHO YOU ARE on this account (field report 2026-08-28): the name and device the user
-   *  sees for this session's identity. From inside a session there was no way to find out —
-   *  `pair` with no arguments can HATCH a fresh identity, so it is not a safe probe — and an
-   *  agent that cannot tell which agent it is cannot tell whether work addressed to
-   *  "Reta" was addressed to it. Absent only for a token with no pairing behind it. */
-  you: z3.object({ name: z3.string(), device: z3.string().nullable(), tokenId: z3.string() }).optional(),
-  /** User-initiated requests addressed to this agent; act on them and reply via
-   *  contact on the same parentId. Keeps reappearing until you call
-   *  set_work_state on its workId (or notificationId once while bootstrapping). */
-  requests: z3.array(
-    z3.object({
-      parentId: z3.string(),
-      notificationId: z3.string(),
-      workId: z3.string().uuid().optional(),
-      text: z3.string(),
-      createdAt: z3.string(),
-      /** The user seeded this request with a past conversation — call get_thread on it
-       *  FIRST and treat the transcript as prior context (#57/#251). */
-      contextParentId: z3.string().optional(),
-      /** STRANDED (field report 2026-08-28): this request was addressed to ANOTHER agent on
-       *  the account — the name here — which has not been seen since it landed, so nobody
-       *  came for it. Handed to you because you are the session that is here. Take it like
-       *  any request (set_work_state claims it, reply with contact on its parentId), and say
-       *  whose it was, because the user chose that agent on purpose. */
-      stranded: z3.string().optional()
-    })
-  ),
-  /** Durable outcomes currently owned by this agent. This is the Work-native queue; flat
-   * notification lists remain during migration so old clients keep their existing view. */
-  work: z3.array(z3.object({
-    workId: z3.string().uuid(),
-    parentId: z3.string().optional(),
-    objective: z3.string().nullable(),
-    state: z3.enum(["active", "blocked", "waiting_external"]),
-    blockedOn: z3.array(z3.string().uuid()),
-    updatedAt: z3.string()
-  })).optional(),
-  /** Callbacks you owe the user that are now DUE (you said you'd follow up when done,
-   *  if blocked, or at a time that has passed). Re-surfaced every sweep until you
-   *  fulfill one by calling contact on its parentId. */
-  /** Ride-alongs (RideAlongSchema): notes assigned to this agent that no wake could
-   *  reach. Same array the contact/await replies carry — one queue, every carrier. */
-  also: z3.array(RideAlongSchema).optional(),
-  owedCallbacks: z3.array(
-    z3.object({ parentId: z3.string(), trigger: CallbackTriggerSchema, note: z3.string() })
-  ),
-  /** Work (either direction) you reported in_progress a while ago and never reported
-   *  completed — likely left half-done by this session or a prior one that crashed or
-   *  went idle. Report a real state (set_work_state) or continue the work. */
-  stalled: z3.array(
-    z3.object({ parentId: z3.string(), notificationId: z3.string(), title: z3.string().nullable(), startedAt: z3.string() })
-  ),
-  /** The queue rail (#614, pending/design.md): the same replies + requests, grouped by
-   *  thread and ordered oldest-thread-first, so you work ONE thread at a time — fold all of
-   *  a thread's `items` into a single turn rather than interleaving threads. `busy` = the
-   *  thread already has a turn in progress (younger than the stall cutoff); let it finish and
-   *  ride the next turn. `items` are that thread's replies/requests in arrival order; the
-   *  full payload for each is in the flat `replies`/`requests` arrays (matched by
-   *  notificationId). Derived, never stored — a crashed agent recomputes it exactly. */
-  threads: z3.array(
-    z3.object({
-      parentId: z3.string(),
-      busy: z3.boolean(),
-      items: z3.array(
-        z3.object({
-          kind: z3.enum(["reply", "request"]),
-          notificationId: z3.string(),
-          at: z3.string()
-        })
-      )
-    })
-  )
-});
 var NotifyResponseSchema = z3.object({
   notificationId: z3.string(),
   workId: z3.string().uuid().optional(),
@@ -5578,19 +5480,98 @@ async function runTool(name, args, opts) {
       throw new Error(`Unknown tool: ${name}`);
   }
 }
+var HEARTBEAT_MS = 25e3;
+var RETRY_MS = [1e3, 2e3, 5e3, 1e4, 3e4];
+var JOIN = { config: { broadcast: { self: false } } };
+var lines = /* @__PURE__ */ new Map();
+function frame(line, topic, event, payload) {
+  try {
+    line.ws?.send(JSON.stringify({ topic, event, payload, ref: String(++line.ref) }));
+  } catch {
+  }
+}
+function stop(line) {
+  line.open = false;
+  clearInterval(line.heart);
+  clearTimeout(line.retry);
+}
+function connect(line) {
+  const base = line.url.replace(/^http/, "ws").replace(/\/+$/, "");
+  const ws = line.ws = new WebSocket(`${base}/realtime/v1/websocket?apikey=${encodeURIComponent(line.anonKey)}&vsn=1.0.0`);
+  ws.addEventListener("open", () => {
+    line.open = true;
+    line.attempt = 0;
+    for (const topic of line.topics.keys()) frame(line, `realtime:${topic}`, "phx_join", JOIN);
+    line.heart = setInterval(() => frame(line, "phoenix", "heartbeat", {}), HEARTBEAT_MS);
+  });
+  ws.addEventListener("message", (e) => {
+    let m;
+    try {
+      m = JSON.parse(String(e.data));
+    } catch {
+      return;
+    }
+    if (m.event !== "broadcast" || !m.topic?.startsWith("realtime:")) return;
+    for (const l of line.topics.get(m.topic.slice("realtime:".length)) ?? []) {
+      if (m.payload?.event === l.event) l.onMessage(m.payload.payload);
+    }
+  });
+  let gone = false;
+  const again = () => {
+    if (gone) return;
+    gone = true;
+    stop(line);
+    if (!line.topics.size) return;
+    line.retry = setTimeout(() => connect(line), RETRY_MS[Math.min(line.attempt++, RETRY_MS.length - 1)]);
+  };
+  ws.addEventListener("close", again);
+  ws.addEventListener("error", again);
+}
+function subscribeRealtime(args) {
+  const key = `${args.url} ${args.anonKey}`;
+  let line = lines.get(key);
+  if (!line) lines.set(key, line = { url: args.url, anonKey: args.anonKey, open: false, attempt: 0, ref: 0, topics: /* @__PURE__ */ new Map() });
+  let heard = line.topics.get(args.topic);
+  if (!heard) {
+    line.topics.set(args.topic, heard = /* @__PURE__ */ new Set());
+    if (line.open) frame(line, `realtime:${args.topic}`, "phx_join", JOIN);
+  }
+  const me = { event: args.event, onMessage: args.onMessage };
+  heard.add(me);
+  if (!line.ws) connect(line);
+  return {
+    close: () => {
+      if (!heard.delete(me) || heard.size) return;
+      line.topics.delete(args.topic);
+      if (line.topics.size) {
+        if (line.open) frame(line, `realtime:${args.topic}`, "phx_leave", {});
+        return;
+      }
+      lines.delete(key);
+      stop(line);
+      try {
+        line.ws?.close();
+      } catch {
+      }
+    }
+  };
+}
 async function subscribeWake(onNudge, opts = {}) {
   const cfg = await registerDelivery("self_hosted", opts);
   const { url, anonKey } = cfg.realtime;
   const channel = wakeChannel(cfg.tokenId);
-  const sb = createClient(url, anonKey, { auth: { persistSession: false } });
-  const ch = sb.channel(channel).on("broadcast", { event: WAKE_EVENT }, (msg) => onNudge(msg.payload ?? {}));
-  ch.subscribe();
+  const ch = subscribeRealtime({
+    url,
+    anonKey,
+    topic: channel,
+    event: WAKE_EVENT,
+    onMessage: (payload) => onNudge(payload ?? {})
+  });
   return {
     tokenId: cfg.tokenId,
     channel,
     close: async () => {
-      await sb.removeChannel(ch).catch(() => {
-      });
+      ch.close();
       await registerDelivery("poll", opts).catch(() => {
       });
     }

package/dist/{chunk-BUTCP2ED.js → chunk-TNQOFCZC.js}

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

package/dist/{chunk-FFI3AIZE.js → chunk-V3VVCML7.js}

@@ -74,14 +74,14 @@ var CreateGoalSchema = z2.object({
    *  worked"). It could not have been: this door took no parent, so the only route was
    *  create -> claim -> `update_goal`, three calls with a lease in the middle, and every agent
    *  took the short one. The hierarchy has been modelled since Goals existed and had been used
-   *  ZERO times in 2,031 of them. Absent still means a root, which is what every caller meant
-   *  before this existed. The writer refuses a Goal belonging to another account. */
+   *  ZERO times in 2,031 of them. Absent, the server judges it against the caller's open Goals
+   *  (`apps/api/src/goal/intake.ts`). The writer refuses a Goal belonging to another account. */
   parentGoalId: z2.string().uuid().optional()
 });
 var CreateGoalToolSchema = CreateGoalSchema.extend({
   idempotencyKey: CreateGoalSchema.shape.idempotencyKey.optional().describe("Optional. One is minted per call; pass your own only so a retry lands on the same Goal.")
 }).strict();
-var CREATE_GOAL_DESCRIPTION = "Create a durable Goal for an outcome. Pass parentGoalId to create it UNDER an existing Goal \u2014 do that whenever the work is part of something already being tracked, rather than minting a root and leaving the relationship unsaid; absent means a root. Admission only: the owner must claim it before doing work, then update it as it advances. Returns an admission receipt with goalId, current state, revision, ownerParticipant, and the next step; no Goal content or execution lease.";
+var CREATE_GOAL_DESCRIPTION = "Create a durable Goal for an outcome. Without parentGoalId it is placed against your open Goals: if one already IS this work, that Goal comes back (existing: true) and nothing new is created \u2014 continue it; if the work belongs under one, it is created there (parentGoalId in the receipt); otherwise it is a root. Pass parentGoalId yourself to put it under a specific Goal. Admission only: the owner must claim it before doing work, then update it as it advances. Returns an admission receipt with goalId, current state, revision, ownerParticipant, and the next step; no Goal content or execution lease.";
 var UpdateGoalSchema = z2.object({
   revision: z2.number().int().positive(),
   changes: z2.object({
@@ -372,9 +372,6 @@ var NotifyRequestSchema = NotifyRequestFields.superRefine((r, ctx) => {
 });
 var NotifyStatusSchema = z3.enum(["pending", "answered", "ignored"]);
 var AgentStateSchema = z3.enum(["idle", "in_progress", "completed", "needs_input"]);
-var SetTaskStateSchema = z3.object({
-  state: z3.enum(["in_progress", "completed", "needs_input"])
-});
 var TurnSchema = z3.object({
   prompt: z3.string(),
   reply: z3.string()
@@ -504,101 +501,6 @@ var AwaitItemSchema = z3.discriminatedUnion("type", [
   })
 ]);
 var CallbackTriggerSchema = z3.enum(["on_done", "on_blocked", "scheduled"]);
-var PendingRepliesSchema = z3.object({
-  replies: z3.array(
-    z3.object({
-      parentId: z3.string(),
-      notificationId: z3.string(),
-      workId: z3.string().uuid().optional(),
-      decisionId: z3.string().uuid().optional(),
-      answer: UserAnswerSchema,
-      /** E2EE: the sealed answer (opaque envelope + plaintext `ignored` hint) when the
-       *  pairing is E2EE — the agent opens it and re-derives the real answer. Absent =
-       *  plaintext answer (in `answer`). See AwaitItemSchema's reply variant. */
-      sealed: z3.lazy(() => SealedAnswerSchema).optional(),
-      /** The call record rendered for THIS agent: the raw words the shaped answer was
-       *  mapped from, filtered to its own claims. See AwaitItemSchema's reply variant. */
-      transcript: z3.string().optional(),
-      /** Coverage report (#396): which declared `points` this answer addressed. */
-      covered: z3.array(z3.string()).optional()
-    })
-  ),
-  pending: z3.array(
-    z3.object({ parentId: z3.string(), notificationId: z3.string(), createdAt: z3.string() })
-  ),
-  /** WHO YOU ARE on this account (field report 2026-08-28): the name and device the user
-   *  sees for this session's identity. From inside a session there was no way to find out —
-   *  `pair` with no arguments can HATCH a fresh identity, so it is not a safe probe — and an
-   *  agent that cannot tell which agent it is cannot tell whether work addressed to
-   *  "Reta" was addressed to it. Absent only for a token with no pairing behind it. */
-  you: z3.object({ name: z3.string(), device: z3.string().nullable(), tokenId: z3.string() }).optional(),
-  /** User-initiated requests addressed to this agent; act on them and reply via
-   *  contact on the same parentId. Keeps reappearing until you call
-   *  set_work_state on its workId (or notificationId once while bootstrapping). */
-  requests: z3.array(
-    z3.object({
-      parentId: z3.string(),
-      notificationId: z3.string(),
-      workId: z3.string().uuid().optional(),
-      text: z3.string(),
-      createdAt: z3.string(),
-      /** The user seeded this request with a past conversation — call get_thread on it
-       *  FIRST and treat the transcript as prior context (#57/#251). */
-      contextParentId: z3.string().optional(),
-      /** STRANDED (field report 2026-08-28): this request was addressed to ANOTHER agent on
-       *  the account — the name here — which has not been seen since it landed, so nobody
-       *  came for it. Handed to you because you are the session that is here. Take it like
-       *  any request (set_work_state claims it, reply with contact on its parentId), and say
-       *  whose it was, because the user chose that agent on purpose. */
-      stranded: z3.string().optional()
-    })
-  ),
-  /** Durable outcomes currently owned by this agent. This is the Work-native queue; flat
-   * notification lists remain during migration so old clients keep their existing view. */
-  work: z3.array(z3.object({
-    workId: z3.string().uuid(),
-    parentId: z3.string().optional(),
-    objective: z3.string().nullable(),
-    state: z3.enum(["active", "blocked", "waiting_external"]),
-    blockedOn: z3.array(z3.string().uuid()),
-    updatedAt: z3.string()
-  })).optional(),
-  /** Callbacks you owe the user that are now DUE (you said you'd follow up when done,
-   *  if blocked, or at a time that has passed). Re-surfaced every sweep until you
-   *  fulfill one by calling contact on its parentId. */
-  /** Ride-alongs (RideAlongSchema): notes assigned to this agent that no wake could
-   *  reach. Same array the contact/await replies carry — one queue, every carrier. */
-  also: z3.array(RideAlongSchema).optional(),
-  owedCallbacks: z3.array(
-    z3.object({ parentId: z3.string(), trigger: CallbackTriggerSchema, note: z3.string() })
-  ),
-  /** Work (either direction) you reported in_progress a while ago and never reported
-   *  completed — likely left half-done by this session or a prior one that crashed or
-   *  went idle. Report a real state (set_work_state) or continue the work. */
-  stalled: z3.array(
-    z3.object({ parentId: z3.string(), notificationId: z3.string(), title: z3.string().nullable(), startedAt: z3.string() })
-  ),
-  /** The queue rail (#614, pending/design.md): the same replies + requests, grouped by
-   *  thread and ordered oldest-thread-first, so you work ONE thread at a time — fold all of
-   *  a thread's `items` into a single turn rather than interleaving threads. `busy` = the
-   *  thread already has a turn in progress (younger than the stall cutoff); let it finish and
-   *  ride the next turn. `items` are that thread's replies/requests in arrival order; the
-   *  full payload for each is in the flat `replies`/`requests` arrays (matched by
-   *  notificationId). Derived, never stored — a crashed agent recomputes it exactly. */
-  threads: z3.array(
-    z3.object({
-      parentId: z3.string(),
-      busy: z3.boolean(),
-      items: z3.array(
-        z3.object({
-          kind: z3.enum(["reply", "request"]),
-          notificationId: z3.string(),
-          at: z3.string()
-        })
-      )
-    })
-  )
-});
 var NotifyResponseSchema = z3.object({
   notificationId: z3.string(),
   workId: z3.string().uuid().optional(),

package/dist/enable.js

@@ -2,9 +2,9 @@
 import {
   PAIGY_TOOL_IDS,
   enablePaigyTools
-} from "./chunk-647HS22P.js";
-import "./chunk-FFI3AIZE.js";
-import "./chunk-YJEJZT56.js";
+} from "./chunk-4JDG67EF.js";
+import "./chunk-V3VVCML7.js";
+import "./chunk-6QQHTUKJ.js";
 
 // src/enable.ts
 function main() {

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   resolvePairing,
   startPairing,
   suggestedAgentName
-} from "./chunk-BUTCP2ED.js";
+} from "./chunk-TNQOFCZC.js";
 import {
   ENABLE_COMMAND,
   OnboardSchema,
@@ -16,8 +16,8 @@ import {
   autoConfigureClients,
   claudeInstallHint,
   paigyToolsAllowlisted
-} from "./chunk-647HS22P.js";
-import "./chunk-FFI3AIZE.js";
+} from "./chunk-4JDG67EF.js";
+import "./chunk-V3VVCML7.js";
 import {
   clearSurface,
   writeSurface
@@ -38,7 +38,7 @@ import {
   setIdentity,
   slotName,
   whoAmI
-} from "./chunk-YJEJZT56.js";
+} from "./chunk-6QQHTUKJ.js";
 
 // src/index.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";

package/dist/listen.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
   entryWords
-} from "./chunk-FFI3AIZE.js";
+} from "./chunk-V3VVCML7.js";
 import {
   checkReplies,
   getGoal,
   subscribeWake
-} from "./chunk-YJEJZT56.js";
+} from "./chunk-6QQHTUKJ.js";
 
 // src/listen.ts
 import { spawn } from "child_process";

package/dist/onboard.js

@@ -3,13 +3,13 @@ import {
   resolvePairing,
   startPairing,
   suggestedAgentName
-} from "./chunk-BUTCP2ED.js";
+} from "./chunk-TNQOFCZC.js";
 import {
   autoConfigureClients,
   claudeInstallHint,
   openBrowser
-} from "./chunk-647HS22P.js";
-import "./chunk-FFI3AIZE.js";
+} from "./chunk-4JDG67EF.js";
+import "./chunk-V3VVCML7.js";
 import {
   AGENT_NAME,
   TOKEN_PATH,
@@ -20,7 +20,7 @@ import {
   saveToken,
   setIdentity,
   whoAmI
-} from "./chunk-YJEJZT56.js";
+} from "./chunk-6QQHTUKJ.js";
 
 // src/onboard.ts
 function reportRegistered() {

package/dist/slot.js

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

package/dist/statusline.js

@@ -9,7 +9,7 @@ import {
   readToken,
   sessionSlot,
   slotName
-} from "./chunk-YJEJZT56.js";
+} from "./chunk-6QQHTUKJ.js";
 
 // src/statusline.ts
 import { mkdirSync, readFileSync, realpathSync, writeFileSync } from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paigy/mcp",
-  "version": "0.40.2",
+  "version": "0.40.3",
   "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",
@@ -24,28 +24,28 @@
     "url": "git+https://github.com/mauurda/paigy.git",
     "directory": "apps/mcp"
   },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "pnpm --filter @paigy/schema build && pnpm --filter @paigy/crypto build && pnpm --filter @paigy/sdk build && pnpm build"
+  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.4",
-    "@supabase/supabase-js": "^2.47.10",
     "qrcode-generator": "^2.0.4",
     "undici": "^6.27.0",
     "zod": "^3.24.1",
     "zod-to-json-schema": "^3.24.1"
   },
   "devDependencies": {
+    "@paigy/crypto": "workspace:*",
+    "@paigy/schema": "workspace:*",
+    "@paigy/sdk": "workspace:*",
     "@types/node": "^22.0.0",
     "@types/qrcode-generator": "^1.0.6",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
-    "vitest": "^2.1.8",
-    "@paigy/crypto": "0.0.0",
-    "@paigy/sdk": "0.2.1",
-    "@paigy/schema": "0.0.0"
-  },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run"
+    "vitest": "^2.1.8"
   }
-}
+}