@paigy/mcp 0.33.0 → 0.34.0

package/dist/{chunk-JT7I3EGY.js → chunk-45CIZLCJ.js}

@@ -362,6 +362,12 @@ var PendingRepliesSchema = z.object({
   pending: z.array(
     z.object({ parentId: z.string(), notificationId: z.string(), createdAt: z.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: z.object({ name: z.string(), device: z.string().nullable(), tokenId: z.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_task_state on its notificationId. */
@@ -373,7 +379,13 @@ var PendingRepliesSchema = z.object({
       createdAt: z.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: z.string().optional()
+      contextParentId: z.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_task_state claims it, reply with contact on its parentId), and say
+       *  whose it was, because the user chose that agent on purpose. */
+      stranded: z.string().optional()
     })
   ),
   /** Callbacks you owe the user that are now DUE (you said you'd follow up when done,

package/dist/{chunk-SASREQWV.js → chunk-G2WR7FCJ.js}

@@ -1,6 +1,6 @@
 import {
   AGENT_NAME
-} from "./chunk-E3OWSUGJ.js";
+} from "./chunk-X42EUXML.js";
 
 // src/clients.ts
 import { execFile } from "child_process";

package/dist/{chunk-E3OWSUGJ.js → chunk-X42EUXML.js}

@@ -2756,6 +2756,12 @@ var PendingRepliesSchema = z.object({
   pending: z.array(
     z.object({ parentId: z.string(), notificationId: z.string(), createdAt: z.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: z.object({ name: z.string(), device: z.string().nullable(), tokenId: z.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_task_state on its notificationId. */
@@ -2767,7 +2773,13 @@ var PendingRepliesSchema = z.object({
       createdAt: z.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: z.string().optional()
+      contextParentId: z.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_task_state claims it, reply with contact on its parentId), and say
+       *  whose it was, because the user chose that agent on purpose. */
+      stranded: z.string().optional()
     })
   ),
   /** Callbacks you owe the user that are now DUE (you said you'd follow up when done,

package/dist/enable.js

@@ -2,8 +2,8 @@
 import {
   PAIGY_TOOL_IDS,
   enablePaigyTools
-} from "./chunk-SASREQWV.js";
-import "./chunk-E3OWSUGJ.js";
+} from "./chunk-G2WR7FCJ.js";
+import "./chunk-X42EUXML.js";
 
 // src/enable.ts
 function main() {

package/dist/index.js

@@ -2,14 +2,14 @@
 import {
   HandoffSchema,
   MISSED_CALL_PLAN
-} from "./chunk-JT7I3EGY.js";
+} from "./chunk-45CIZLCJ.js";
 import {
   ENABLE_COMMAND,
   PAIGY_TOOL_IDS,
   autoConfigureClients,
   claudeInstallHint,
   paigyToolsAllowlisted
-} from "./chunk-SASREQWV.js";
+} from "./chunk-G2WR7FCJ.js";
 import {
   clearSurface,
   writeSurface
@@ -51,7 +51,7 @@ import {
   startE2ee,
   submitNotification,
   whoAmI
-} from "./chunk-E3OWSUGJ.js";
+} from "./chunk-X42EUXML.js";
 
 // src/index.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -468,7 +468,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     },
     {
       name: "check_replies",
-      description: "The catch-up sweep for everything outstanding \u2014 a PURE read, takes no arguments, safe to call as often as you like: nothing here is consumed by reading it. Returns `replies` (answers to notifications you sent), your still-pending notifications, and `requests` \u2014 requests the user started toward you (each { notificationId, parentId, text }). Each keeps reappearing on every call until you actually engage with it: call set_task_state on its notificationId, which is what claims/acknowledges it \u2014 a human-initiated reply or request must never be silently dropped just because you read the list without acting. Also returns `threads` \u2014 the SAME replies + requests grouped by conversation, oldest thread first, each with a `busy` flag and its `items` in arrival order. WORK ONE THREAD AT A TIME: take the oldest thread whose `busy` is false, handle ALL of its items together in a single turn (one set_task_state), then go to the next \u2014 don't interleave threads item-by-item. A `busy` thread already has a turn in progress; leave it and let its new items ride the next turn. Use check_replies when booting up / starting a session, or when you've been waiting a long time on something else. To wait on an answer to a contact call you just made, use await_reply instead. Also returns owedCallbacks: callbacks now due that you promised \u2014 fulfill each with contact on its parentId. EVERY Paigy reply \u2014 this one, await_reply's, and contact's \u2014 may carry `also`: work assigned to you that no wake could reach, handed to you because you happened to be here. It is NOT what you asked about and it is never urgent: FINISH what you came for first, then take it up. Each entry has a `noteId` and the owner's own words; report on its `parentId` thread when it has one, and call set_task_state on that thread as you would for any assigned work. Ignoring it costs nothing \u2014 it rides your next reply too. Also returns `stalled`: work (either direction) you reported in_progress via set_task_state a while ago and never reported completed \u2014 likely left half-done by this session or a prior one that crashed or went idle. For each, either continue the work and report a real state, or investigate why it stalled. Replies may carry `intents`/`transcript`/`covered` (call-mapped answers) \u2014 handle intents exactly as await_reply's description says (defer \u2192 schedule_callback now; delegate \u2192 decide and say so; channel \u2192 honor next contact), and treat a `covered` list missing one of your declared points as that part still unanswered.",
+      description: "The catch-up sweep for everything outstanding \u2014 a PURE read, takes no arguments, safe to call as often as you like: nothing here is consumed by reading it. Returns `replies` (answers to notifications you sent), your still-pending notifications, and `requests` \u2014 requests the user started toward you (each { notificationId, parentId, text }). Each keeps reappearing on every call until you actually engage with it: call set_task_state on its notificationId, which is what claims/acknowledges it \u2014 a human-initiated reply or request must never be silently dropped just because you read the list without acting. Also returns `threads` \u2014 the SAME replies + requests grouped by conversation, oldest thread first, each with a `busy` flag and its `items` in arrival order. WORK ONE THREAD AT A TIME: take the oldest thread whose `busy` is false, handle ALL of its items together in a single turn (one set_task_state), then go to the next \u2014 don't interleave threads item-by-item. A `busy` thread already has a turn in progress; leave it and let its new items ride the next turn. Use check_replies when booting up / starting a session, or when you've been waiting a long time on something else. To wait on an answer to a contact call you just made, use await_reply instead. Also returns owedCallbacks: callbacks now due that you promised \u2014 fulfill each with contact on its parentId. EVERY Paigy reply \u2014 this one, await_reply's, and contact's \u2014 may carry `also`: work assigned to you that no wake could reach, handed to you because you happened to be here. It is NOT what you asked about and it is never urgent: FINISH what you came for first, then take it up. Each entry has a `noteId` and the owner's own words; report on its `parentId` thread when it has one, and call set_task_state on that thread as you would for any assigned work. Ignoring it costs nothing \u2014 it rides your next reply too. Also returns `stalled`: work (either direction) you reported in_progress via set_task_state a while ago and never reported completed \u2014 likely left half-done by this session or a prior one that crashed or went idle. For each, either continue the work and report a real state, or investigate why it stalled. Also returns `you` \u2014 WHICH IDENTITY you are speaking as ({ name, device, tokenId }), the same name and device the user sees on their Agents screen. This is the only safe way to find out (calling `pair` can MINT a new identity instead of telling you about the current one). Use it when the user asks who you are, and to tell whether work addressed to a name is addressed to you. A request may also carry `stranded`: it was addressed to ANOTHER agent on this account (that name) which has not been seen since it landed, so nobody came for it and it is handed to you because you are the session that is here. Take it exactly like your own \u2014 set_task_state claims it, reply with contact on its parentId \u2014 and say whose it was, because the user picked that agent on purpose. Replies may carry `intents`/`transcript`/`covered` (call-mapped answers) \u2014 handle intents exactly as await_reply's description says (defer \u2192 schedule_callback now; delegate \u2192 decide and say so; channel \u2192 honor next contact), and treat a `covered` list missing one of your declared points as that part still unanswered.",
       inputSchema: json(z.object({}))
     },
     {

package/dist/listen.js

@@ -2,11 +2,11 @@
 import {
   WAKE_EVENT,
   wakeChannel
-} from "./chunk-JT7I3EGY.js";
+} from "./chunk-45CIZLCJ.js";
 import {
   checkReplies,
   registerDelivery
-} from "./chunk-E3OWSUGJ.js";
+} from "./chunk-X42EUXML.js";
 
 // src/listen.ts
 import { createClient } from "@supabase/supabase-js";

package/dist/onboard.js

@@ -3,7 +3,7 @@ import {
   autoConfigureClients,
   claudeInstallHint,
   openBrowser
-} from "./chunk-SASREQWV.js";
+} from "./chunk-G2WR7FCJ.js";
 import {
   AGENT_NAME,
   TOKEN_PATH,
@@ -17,7 +17,7 @@ import {
   setIdentity,
   sleep,
   whoAmI
-} from "./chunk-E3OWSUGJ.js";
+} from "./chunk-X42EUXML.js";
 
 // src/onboard.ts
 async function main() {

package/dist/statusline.js

@@ -6,7 +6,7 @@ import {
   BACKEND_URL,
   reach,
   readToken
-} from "./chunk-E3OWSUGJ.js";
+} from "./chunk-X42EUXML.js";
 
 // src/statusline.ts
 import { mkdirSync, readFileSync, realpathSync, writeFileSync } from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paigy/mcp",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "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",