@paigy/mcp 0.33.0 → 0.35.0

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

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

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

@@ -2645,10 +2645,10 @@ var IntentSchema = z.object({
   // questions included. Found auditing five calls' stored feedback, 2026-08-01.
   kind: z.enum(["defer", "delegate", "channel", "question", "detail", "feedback", "command", "control"]),
   detail: z.string(),
-  /** Landed defer (#397): the MCP parses common spoken forms ("in 20 minutes",
-   *  "after lunch") against the agent machine's clock — the user's — and attaches
-   *  the seconds, ready to pass straight to schedule_callback. Absent when the
-   *  detail didn't parse (the agent interprets it) or the kind isn't defer. */
+  /** Defer only: seconds until the callback the caller asked for, when something upstream
+   *  already read the time. Nothing sets it today (#397 documented an MCP parser that was
+   *  never written) — the API reads the defer's `detail` itself with `notes/when.ts`
+   *  (`parseDelay`, #1292), and a value here simply wins over that reading. */
   dueInSeconds: z.number().int().positive().optional(),
   /** Feedback only (#812): WHICH failure the complaint names — typed by the mapper that
    *  already read the utterance, so `feedback_from_call.kind` stops defaulting to
@@ -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,
@@ -3068,7 +3080,13 @@ var BrokerTuningSchema = z.object({
    *  uninterpretable, 'high' = whenever not fully certain. */
   clarifyEagerness: z.enum(["low", "normal", "high"]).optional(),
   /** The user's own shorthand: when they say `say`, they mean `mean`. */
-  phrasebook: z.array(z.object({ say: z.string().min(1).max(60), mean: z.string().min(1).max(120) })).max(24).optional()
+  phrasebook: z.array(z.object({ say: z.string().min(1).max(60), mean: z.string().min(1).max(120) })).max(24).optional(),
+  /** The language calls are PLANNED in, when the account has chosen one (#1272). Absent —
+   *  which is every account today — means the agent's own words decide, per ask: a call
+   *  about an English ask opens in English. This is the only thing that overrides that,
+   *  and a live caller who switches language mid-call still outranks it (broker/lang.ts).
+   *  Set per user (no UI yet), like `voiceTuning`. */
+  language: z.enum(["en", "es"]).optional()
 });
 var UserSettingsSchema = z.object({
   permissions: z.object({
@@ -3276,7 +3294,9 @@ var NoteSchema = z.object({
   /** The request thread minted at assignment; null until assigned. */
   parentId: z.string().nullable(),
   /** REMINDERS (reminders-design.md): the NOT-BEFORE this becomes eligible to ride a
-   *  call — never a deadline, and nothing rings when it passes. Null = "the very next
+   *  call — never a deadline. It only ever comes from the user's own words, so when it
+   *  passes Paigy rings ONCE (#1293, owner 2026-08-26: a time said out loud is consent to
+   *  a ring at that time); after that it rides like any other. Null = "the very next
    *  call", the right reading of "remind me to…" with no time attached. */
   //  Defaulted, not required: a Note from an API deploy older than the reminders
   //  migration has none of these, and the defaults ARE what it means — no not-before,
@@ -3319,6 +3339,59 @@ var AssignNoteSchema = z.object({
     workspace: z.string().min(1)
   }).optional()
 }).refine((a) => !!a.target !== !!a.spawn, { message: "exactly one of target or spawn" });
+var TriageVerdictSchema = z.enum(["keep", "stale", "close", "assign"]);
+var TriageItemSchema = z.object({
+  noteId: z.string(),
+  /** The note's headline at run time. */
+  title: z.string(),
+  /** WHY, in one short human line, evidence first — this is read on a phone underneath
+   *  the note's title: "no movement in 34 days", "worked 3 notes in this repo this week".
+   *  Never a model's reasoning transcript, never an id. */
+  why: z.string()
+});
+var TriageAssignmentSchema = z.object({
+  /** The agent's token id — what `dispatchNote` resolves and what a request is addressed to. */
+  agent: z.string(),
+  /** Its display name at run time (the name on the hatchling's card). Denormalized for the
+   *  same reason as `title`: the card must render from the proposal alone. */
+  agentName: z.string(),
+  notes: z.array(TriageItemSchema)
+});
+var TriageStatusSchema = z.enum(["open", "superseded", "dismissed"]);
+var SubmitTriageSchema = z.object({
+  /** Which runtime judged: "ollama" (inference never left the machine) or a harness the
+   *  user already runs under their own credentials ("claude" / "codex" / "agy"). Recorded
+   *  so the phone can say where the content went — an unattributed privacy claim is worth
+   *  nothing, and #1106's promise is precisely "Paigy's servers never see this". */
+  provider: z.string().min(1).max(60),
+  /** The concrete model when the provider names one (an ollama tag); null otherwise. */
+  model: z.string().max(200).nullable().optional(),
+  /** How many open notes the run actually looked at — the denominator on the phone
+   *  ("6 of 50"), and the honest answer to "did it read the whole queue?". */
+  reviewed: z.number().int().min(0).max(1e4).default(0),
+  close: z.array(TriageItemSchema).max(200).default([]),
+  stale: z.array(TriageItemSchema).max(200).default([]),
+  assign: z.array(TriageAssignmentSchema).max(50).default([])
+});
+var TriageProposalSchema = SubmitTriageSchema.extend({
+  id: z.string(),
+  runAt: z.string(),
+  status: TriageStatusSchema,
+  model: z.string().nullable().default(null)
+});
+var AcceptTriageSchema = z.discriminatedUnion("group", [
+  z.object({ group: z.literal("close"), noteIds: z.array(z.string()).max(200).optional() }),
+  z.object({ group: z.literal("stale"), noteIds: z.array(z.string()).max(200).optional() }),
+  z.object({
+    group: z.literal("assign"),
+    agent: z.string().min(1),
+    noteIds: z.array(z.string()).max(200).optional()
+  })
+]);
+var AcceptTriageResultSchema = z.object({
+  accepted: z.array(z.string()),
+  failed: z.array(z.object({ noteId: z.string(), reason: z.string() }))
+});
 var DeliveryModeSchema = z.enum(["poll", "self_hosted"]);
 var RegisterDeliverySchema = z.object({ mode: DeliveryModeSchema });
 var OAuthStartSchema = z.object({
@@ -4100,7 +4173,6 @@ async function submitNotification(req, opts = {}) {
   if (!res.ok) throw new Error(`notify failed: ${res.status} ${await res.text()}`);
   return await res.json();
 }
-var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
 function decryptAnswer(reply, deps = {}) {
   if (!reply.sealed) return reply.answer;
   const keyFile = (deps.readKeyFile ?? readKeyFile)();
@@ -4109,15 +4181,6 @@ function decryptAnswer(reply, deps = {}) {
   }
   return openSealedAnswer(reply.sealed, keyFile.keypair);
 }
-async function pollAnswer(notificationId) {
-  const token = readToken();
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/await?notificationId=${encodeURIComponent(notificationId)}`, {
-    headers: { authorization: `Bearer ${token}` }
-  }));
-  if (!res.ok) throw new Error(`await failed: ${res.status} ${await res.text()}`);
-  const item = await res.json();
-  return item.type === "idle" ? item : decryptItem(item);
-}
 var AWAIT_WINDOW_MS = 45e3;
 var _partialSeen = /* @__PURE__ */ new Map();
 async function pollPartials(notificationId) {
@@ -4138,30 +4201,6 @@ async function pollPartials(notificationId) {
     return null;
   }
 }
-async function awaitReply(notificationId, opts = {}) {
-  const intervalMs = opts.intervalMs ?? 5e3;
-  const windowMs = opts.windowMs ?? AWAIT_WINDOW_MS;
-  const doSleep = opts.sleep ?? sleep2;
-  const now = opts.now ?? Date.now;
-  const start = now();
-  while (true) {
-    if (opts.signal?.aborted) return { type: "idle" };
-    const item = await pollAnswer(notificationId);
-    if (item.type !== "idle") return item;
-    const partial = await pollPartials(notificationId);
-    if (partial) return partial;
-    if (now() - start >= windowMs) return { type: "idle" };
-    await doSleep(intervalMs);
-  }
-}
-function decryptItem(item) {
-  if (item.type !== "reply") return item;
-  const enriched = { ...item, intents: landIntents(item.intents) };
-  if (!enriched.sealed) return enriched;
-  const answer = decryptAnswer(enriched);
-  const { sealed: _s, ...rest } = enriched;
-  return { ...rest, answer };
-}
 function landIntents(intents) {
   if (!intents?.length) return intents;
   return intents.map((i) => {
@@ -4187,10 +4226,14 @@ async function searchThreads(q) {
 async function checkReplies(opts = {}) {
   const token = authToken(opts.token);
   const res = ensureAuthed(await reach(`${BACKEND_URL}/api/pending`, {
-    headers: { authorization: `Bearer ${token}` }
+    headers: {
+      authorization: `Bearer ${token}`,
+      ...opts.replyAck ? { "x-paigy-await-ack": "1" } : {}
+    }
   }));
   if (!res.ok) throw new Error(`check_replies failed: ${res.status} ${await res.text()}`);
   const pending = await res.json();
+  if (opts.replyAck) return pending;
   return {
     ...pending,
     replies: pending.replies.map((raw) => {
@@ -4255,15 +4298,6 @@ async function heartbeat(runtime, opts = {}) {
   }));
   if (!res.ok) throw new Error(`heartbeat failed: ${res.status}`);
 }
-async function setTaskState(notificationId, state, opts = {}) {
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/notify/${notificationId}/state`, {
-    method: "PATCH",
-    headers: { "content-type": "application/json", authorization: `Bearer ${authToken(opts.token)}` },
-    body: JSON.stringify({ state })
-  }));
-  if (!res.ok) throw new Error(`set_task_state failed: ${res.status} ${await res.text()}`);
-  return await res.json();
-}
 async function registerDelivery(mode) {
   const res = ensureAuthed(await reach(`${BACKEND_URL}/api/delivery`, {
     method: "POST",
@@ -4293,6 +4327,204 @@ async function handoff(req) {
   if (!res.ok) throw new Error(`handoff failed: ${res.status} ${await res.text()}`);
   return await res.json();
 }
+var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var ReplyLeaseExpiredError = class extends Error {
+  constructor() {
+    super(
+      "The Paigy reply lease expired before acknowledgement. The answer remains durable; call await_reply again to reclaim it before acting."
+    );
+    this.name = "ReplyLeaseExpiredError";
+  }
+};
+var ReplyAckError = class extends Error {
+  constructor(message, retryable) {
+    super(message);
+    this.retryable = retryable;
+    this.name = "ReplyAckError";
+  }
+  retryable;
+};
+function ensureAuthed2(res) {
+  if (res.status === 401) throw new UnpairedError();
+  return res;
+}
+function decryptAnswer2(reply, deps = {}) {
+  if (!reply.sealed) return reply.answer;
+  const keyFile = (deps.readKeyFile ?? readKeyFile)();
+  if (!keyFile?.keypair) {
+    throw new Error(
+      "received a sealed answer but this agent has no device key to open it \u2014 re-pair."
+    );
+  }
+  return openSealedAnswer(reply.sealed, keyFile.keypair);
+}
+function landIntents2(intents) {
+  if (!intents?.length) return intents;
+  return intents.map((intent) => {
+    if (intent.kind !== "defer") return intent;
+    const due = parseDue(intent.detail);
+    return due !== null ? { ...intent, dueInSeconds: due } : intent;
+  });
+}
+function decodeReply(item, deps = {}) {
+  const { delivery: _delivery, ...withoutDelivery } = item;
+  const enriched = {
+    ...withoutDelivery,
+    intents: landIntents2(withoutDelivery.intents)
+  };
+  if (!enriched.sealed) return enriched;
+  const answer = decryptAnswer2(enriched, deps);
+  const { sealed: _sealed, ...plaintext } = enriched;
+  return { ...plaintext, answer };
+}
+function deliveryOf(item) {
+  if (item.type !== "reply" || !("delivery" in item) || item.delivery === void 0) {
+    return null;
+  }
+  const delivery = item.delivery;
+  if (!delivery || typeof delivery.leaseId !== "string" || !delivery.leaseId || typeof delivery.expiresAt !== "string" || !delivery.expiresAt) {
+    throw new Error(
+      "Paigy returned invalid reply-delivery metadata; the answer was not acknowledged and remains recoverable."
+    );
+  }
+  return delivery;
+}
+async function responseDetail(res) {
+  try {
+    return (await res.text()).slice(0, 300);
+  } catch {
+    return "";
+  }
+}
+async function acknowledge(token, leaseId, opts = {}) {
+  const attempts = Math.max(1, Math.min(opts.attempts ?? 3, 5));
+  const backoffMs = Math.max(0, opts.backoffMs ?? 100);
+  const doSleep = opts.doSleep ?? sleep2;
+  let lastError;
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    try {
+      const res = ensureAuthed2(await reach(`${BACKEND_URL}/api/await/ack`, {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${token}`,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({ leaseId })
+      }));
+      if (res.ok) return;
+      const detail2 = await responseDetail(res);
+      if (res.status === 409) throw new ReplyLeaseExpiredError();
+      const retryable = res.status === 408 || res.status === 425 || res.status === 429 || res.status >= 500;
+      throw new ReplyAckError(
+        `Paigy reply acknowledgement failed: ${res.status}${detail2 ? ` ${detail2}` : ""}`,
+        retryable
+      );
+    } catch (error) {
+      if (error instanceof UnpairedError || error instanceof ReplyLeaseExpiredError || error instanceof ReplyAckError && !error.retryable) {
+        throw error;
+      }
+      lastError = error;
+      if (attempt + 1 < attempts) {
+        await doSleep(backoffMs * 2 ** attempt);
+      }
+    }
+  }
+  const detail = lastError instanceof Error ? lastError.message : String(lastError);
+  throw new Error(
+    `Could not acknowledge the Paigy reply after ${attempts} attempts (${detail}). The answer was not returned to the agent and remains recoverable after the lease expires.`
+  );
+}
+async function receiveReply(item, token, opts = {}) {
+  const decoded = decodeReply(item, opts);
+  const delivery = deliveryOf(item);
+  if (!delivery) {
+    if (opts.requireDelivery) {
+      throw new Error("Paigy returned a catch-up reply without a delivery lease; the answer was not exposed.");
+    }
+    return decoded;
+  }
+  await acknowledge(token, delivery.leaseId, {
+    attempts: opts.ackAttempts,
+    backoffMs: opts.ackBackoffMs,
+    doSleep: opts.ackSleep
+  });
+  return decoded;
+}
+async function pollAnswer(notificationId, opts = {}) {
+  const token = authToken() ?? "";
+  const res = ensureAuthed2(await reach(
+    `${BACKEND_URL}/api/await?notificationId=${encodeURIComponent(notificationId)}`,
+    {
+      headers: {
+        authorization: `Bearer ${token}`,
+        "x-paigy-await-ack": "1"
+      }
+    }
+  ));
+  if (!res.ok) throw new Error(`await failed: ${res.status} ${await res.text()}`);
+  const wire = await res.json();
+  if (wire.type !== "reply") return wire;
+  return receiveReply(wire, token, opts);
+}
+async function awaitReply(notificationId, opts = {}) {
+  const intervalMs = opts.intervalMs ?? 5e3;
+  const windowMs = opts.windowMs ?? AWAIT_WINDOW_MS;
+  const doSleep = opts.sleep ?? sleep2;
+  const now = opts.now ?? Date.now;
+  const start = now();
+  while (true) {
+    if (opts.signal?.aborted) return { type: "idle" };
+    const item = await pollAnswer(notificationId);
+    if (item.type !== "idle") return item;
+    const partial = await pollPartials(notificationId);
+    if (partial) return partial;
+    if (now() - start >= windowMs) return { type: "idle" };
+    await doSleep(intervalMs);
+  }
+}
+async function checkReplies2(opts = {}) {
+  const pending = await checkReplies({ ...opts, replyAck: true });
+  const token = authToken(opts.token) ?? "";
+  const replies = await Promise.all(pending.replies.map(async (reply) => {
+    const received = await receiveReply(
+      { type: "reply", ...reply },
+      token,
+      { requireDelivery: true }
+    );
+    const { type: _type, ...withoutType } = received;
+    return withoutType;
+  }));
+  return {
+    ...pending,
+    replies
+  };
+}
+function ensureAuthed3(res) {
+  if (res.status === 401) throw new UnpairedError();
+  return res;
+}
+async function setTaskState(notificationId, state, opts = {}) {
+  const token = authToken(opts.token) ?? "";
+  const res = ensureAuthed3(await reach(
+    `${BACKEND_URL}/api/notify/${encodeURIComponent(notificationId)}/state`,
+    {
+      method: "PATCH",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${token}`,
+        "x-paigy-await-ack": "1"
+      },
+      body: JSON.stringify({ state })
+    }
+  ));
+  if (!res.ok) {
+    throw new Error(`set_task_state failed: ${res.status} ${await res.text()}`);
+  }
+  return await res.json();
+}
+function overrideToken2(secret) {
+  overrideToken(secret);
+}
 
 export {
   BACKEND_URL,
@@ -4322,18 +4554,18 @@ export {
   pairStep,
   UnpairedError,
   submitNotification,
-  awaitReply,
   getThread,
   searchThreads,
-  checkReplies,
   answerCallerQuestion,
-  overrideToken,
   hatch,
   whoAmI,
   setIdentity,
   heartbeat,
-  setTaskState,
   registerDelivery,
   scheduleCallback,
-  handoff
+  handoff,
+  awaitReply,
+  checkReplies2,
+  setTaskState,
+  overrideToken2
 };

package/dist/{chunk-JT7I3EGY.js → chunk-YOGAG4YY.js}

@@ -251,10 +251,10 @@ var IntentSchema = z.object({
   // questions included. Found auditing five calls' stored feedback, 2026-08-01.
   kind: z.enum(["defer", "delegate", "channel", "question", "detail", "feedback", "command", "control"]),
   detail: z.string(),
-  /** Landed defer (#397): the MCP parses common spoken forms ("in 20 minutes",
-   *  "after lunch") against the agent machine's clock — the user's — and attaches
-   *  the seconds, ready to pass straight to schedule_callback. Absent when the
-   *  detail didn't parse (the agent interprets it) or the kind isn't defer. */
+  /** Defer only: seconds until the callback the caller asked for, when something upstream
+   *  already read the time. Nothing sets it today (#397 documented an MCP parser that was
+   *  never written) — the API reads the defer's `detail` itself with `notes/when.ts`
+   *  (`parseDelay`, #1292), and a value here simply wins over that reading. */
   dueInSeconds: z.number().int().positive().optional(),
   /** Feedback only (#812): WHICH failure the complaint names — typed by the mapper that
    *  already read the utterance, so `feedback_from_call.kind` stops defaulting to
@@ -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,
@@ -684,7 +696,13 @@ var BrokerTuningSchema = z.object({
    *  uninterpretable, 'high' = whenever not fully certain. */
   clarifyEagerness: z.enum(["low", "normal", "high"]).optional(),
   /** The user's own shorthand: when they say `say`, they mean `mean`. */
-  phrasebook: z.array(z.object({ say: z.string().min(1).max(60), mean: z.string().min(1).max(120) })).max(24).optional()
+  phrasebook: z.array(z.object({ say: z.string().min(1).max(60), mean: z.string().min(1).max(120) })).max(24).optional(),
+  /** The language calls are PLANNED in, when the account has chosen one (#1272). Absent —
+   *  which is every account today — means the agent's own words decide, per ask: a call
+   *  about an English ask opens in English. This is the only thing that overrides that,
+   *  and a live caller who switches language mid-call still outranks it (broker/lang.ts).
+   *  Set per user (no UI yet), like `voiceTuning`. */
+  language: z.enum(["en", "es"]).optional()
 });
 var UserSettingsSchema = z.object({
   permissions: z.object({
@@ -892,7 +910,9 @@ var NoteSchema = z.object({
   /** The request thread minted at assignment; null until assigned. */
   parentId: z.string().nullable(),
   /** REMINDERS (reminders-design.md): the NOT-BEFORE this becomes eligible to ride a
-   *  call — never a deadline, and nothing rings when it passes. Null = "the very next
+   *  call — never a deadline. It only ever comes from the user's own words, so when it
+   *  passes Paigy rings ONCE (#1293, owner 2026-08-26: a time said out loud is consent to
+   *  a ring at that time); after that it rides like any other. Null = "the very next
    *  call", the right reading of "remind me to…" with no time attached. */
   //  Defaulted, not required: a Note from an API deploy older than the reminders
   //  migration has none of these, and the defaults ARE what it means — no not-before,
@@ -935,6 +955,59 @@ var AssignNoteSchema = z.object({
     workspace: z.string().min(1)
   }).optional()
 }).refine((a) => !!a.target !== !!a.spawn, { message: "exactly one of target or spawn" });
+var TriageVerdictSchema = z.enum(["keep", "stale", "close", "assign"]);
+var TriageItemSchema = z.object({
+  noteId: z.string(),
+  /** The note's headline at run time. */
+  title: z.string(),
+  /** WHY, in one short human line, evidence first — this is read on a phone underneath
+   *  the note's title: "no movement in 34 days", "worked 3 notes in this repo this week".
+   *  Never a model's reasoning transcript, never an id. */
+  why: z.string()
+});
+var TriageAssignmentSchema = z.object({
+  /** The agent's token id — what `dispatchNote` resolves and what a request is addressed to. */
+  agent: z.string(),
+  /** Its display name at run time (the name on the hatchling's card). Denormalized for the
+   *  same reason as `title`: the card must render from the proposal alone. */
+  agentName: z.string(),
+  notes: z.array(TriageItemSchema)
+});
+var TriageStatusSchema = z.enum(["open", "superseded", "dismissed"]);
+var SubmitTriageSchema = z.object({
+  /** Which runtime judged: "ollama" (inference never left the machine) or a harness the
+   *  user already runs under their own credentials ("claude" / "codex" / "agy"). Recorded
+   *  so the phone can say where the content went — an unattributed privacy claim is worth
+   *  nothing, and #1106's promise is precisely "Paigy's servers never see this". */
+  provider: z.string().min(1).max(60),
+  /** The concrete model when the provider names one (an ollama tag); null otherwise. */
+  model: z.string().max(200).nullable().optional(),
+  /** How many open notes the run actually looked at — the denominator on the phone
+   *  ("6 of 50"), and the honest answer to "did it read the whole queue?". */
+  reviewed: z.number().int().min(0).max(1e4).default(0),
+  close: z.array(TriageItemSchema).max(200).default([]),
+  stale: z.array(TriageItemSchema).max(200).default([]),
+  assign: z.array(TriageAssignmentSchema).max(50).default([])
+});
+var TriageProposalSchema = SubmitTriageSchema.extend({
+  id: z.string(),
+  runAt: z.string(),
+  status: TriageStatusSchema,
+  model: z.string().nullable().default(null)
+});
+var AcceptTriageSchema = z.discriminatedUnion("group", [
+  z.object({ group: z.literal("close"), noteIds: z.array(z.string()).max(200).optional() }),
+  z.object({ group: z.literal("stale"), noteIds: z.array(z.string()).max(200).optional() }),
+  z.object({
+    group: z.literal("assign"),
+    agent: z.string().min(1),
+    noteIds: z.array(z.string()).max(200).optional()
+  })
+]);
+var AcceptTriageResultSchema = z.object({
+  accepted: z.array(z.string()),
+  failed: z.array(z.object({ noteId: z.string(), reason: z.string() }))
+});
 var DeliveryModeSchema = z.enum(["poll", "self_hosted"]);
 var WAKE_EVENT = "wake";
 var wakeChannel = (tokenId) => `wake:${tokenId}`;

package/dist/enable.js

@@ -2,8 +2,8 @@
 import {
   PAIGY_TOOL_IDS,
   enablePaigyTools
-} from "./chunk-SASREQWV.js";
-import "./chunk-E3OWSUGJ.js";
+} from "./chunk-KNMI3CJ3.js";
+import "./chunk-U6SLIORK.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-YOGAG4YY.js";
 import {
   ENABLE_COMMAND,
   PAIGY_TOOL_IDS,
   autoConfigureClients,
   claudeInstallHint,
   paigyToolsAllowlisted
-} from "./chunk-SASREQWV.js";
+} from "./chunk-KNMI3CJ3.js";
 import {
   clearSurface,
   writeSurface
@@ -22,7 +22,7 @@ import {
   UnpairedError,
   answerCallerQuestion,
   awaitReply,
-  checkReplies,
+  checkReplies2,
   deleteKeyFile,
   deleteToken,
   fetchCredential,
@@ -34,7 +34,7 @@ import {
   lintNotify,
   listSlots,
   normalizeSpeech,
-  overrideToken,
+  overrideToken2,
   pairStep,
   readKeyFile,
   readToken,
@@ -51,7 +51,7 @@ import {
   startE2ee,
   submitNotification,
   whoAmI
-} from "./chunk-E3OWSUGJ.js";
+} from "./chunk-U6SLIORK.js";
 
 // src/index.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -404,7 +404,7 @@ function prependNote(result, note) {
 }
 async function hatchUnderDevice(name, voice) {
   if (!listSlots().includes("Desktop")) return null;
-  overrideToken(readToken("Desktop"));
+  overrideToken2(readToken("Desktop"));
   try {
     const minted = await hatch(name ?? suggestedAgentName() ?? "Agent", voice ?? null);
     const dt = { ok: true, access_token: minted.token, name: minted.name, device: null };
@@ -413,7 +413,7 @@ async function hatchUnderDevice(name, voice) {
   } catch {
     return null;
   } finally {
-    overrideToken(null);
+    overrideToken2(null);
   }
 }
 async function runPair(device_code, name, voice, note) {
@@ -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({}))
     },
     {
@@ -658,7 +658,7 @@ async function handleTool(request, signal) {
       return { content: [{ type: "text", text: JSON.stringify(item) }] };
     }
     case "check_replies": {
-      const result = await checkReplies();
+      const result = await checkReplies2();
       return { content: [{ type: "text", text: JSON.stringify(result) }] };
     }
     case "get_thread": {

package/dist/listen.js

@@ -2,11 +2,11 @@
 import {
   WAKE_EVENT,
   wakeChannel
-} from "./chunk-JT7I3EGY.js";
+} from "./chunk-YOGAG4YY.js";
 import {
-  checkReplies,
+  checkReplies2,
   registerDelivery
-} from "./chunk-E3OWSUGJ.js";
+} from "./chunk-U6SLIORK.js";
 
 // src/listen.ts
 import { createClient } from "@supabase/supabase-js";
@@ -170,7 +170,7 @@ function launchEnv(work, reason) {
 }
 async function sweep(reason) {
   try {
-    const work = await checkReplies();
+    const work = await checkReplies2();
     emit({ type: "sweep", reason, ...work });
     const cmd = process.env.PAIGY_ON_WAKE;
     const inbound = work.replies.length > 0 || work.requests.length > 0;

package/dist/onboard.js

@@ -3,13 +3,13 @@ import {
   autoConfigureClients,
   claudeInstallHint,
   openBrowser
-} from "./chunk-SASREQWV.js";
+} from "./chunk-KNMI3CJ3.js";
 import {
   AGENT_NAME,
   TOKEN_PATH,
   hatch,
   listSlots,
-  overrideToken,
+  overrideToken2,
   pollToken,
   readToken,
   requestCode,
@@ -17,7 +17,7 @@ import {
   setIdentity,
   sleep,
   whoAmI
-} from "./chunk-E3OWSUGJ.js";
+} from "./chunk-U6SLIORK.js";
 
 // src/onboard.ts
 async function main() {
@@ -50,7 +50,7 @@ Paigy MCP onboarding (agent: "${AGENT_NAME}")
     console.log("The saved token is no longer valid \u2014 re-pairing.\n");
   }
   if (listSlots().includes("Desktop")) {
-    overrideToken(readToken("Desktop"));
+    overrideToken2(readToken("Desktop"));
     try {
       const minted = await hatch(process.env.PAIGY_NAME ?? "Agent", null);
       saveToken({ ok: true, access_token: minted.token, name: minted.name, device: null });
@@ -67,7 +67,7 @@ Paigy MCP onboarding (agent: "${AGENT_NAME}")
     } catch {
       console.log("(This machine's saved credential didn't work \u2014 falling back to a code.)\n");
     } finally {
-      overrideToken(null);
+      overrideToken2(null);
     }
   }
   const code = await requestCode();

package/dist/statusline.js

@@ -6,7 +6,7 @@ import {
   BACKEND_URL,
   reach,
   readToken
-} from "./chunk-E3OWSUGJ.js";
+} from "./chunk-U6SLIORK.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.35.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",