@paigy/mcp 0.40.19 → 0.40.20

package/dist/{chunk-VYWIPFEY.js → chunk-6C6CO7H3.js}

@@ -1525,18 +1525,18 @@ var AskInputSchema = z2.object({
   parentId: z2.string().uuid().optional().describe("The Goal this question is about \u2014 usually the one you are working on. The question goes onto that Goal and its answer comes back there. Omit it and Paigy places the question in the tree itself."),
   repo: z2.string().optional().describe("Optional repository context."),
   ask: z2.string().trim().min(1).max(1e4).describe(
-    "ONE question, and only what is needed to answer it. Several questions are several asks in the array, one each: an answer settles the one ask it was given in the shape that ask declares, so a person who answers the part of a bundled ask that interested them settles nothing and is asked again. Paigy reads every ask once and takes a bundled one apart into its own cards anyway \u2014 parts of one piece of work under one Goal, separate things as separate Goals \u2014 but the words it splits are its reading, not yours. News, progress and findings are their own contact; a call contact JOINS a call already happening, so several arrive as one call."
+    "ONE question, and only what is needed to answer it. Several questions are several asks in the array, one each: an answer settles the one ask it was given in the shape that ask declares, so a person who answers the part of a bundled ask that interested them settles nothing and is asked again. Paigy reads every ask once and takes a bundled one apart into its own cards anyway \u2014 each question a Question on the one Goal the ask lands on, never a Goal of its own \u2014 but the words it splits are its reading, not yours. News, progress and findings are their own contact; ANY contact for a person already on a call JOINS that call, whatever channel you asked for, so several arrive as one call."
   ),
-  options: z2.array(OptionInputSchema).min(2).max(6).optional()
+  options: z2.array(OptionInputSchema).min(1).max(6).optional()
 }).strict();
 var StartContactSchema = z2.object({
   asks: z2.array(AskInputSchema).min(1).describe("The questions to pose, one per object. An ask with a parentId is filed on that Goal as it is; only an ask naming no Goal is placed in the tree by Paigy."),
-  waiting: z2.enum(["none", "hard"]).default("none"),
+  waiting: z2.enum(["none", "hard"]).default("none").describe("hard requests a call even when channel is notification; user permissions and ring cooldowns still apply."),
   channel: z2.enum(["notification", "call"]).default("notification")
 }).strict();
 var ContactSchema = z2.union([StartContactSchema, z2.object({ deliveryId: z2.string().uuid() }).strict()]);
 var CONTACT_SCHEMA = { type: "object", ...mcpInputSchema(ContactSchema) };
-var CONTACT_DESCRIPTION = "Contact the user with one or more asks/questions. Pass an array of asks (each with 'ask', optional 'options', 'id', 'parentId', 'repo'), plus channel:'notification'|'call', and waiting:'none'|'hard'. An ask that names a Goal (parentId) goes onto that Goal; one that names none is placed in the person's tree by Paigy. Notification returns immediately; collect durable answers with check_replies. On stdio, a Call holds one cancellable ~45s window; continue with ONLY {deliveryId}. One question per 'ask'; several questions are several objects in 'asks'. A bundled ask is taken apart into its own cards by Paigy's one intake read \u2014 parts of one piece of work under one Goal, separate things as separate Goals. An ask with no options that is not blocking is a report: on a Goal whose report card is still open it is added to that card, with no new push; one that only says where your work stands while under way is recorded as the Goal's progress, not sent (the result says so).";
+var CONTACT_DESCRIPTION = "Contact the user with one or more asks/questions. Pass an array of asks (each with 'ask', optional 'options', 'id', 'parentId', 'repo'), plus channel:'notification'|'call', and waiting:'none'|'hard'. An ask that names a Goal (parentId) goes onto that Goal; one that names none is placed in the person's tree by Paigy. Notification returns immediately; collect durable answers with check_replies. On stdio, a Call holds one cancellable ~45s window; continue with ONLY {deliveryId}. One question per 'ask'; several questions are several objects in 'asks'. A bundled ask is taken apart into its own cards by Paigy's one intake read, every one on the Goal the ask lands on; separate pieces of work are separate asks. An ask with no options that is not blocking is a report, and a report is an UPDATE, never a claim on them: it reaches them and is listed apart from what waits on them, so no answer is owed and none should be awaited. On a Goal whose report card is still open it is added to that card, with no new push; one that only says where your work stands while under way is recorded as the Goal's progress, not sent (the result says so). Send options (or waiting:'hard') when you actually need an answer. If the person is already on a call, your contact joins that call automatically \u2014 whatever channel you asked for, with no ring \u2014 and the Delivery it returns IS that call: reread it with contact({deliveryId}) to see everything answered on it so far, and contact again while it is live to add information or a further question to the same call.";
 var CreateGoalSchema = z3.object({
   outcome: z3.string().trim().min(1).max(1e4),
   /** The work's NAME (#2115) — one to five words, how a person refers to it out loud ("the night
@@ -1574,7 +1574,11 @@ var UpdateGoalSchema = z3.object({
     state: z3.enum(["active", "done", "cancelled"]).optional(),
     progress: z3.string().trim().min(1).max(1e4).optional(),
     reviewed: z3.literal(true).optional(),
-    dueAt: z3.string().datetime({ offset: true }).nullable().optional()
+    dueAt: z3.string().datetime({ offset: true }).nullable().optional(),
+    /** WITHDRAW YOUR OWN QUESTION (#2777, owner 2026-09-30). The question's id as every read shows it
+     *  (the conversation's `id`, eight characters, or the whole request Entry id), on THIS Goal, asked
+     *  by you and still open. It is cancelled, not answered: its cards close and nothing rings for it. */
+    withdraw: z3.array(z3.string().trim().regex(/^[0-9a-fA-F-]{8,36}$/)).min(1).max(10).optional()
   }).strict().refine((v) => Object.keys(v).length > 0),
   reason: z3.string().trim().min(1).max(2e3),
   operationId: z3.string().uuid().optional()
@@ -1585,10 +1589,14 @@ var GetGoalSchema = z3.object({
   goalId: z3.string().uuid(),
   /** Every entry in full. Without it the read carries the person's words, open questions and your
    *  newest entry, and counts what it left out (`apps/api/src/goal/collapse.ts`). */
-  history: z3.boolean().optional()
+  history: z3.boolean().optional(),
+  /** WHEN A READ HAS CONFUSED YOU. Adds `diagnosis`: every reader that already answers a question
+   *  about this work, each answer attributed to the reader that gave it, and every disagreement
+   *  between two of them named. Off by default; `apps/api/src/goal/diagnose-design.md`. */
+  diagnose: z3.boolean().optional()
 }).strict();
-var GET_GOAL_DESCRIPTION = "Read one Goal without claiming it: its outcome, state, revision, progress, blockers, the conversation on it (each question with its options and what was decided), `next`, the one step to take, and `more`, where to read further. The conversation carries everything the person said, every open question and your newest entry; your older entries are left out and counted \u2014 history: true reads every entry in full. Another account's Goals, and another agent's Goal that is not below one of yours, are not disclosed.";
-var UPDATE_GOAL_DESCRIPTION = `Update an owned Goal at an exact revision. State, ownership, dependencies, children, progress, title, and review acknowledgement are explicit; stale revisions are rejected. title is the work's name in one to five words, as a person would refer to it out loud (it is spoken on a call and heads every list); null clears it. reviewed: true acknowledges new evidence and closes the Deliveries addressed to you on that Goal, never over an open decision. dueAt (an ISO instant, or null) makes the Goal wait until then; when it passes you are woken for it \u2014 use it for a promise to follow up later. state: done means the work was accomplished, and it can be reopened: when the person says it is not done ("it's not working"), set state: active on that same Goal instead of starting a new one; its parent reopens with it. cancelled is final. Returns the Goal as get_goal reads it, at its new revision.`;
+var GET_GOAL_DESCRIPTION = "Read one Goal without claiming it: its outcome, state, revision, progress, blockers, the conversation on it (each question with its options and what was decided), `next`, the one step to take, and `more`, where to read further. The conversation carries everything the person said, every open question and your newest entry; your older entries are left out and counted \u2014 history: true reads every entry in full. Another account's Goals, and another agent's Goal that is not below one of yours, are not disclosed.\n\ndiagnose: true is for when a read has CONFUSED you \u2014 not for the working loop. It adds `diagnosis`, which asks every reader that already answers a question about your work and NAMES the reader behind every value, so you never guess which of two places to look: what state your work is really in (the stored `goals.state` beside the derived `goal_execution_state`, which can differ); whether anything is armed to ring and when (`ladder_candidates`, with the ladder's own last decision); whether a wake fired for you and what it did (durable `wake.*` events, beside when your process was last heard from); and what has reached you (`list_waiting` \u2014 review flags, unstarted work, open questions, the person's newest words). Read `diagnosis.disagreements` FIRST: each one is two readers giving different values for the same fact, with both values and both sources, and it never chooses between them \u2014 that is yours to do, from the Goal's own history. `diagnosis.looked` names every reader asked, including any that could not answer, so an empty answer is never confused with a broken one.";
+var UPDATE_GOAL_DESCRIPTION = `Update an owned Goal at an exact revision. State, ownership, dependencies, children, progress, title, and review acknowledgement are explicit; stale revisions are rejected. title is the work's name in one to five words, as a person would refer to it out loud (it is spoken on a call and heads every list); null clears it. reviewed: true acknowledges new evidence and closes the Deliveries addressed to you on that Goal, never over an open decision. dueAt (an ISO instant, or null) makes the Goal wait until then; when it passes you are woken for it \u2014 use it for a promise to follow up later. withdraw: [questionId] takes back a question YOU asked on this Goal that is still open \u2014 because you acted on it yourself, it no longer matters, or you asked it wrongly (e.g. waiting: hard when nothing was blocked): it is cancelled, not answered, its card closes and it stops ringing; the id is the one the conversation shows. state: done means the work was accomplished, and it can be reopened: when the person says it is not done ("it's not working"), set state: active on that same Goal instead of starting a new one; its parent reopens with it. state: done while children are still open records your part as done: the Goal waits and closes by itself when its last open child closes. cancelled is final. Returns the Goal as get_goal reads it, at its new revision.`;
 var CLAIM_GOAL_DESCRIPTION = "Claim the oldest runnable or review-pending Goal you own, or pass goalId to claim that Goal. Another agent's Goal that has gone quiet for 3 days (check_replies lists them as stalledOthers) is taken over when you claim it, and becomes yours to finish or cancel. Returns the Goal as get_goal reads it, and creates or renews the execution lease.";
 var CHECK_REPLIES_DESCRIPTION = "What is waiting for you: your open Deliveries (a request the user started toward you, a handoff), one row each with its Goals, how many decisions are still open, and the newest words in brief; `assigned`, your Goals nobody has started yet, however they became yours (claim_goal({goalId}) starts one); and `review`, your Goals with something new on them \u2014 the user's answers and notes are Entries on the Goal, not Deliveries. A pure read with no arguments: nothing is consumed, acknowledged or claimed by reading it, so call it on startup, after a long wait, or whenever you want to know what is outstanding. To act on one, claim its Goal (claim_goal) or reread a Delivery in full with contact({deliveryId}). Once you have acted on what arrived, update_goal with reviewed: true clears the Goal from `review` and closes the Deliveries addressed to you on it.";
 var CheckRepliesSchema = z3.object({}).strict();
@@ -2207,18 +2215,20 @@ var UserSettingsSchema = z4.object({
    *  clobber guard as voiceMode: absent = leave unchanged on write. */
   broker: BrokerTuningSchema.optional()
 });
-var HistoryItemSchema = z4.object({
+var HistoryWorkSchema = z4.object({
   id: z4.string(),
-  /** 'user' = a request you sent; 'agent' = a notification an agent sent you. */
-  initiator: z4.enum(["user", "agent"]),
   title: z4.string(),
-  /** The agent on the other end (its name). */
-  name: z4.string(),
-  createdAt: z4.string(),
-  /** When the agent fetched your request (user→agent only). */
-  agentAckedAt: z4.string().nullable(),
-  /** When you answered the agent's notification (agent→user only). */
-  humanAckedAt: z4.string().nullable()
+  state: z4.enum(["done", "cancelled"]),
+  /** Who held it (`agent:<tokenId>` or `human:<userId>`). */
+  assignee: z4.string()
+});
+var HistoryEntrySchema = z4.union([
+  z4.object({ at: z4.string(), card: InboxItemSchema }),
+  z4.object({ at: z4.string(), work: HistoryWorkSchema })
+]);
+var HistoryPageSchema = z4.object({
+  entries: z4.array(HistoryEntrySchema),
+  next: z4.string().nullable()
 });
 var ACTIVITY_LINES = 2;
 var ACTIVITY_LINE_MAX = 80;
@@ -2402,6 +2412,9 @@ var QueueItemSchema = z4.object({
   progressLine: z4.string().nullable().optional(),
   reviewPending: z4.boolean().default(false),
   dueAt: z4.string().nullable().default(null),
+  /** WHEN ITS OWNER SAID DONE WHILE CHILDREN WERE OPEN (#2704): its own work is finished and it closes
+   *  with its last open child. Null otherwise; optional, so hand-built queues need not spell it. */
+  finishedAt: z4.string().nullable().optional(),
   /** The Goal this one was opened under; null at the root. */
   parentGoalId: z4.string().nullable().default(null),
   /** Goals opened under this one — only those the same list holds. */
@@ -2410,8 +2423,17 @@ var QueueItemSchema = z4.object({
   dependencyGoalIds: z4.array(z4.string()).default([]),
   /** True while any gate is on a Goal that is not done — the walk draws it dashed. */
   blocked: z4.boolean().default(false),
-  /** Every decision need on it, open or settled — the page decides which to show. */
+  /** Its questions: every OPEN one, and at most ten settled, newest settled first
+   *  (20260929133308) — the page decides which of them to show. NOT the whole set: `asked` and
+   *  `answered` are, and a settled one's words are a line (280 characters), its body read when the
+   *  question is opened. */
   questions: z4.array(QueueQuestionSchema).default([]),
+  /** HOW MANY QUESTIONS THIS WORK HAS ASKED, and how many are answered — the Goal's own totals,
+   *  bounded at 100 server-side. A tally counted off `questions` is a wrong number that looks
+   *  right once the cap bites (`walk/trees.ts` `tallyOf`). Optional, and defaulted from the array
+   *  by the projection, so hand-built queues (fixtures, the demo) need not spell them. */
+  asked: z4.number().optional(),
+  answered: z4.number().optional(),
   /** Every note on it the person replied to (`QueueReplySchema`) — the page decides which to show.
    *  Optional, not defaulted: absent is none, and every hand-built queue (fixtures, the demo) need
    *  not spell an empty list. */
@@ -2548,6 +2570,19 @@ var DeliveryConfigSchema = z4.object({
    *  carries credentials; only a `poll` registration can come back with null here. */
   realtime: z4.object({ url: z4.string(), anonKey: z4.string() }).nullable()
 });
+var HostDecisionSchema = z4.object({
+  /** The agent's token id: the row's `recipient`. */
+  agent: z4.string().uuid(),
+  decision: z4.enum(["stood_back", "took_over"]),
+  /** The work it was about: the Goal `claim_goal` would hand that agent next. */
+  goalId: z4.string().uuid().nullable().optional(),
+  /** When the server last heard from the agent, as the host read it: the presence it stood back for. */
+  seenAt: z4.string().datetime().nullable().optional(),
+  /** When that work last moved (`claimable.since` on `check_replies`), the fact the bound is judged on. */
+  since: z4.string().datetime().nullable().optional(),
+  /** What the host said, in its log's own words: why it stood back, or what the take-over did. */
+  said: z4.string().max(300).optional()
+});
 var WakeNudgeSchema = z4.object({
   kind: z4.enum(["reply", "request", "callback"]),
   notificationId: z4.string().optional(),
@@ -2592,6 +2627,9 @@ var DeviceTokenSchema = z4.object({
    *  landed in the FIRST granted workspace and the agent rediscovered its own repo from
    *  the thread each time (host.ts, live catch 2026-08-06 — prompt-papered until now). */
   workspace: z4.string().nullable().optional(),
+  /** Local host recovery must preserve the launch's runtime and Paigy identity. */
+  harness: z4.enum(["claude", "codex", "agy"]).optional(),
+  session_id: z4.string().uuid().optional(),
   uik_pub: z4.string().nullable().optional()
 });
 var SupportRequestSchema = z4.object({
@@ -2771,7 +2809,7 @@ function updateSlot(agent2, patch) {
 }
 function slotIdentity(agent2) {
   const t = readTokenFile()[agent2];
-  return { name: t?.name ?? null, voice: t?.voice ?? null, tokenId: t?.token_id ?? null, workspace: t?.workspace ?? null };
+  return { name: t?.name ?? null, voice: t?.voice ?? null, tokenId: t?.token_id ?? null, workspace: t?.workspace ?? null, harness: t?.harness ?? null, sessionId: t?.session_id ?? null };
 }
 var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 function readToken(agent2 = agentName()) {
@@ -2835,9 +2873,21 @@ var UnpairedError = class extends Error {
     this.name = "UnpairedError";
   }
 };
-function ensureAuthed(res) {
-  if (res.status === 401) throw new UnpairedError();
-  return res;
+var RevokedError = class extends UnpairedError {
+  constructor() {
+    super();
+    this.message = "This identity was revoked (the API answered 401 revoked): its credential is gone for good. Pairing again makes a new identity.";
+    this.name = "RevokedError";
+  }
+};
+async function ensureAuthed(res) {
+  if (res.status !== 401) return res;
+  let body = null;
+  try {
+    body = await res.json();
+  } catch {
+  }
+  throw body?.error === "revoked" ? new RevokedError() : new UnpairedError();
 }
 var ApiError = class extends Error {
   status;
@@ -2864,7 +2914,7 @@ async function fail(what, res) {
 }
 async function createGoal(input, opts = {}) {
   const token = authToken(opts.token) ?? "";
-  const res = ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/goals`, {
+  const res = await ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/goals`, {
     method: "POST",
     headers: { "content-type": "application/json", authorization: `Bearer ${token}`, "x-paigy-model": "goal-entry-v1" },
     body: JSON.stringify(input)
@@ -2874,13 +2924,14 @@ async function createGoal(input, opts = {}) {
 }
 async function claimGoal(goalId, opts = {}) {
   const token = authToken(opts.token) ?? "";
-  const res = ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/goals/claim`, { method: "POST", headers: { "content-type": "application/json", authorization: `Bearer ${token}`, "x-paigy-model": "goal-entry-v1" }, body: JSON.stringify(goalId ? { goalId } : {}) }));
+  const res = await ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/goals/claim`, { method: "POST", headers: { "content-type": "application/json", authorization: `Bearer ${token}`, "x-paigy-model": "goal-entry-v1" }, body: JSON.stringify(goalId ? { goalId } : {}) }));
   if (!res.ok) await fail("claim_goal", res);
   return await res.json();
 }
 async function getGoal(goalId, opts = {}, read = {}) {
   const token = authToken(opts.token) ?? "";
-  const res = ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/goals/${encodeURIComponent(goalId)}${read.history ? "?history=1" : ""}`, {
+  const query = [read.history ? "history=1" : "", read.diagnose ? "diagnose=1" : ""].filter(Boolean).join("&");
+  const res = await ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/goals/${encodeURIComponent(goalId)}${query ? `?${query}` : ""}`, {
     method: "GET",
     headers: { authorization: `Bearer ${token}`, "x-paigy-model": "goal-entry-v1" }
   }));
@@ -2890,13 +2941,13 @@ async function getGoal(goalId, opts = {}, read = {}) {
 async function updateGoal(goalId, input, opts = {}) {
   const token = authToken(opts.token) ?? "";
   const operationId = input.operationId ?? randomUUID2();
-  const res = ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/goals/${encodeURIComponent(goalId)}`, { method: "PATCH", headers: { "content-type": "application/json", authorization: `Bearer ${token}`, "x-paigy-model": "goal-entry-v1" }, body: JSON.stringify({ ...input, operationId }) }));
+  const res = await ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/goals/${encodeURIComponent(goalId)}`, { method: "PATCH", headers: { "content-type": "application/json", authorization: `Bearer ${token}`, "x-paigy-model": "goal-entry-v1" }, body: JSON.stringify({ ...input, operationId }) }));
   if (!res.ok) await fail("update_goal", res);
   return await res.json();
 }
 var AWAIT_WINDOW_MS = 45e3;
 async function hatch(name, voice = null) {
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/hatch`, {
+  const res = await ensureAuthed(await reach(`${BACKEND_URL}/api/hatch`, {
     method: "POST",
     headers: { "content-type": "application/json", authorization: `Bearer ${authToken()}` },
     body: JSON.stringify({ name, voice })
@@ -2918,7 +2969,7 @@ var NameTakenError = class extends Error {
   code = "agent_name_taken";
 };
 async function setIdentity(patch, opts = {}) {
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/identity`, {
+  const res = await ensureAuthed(await reach(`${BACKEND_URL}/api/identity`, {
     method: "PATCH",
     headers: { "content-type": "application/json", authorization: `Bearer ${authToken(opts.token)}` },
     body: JSON.stringify(patch)
@@ -2938,19 +2989,27 @@ async function setIdentity(patch, opts = {}) {
   return await res.json();
 }
 async function claimSessions(opts = {}) {
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/sessions/claim`, {
+  const res = await ensureAuthed(await reach(`${BACKEND_URL}/api/sessions/claim`, {
     headers: { authorization: `Bearer ${authToken(opts.token)}` }
     // the HOST's identity
   }));
   if (!res.ok) throw new Error(`claim_sessions failed: ${res.status}`);
   return (await res.json()).sessions;
 }
+async function recordDecision(decision, opts = {}) {
+  const res = await ensureAuthed(await reach(`${BACKEND_URL}/api/host/decisions`, {
+    method: "POST",
+    headers: { "content-type": "application/json", authorization: `Bearer ${authToken(opts.token)}` },
+    body: JSON.stringify(decision)
+  }));
+  if (!res.ok) await fail("record_decision", res);
+}
 async function heartbeat(runtime, opts = {}) {
   const body = {
     ...runtime !== void 0 ? { runtime } : {},
     ...opts.activity !== void 0 ? { activity: opts.activity } : {}
   };
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/presence`, {
+  const res = await ensureAuthed(await reach(`${BACKEND_URL}/api/presence`, {
     method: "POST",
     headers: { "content-type": "application/json", authorization: `Bearer ${authToken(opts.token)}` },
     ...Object.keys(body).length > 0 ? { body: JSON.stringify(body) } : {}
@@ -2958,7 +3017,7 @@ async function heartbeat(runtime, opts = {}) {
   if (!res.ok) throw new Error(`heartbeat failed: ${res.status}`);
 }
 async function registerDelivery(mode, opts = {}) {
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/delivery`, {
+  const res = await ensureAuthed(await reach(`${BACKEND_URL}/api/delivery`, {
     method: "POST",
     headers: { "content-type": "application/json", authorization: `Bearer ${authToken(opts.token)}` },
     body: JSON.stringify({ mode })
@@ -2967,21 +3026,21 @@ async function registerDelivery(mode, opts = {}) {
   return await res.json();
 }
 async function listNotes(opts = {}) {
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/notes`, {
+  const res = await ensureAuthed(await reach(`${BACKEND_URL}/api/notes`, {
     headers: { authorization: `Bearer ${authToken(opts.token)}` }
   }));
   if (!res.ok) throw new Error(`list_notes failed: ${res.status} ${await res.text()}`);
   return await res.json();
 }
 async function listConnections(opts = {}) {
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/tokens`, {
+  const res = await ensureAuthed(await reach(`${BACKEND_URL}/api/tokens`, {
     headers: { authorization: `Bearer ${authToken(opts.token)}`, "x-paigy-model": "goal-entry-v1" }
   }));
   if (!res.ok) throw new Error(`list_connections failed: ${res.status} ${await res.text()}`);
   return await res.json();
 }
 async function submitTriage(run, opts = {}) {
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/triage`, {
+  const res = await ensureAuthed(await reach(`${BACKEND_URL}/api/triage`, {
     method: "POST",
     headers: { "content-type": "application/json", authorization: `Bearer ${authToken(opts.token)}` },
     body: JSON.stringify(run)
@@ -2990,14 +3049,14 @@ async function submitTriage(run, opts = {}) {
   return await res.json();
 }
 async function getTriage(opts = {}) {
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/triage`, {
+  const res = await ensureAuthed(await reach(`${BACKEND_URL}/api/triage`, {
     headers: { authorization: `Bearer ${authToken(opts.token)}` }
   }));
   if (!res.ok) throw new Error(`get_triage failed: ${res.status} ${await res.text()}`);
   return await res.json();
 }
 async function acceptTriage(proposalId, body, opts = {}) {
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/triage/${encodeURIComponent(proposalId)}/accept`, {
+  const res = await ensureAuthed(await reach(`${BACKEND_URL}/api/triage/${encodeURIComponent(proposalId)}/accept`, {
     method: "POST",
     headers: { "content-type": "application/json", authorization: `Bearer ${authToken(opts.token)}` },
     body: JSON.stringify(body)
@@ -3006,7 +3065,7 @@ async function acceptTriage(proposalId, body, opts = {}) {
   return await res.json();
 }
 async function dismissTriage(proposalId, opts = {}) {
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/triage/${encodeURIComponent(proposalId)}/dismiss`, {
+  const res = await ensureAuthed(await reach(`${BACKEND_URL}/api/triage/${encodeURIComponent(proposalId)}/dismiss`, {
     method: "POST",
     headers: { authorization: `Bearer ${authToken(opts.token)}` }
   }));
@@ -3062,7 +3121,7 @@ async function contact(input, opts = {}) {
       ask: a.ask,
       options: a.options ?? []
     }));
-    const res = ensureAuthed(await send2(`${BACKEND_URL}/api/goals/contact`, {
+    const res = await ensureAuthed(await send2(`${BACKEND_URL}/api/goals/contact`, {
       method: "POST",
       headers,
       signal: opts.signal,
@@ -3084,15 +3143,17 @@ async function contact(input, opts = {}) {
   }
   const all = deliveries.filter((d) => !!d.deliveryId && !!d.goalId).map(({ id, deliveryId: deliveryId2, goalId }) => ({ ...id ? { id } : {}, deliveryId: deliveryId2, goalId }));
   const joinedCard = deliveries[0]?.joinedCard === true;
+  const joinedCall = deliveries[0]?.joinedCall === true;
   const read = async (signal2) => {
-    const res = ensureAuthed(await send2(`${BACKEND_URL}/api/deliveries/${encodeURIComponent(deliveryId)}`, { headers, signal: signal2 }));
+    const res = await ensureAuthed(await send2(`${BACKEND_URL}/api/deliveries/${encodeURIComponent(deliveryId)}`, { headers, signal: signal2 }));
     if (!res.ok) await fail("read_delivery", res);
     const one = await res.json();
     return {
       ...one,
       ...all.length > 1 ? { deliveries: all } : {},
       ...recorded.length ? { recorded, notSent: NOT_SENT } : {},
-      ...joinedCard ? { joinedCard: true } : {}
+      ...joinedCard ? { joinedCard: true } : {},
+      ...joinedCall ? { joinedCall: true } : {}
     };
   };
   const settled = (d) => d.kind === "notification" || d.state === "closed" || d.answers.length > 0 || d.entries.some((e) => e.kind === "contribution");
@@ -3114,7 +3175,7 @@ async function contact(input, opts = {}) {
   }
 }
 async function checkReplies(opts = {}) {
-  const res = ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/deliveries`, {
+  const res = await ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/deliveries`, {
     headers: { authorization: `Bearer ${authToken(opts.token) ?? ""}`, "x-paigy-model": "goal-entry-v1" }
   }));
   if (!res.ok) await fail("check_replies", res);
@@ -3206,6 +3267,7 @@ function goalView(g) {
     more: more(g)
   });
 }
+var JOINED_CALL = "This ask joined the call the person is ALREADY ON \u2014 no ring, no card of its own. `conversation` above is that whole call, so the answers already given on it before your ask arrived are in it. Yours is queued for the bot's next turn: call contact({deliveryId}) again to keep reading this same call until your answer lands \u2014 do not resend the ask. To add information or a further question to the same call, contact again while it is live; that joins it too.";
 function deliveryView(d) {
   const answers = "Answers land on the Goal: read them with claim_goal or get_goal. Do not poll this notification.";
   return compact({
@@ -3220,7 +3282,8 @@ function deliveryView(d) {
     recorded: d.recorded,
     notSent: d.notSent,
     joinedCard: d.joinedCard,
-    next: d.kind === "notification" ? d.joinedCard ? `Added to the open report card on its Goal; no new push was sent. ${answers}` : answers : d.message
+    joinedCall: d.joinedCall,
+    next: d.joinedCall ? `${JOINED_CALL}${d.message ? ` ${d.message}` : ""}` : d.kind === "notification" ? d.joinedCard ? `Added to the open report card on its Goal; no new push was sent. ${answers}` : answers : d.state === "open" && d.decisionNeeds.some((n) => n.state === "open") ? `Decision pending. Call contact(${JSON.stringify({ deliveryId: d.deliveryId })}) now to continue this same Call; do not resend the ask or end your turn merely because this wait window returned. ${d.message ?? ""}`.trim() : d.message
   });
 }
 function repliesView(r) {
@@ -3255,7 +3318,11 @@ function repliesView(r) {
     next: [
       deliveries.length || r.claimable || review.length || assigned.length ? "Act on a Goal with claim_goal; reread one Delivery in full with contact({deliveryId})." : "Nothing is waiting.",
       ...assigned.length ? [`${assigned.length} of your Goals are assigned to you and not started (assigned): claim_goal({goalId}) to start one.`] : [],
-      ...review.length ? [`${review.length} of your Goals have something new (review): read each with claim_goal or get_goal, then update_goal with reviewed: true.`] : [],
+      // THE PERSON SPOKE, AND THAT IS NOT "SOMETHING NEW" (2026-09-29). This line said only how
+      // many Goals were flagged, so four things the owner said on a call read as four chores. The
+      // rows carry their words now (`said`, `saidAt`, newest first, `delivery/read.ts`); the
+      // sentence names the person and quotes the freshest one, because a count is not a message.
+      ...review.length ? [spoke(review) ?? `${review.length} of your Goals have something new (review): read each with claim_goal or get_goal, then update_goal with reviewed: true.`] : [],
       ...stalled.length ? [`${stalled.length} of your Goals have had no progress for 3 days: update_goal each with progress, finish it, or cancel it.`] : [],
       ...others.length ? [`${others.length} of other agents' Goals have gone quiet for 3 days: claim_goal({goalId}) takes one over, then finish or cancel it with update_goal.`] : [],
       // No name of its own (#2525): the API's ask, verbatim.
@@ -3263,6 +3330,13 @@ function repliesView(r) {
     ].join(" ")
   };
 }
+function spoke(review) {
+  const withWords = review.filter((r) => r.said?.trim());
+  if (!withWords.length) return null;
+  const newest = withWords[0];
+  const rest = review.length - 1;
+  return `The person has spoken on ${withWords.length === 1 ? "one of your Goals" : `${withWords.length} of your Goals`} \u2014 newest, on ${newest.title ?? newest.goalId}: "${newest.said}". Read it with claim_goal or get_goal, answer what it asks, then update_goal with reviewed: true.${rest > 0 ? ` (${rest} more flagged; see review.)` : ""}`;
+}
 async function runTool(name, args, opts) {
   const { waits, signal, ...client } = opts;
   const input = args ?? {};
@@ -3283,8 +3357,11 @@ async function runTool(name, args, opts) {
       return goalView(await claimGoal(goalId, client));
     }
     case "get_goal": {
-      const { goalId, history } = GetGoalSchema.parse(input);
-      return goalView(await getGoal(goalId, client, { history }));
+      const { goalId, history, diagnose } = GetGoalSchema.parse(input);
+      const goal = await getGoal(goalId, client, { history, diagnose });
+      const view = goalView(goal);
+      const diagnosis = goal.diagnosis;
+      return diagnosis === void 0 ? view : { ...view, diagnosis };
     }
     case "update_goal": {
       const { goalId, ...body } = UpdateGoalToolSchema.parse(input);
@@ -3499,6 +3576,7 @@ export {
   requestCode,
   pollToken,
   UnpairedError,
+  RevokedError,
   ApiError,
   overrideToken,
   authToken,
@@ -3512,6 +3590,7 @@ export {
   NameTakenError,
   setIdentity,
   claimSessions,
+  recordDecision,
   heartbeat,
   registerDelivery,
   listNotes,

package/dist/{chunk-76ILN3YV.js → chunk-6MEUSSRH.js}

@@ -4,10 +4,10 @@ import {
   serverInstructions,
   sessionStartHook,
   withSessionStartHook
-} from "./chunk-HGXXGOGG.js";
+} from "./chunk-RLN2B5IZ.js";
 import {
   agentName
-} from "./chunk-VYWIPFEY.js";
+} from "./chunk-6C6CO7H3.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-HGXXGOGG.js → chunk-RLN2B5IZ.js}

@@ -57,18 +57,18 @@ var AskInputSchema = z2.object({
   parentId: z2.string().uuid().optional().describe("The Goal this question is about \u2014 usually the one you are working on. The question goes onto that Goal and its answer comes back there. Omit it and Paigy places the question in the tree itself."),
   repo: z2.string().optional().describe("Optional repository context."),
   ask: z2.string().trim().min(1).max(1e4).describe(
-    "ONE question, and only what is needed to answer it. Several questions are several asks in the array, one each: an answer settles the one ask it was given in the shape that ask declares, so a person who answers the part of a bundled ask that interested them settles nothing and is asked again. Paigy reads every ask once and takes a bundled one apart into its own cards anyway \u2014 parts of one piece of work under one Goal, separate things as separate Goals \u2014 but the words it splits are its reading, not yours. News, progress and findings are their own contact; a call contact JOINS a call already happening, so several arrive as one call."
+    "ONE question, and only what is needed to answer it. Several questions are several asks in the array, one each: an answer settles the one ask it was given in the shape that ask declares, so a person who answers the part of a bundled ask that interested them settles nothing and is asked again. Paigy reads every ask once and takes a bundled one apart into its own cards anyway \u2014 each question a Question on the one Goal the ask lands on, never a Goal of its own \u2014 but the words it splits are its reading, not yours. News, progress and findings are their own contact; ANY contact for a person already on a call JOINS that call, whatever channel you asked for, so several arrive as one call."
   ),
-  options: z2.array(OptionInputSchema).min(2).max(6).optional()
+  options: z2.array(OptionInputSchema).min(1).max(6).optional()
 }).strict();
 var StartContactSchema = z2.object({
   asks: z2.array(AskInputSchema).min(1).describe("The questions to pose, one per object. An ask with a parentId is filed on that Goal as it is; only an ask naming no Goal is placed in the tree by Paigy."),
-  waiting: z2.enum(["none", "hard"]).default("none"),
+  waiting: z2.enum(["none", "hard"]).default("none").describe("hard requests a call even when channel is notification; user permissions and ring cooldowns still apply."),
   channel: z2.enum(["notification", "call"]).default("notification")
 }).strict();
 var ContactSchema = z2.union([StartContactSchema, z2.object({ deliveryId: z2.string().uuid() }).strict()]);
 var CONTACT_SCHEMA = { type: "object", ...mcpInputSchema(ContactSchema) };
-var CONTACT_DESCRIPTION = "Contact the user with one or more asks/questions. Pass an array of asks (each with 'ask', optional 'options', 'id', 'parentId', 'repo'), plus channel:'notification'|'call', and waiting:'none'|'hard'. An ask that names a Goal (parentId) goes onto that Goal; one that names none is placed in the person's tree by Paigy. Notification returns immediately; collect durable answers with check_replies. On stdio, a Call holds one cancellable ~45s window; continue with ONLY {deliveryId}. One question per 'ask'; several questions are several objects in 'asks'. A bundled ask is taken apart into its own cards by Paigy's one intake read \u2014 parts of one piece of work under one Goal, separate things as separate Goals. An ask with no options that is not blocking is a report: on a Goal whose report card is still open it is added to that card, with no new push; one that only says where your work stands while under way is recorded as the Goal's progress, not sent (the result says so).";
+var CONTACT_DESCRIPTION = "Contact the user with one or more asks/questions. Pass an array of asks (each with 'ask', optional 'options', 'id', 'parentId', 'repo'), plus channel:'notification'|'call', and waiting:'none'|'hard'. An ask that names a Goal (parentId) goes onto that Goal; one that names none is placed in the person's tree by Paigy. Notification returns immediately; collect durable answers with check_replies. On stdio, a Call holds one cancellable ~45s window; continue with ONLY {deliveryId}. One question per 'ask'; several questions are several objects in 'asks'. A bundled ask is taken apart into its own cards by Paigy's one intake read, every one on the Goal the ask lands on; separate pieces of work are separate asks. An ask with no options that is not blocking is a report, and a report is an UPDATE, never a claim on them: it reaches them and is listed apart from what waits on them, so no answer is owed and none should be awaited. On a Goal whose report card is still open it is added to that card, with no new push; one that only says where your work stands while under way is recorded as the Goal's progress, not sent (the result says so). Send options (or waiting:'hard') when you actually need an answer. If the person is already on a call, your contact joins that call automatically \u2014 whatever channel you asked for, with no ring \u2014 and the Delivery it returns IS that call: reread it with contact({deliveryId}) to see everything answered on it so far, and contact again while it is live to add information or a further question to the same call.";
 var CreateGoalSchema = z3.object({
   outcome: z3.string().trim().min(1).max(1e4),
   /** The work's NAME (#2115) — one to five words, how a person refers to it out loud ("the night
@@ -106,7 +106,11 @@ var UpdateGoalSchema = z3.object({
     state: z3.enum(["active", "done", "cancelled"]).optional(),
     progress: z3.string().trim().min(1).max(1e4).optional(),
     reviewed: z3.literal(true).optional(),
-    dueAt: z3.string().datetime({ offset: true }).nullable().optional()
+    dueAt: z3.string().datetime({ offset: true }).nullable().optional(),
+    /** WITHDRAW YOUR OWN QUESTION (#2777, owner 2026-09-30). The question's id as every read shows it
+     *  (the conversation's `id`, eight characters, or the whole request Entry id), on THIS Goal, asked
+     *  by you and still open. It is cancelled, not answered: its cards close and nothing rings for it. */
+    withdraw: z3.array(z3.string().trim().regex(/^[0-9a-fA-F-]{8,36}$/)).min(1).max(10).optional()
   }).strict().refine((v) => Object.keys(v).length > 0),
   reason: z3.string().trim().min(1).max(2e3),
   operationId: z3.string().uuid().optional()
@@ -117,10 +121,14 @@ var GetGoalSchema = z3.object({
   goalId: z3.string().uuid(),
   /** Every entry in full. Without it the read carries the person's words, open questions and your
    *  newest entry, and counts what it left out (`apps/api/src/goal/collapse.ts`). */
-  history: z3.boolean().optional()
+  history: z3.boolean().optional(),
+  /** WHEN A READ HAS CONFUSED YOU. Adds `diagnosis`: every reader that already answers a question
+   *  about this work, each answer attributed to the reader that gave it, and every disagreement
+   *  between two of them named. Off by default; `apps/api/src/goal/diagnose-design.md`. */
+  diagnose: z3.boolean().optional()
 }).strict();
-var GET_GOAL_DESCRIPTION = "Read one Goal without claiming it: its outcome, state, revision, progress, blockers, the conversation on it (each question with its options and what was decided), `next`, the one step to take, and `more`, where to read further. The conversation carries everything the person said, every open question and your newest entry; your older entries are left out and counted \u2014 history: true reads every entry in full. Another account's Goals, and another agent's Goal that is not below one of yours, are not disclosed.";
-var UPDATE_GOAL_DESCRIPTION = `Update an owned Goal at an exact revision. State, ownership, dependencies, children, progress, title, and review acknowledgement are explicit; stale revisions are rejected. title is the work's name in one to five words, as a person would refer to it out loud (it is spoken on a call and heads every list); null clears it. reviewed: true acknowledges new evidence and closes the Deliveries addressed to you on that Goal, never over an open decision. dueAt (an ISO instant, or null) makes the Goal wait until then; when it passes you are woken for it \u2014 use it for a promise to follow up later. state: done means the work was accomplished, and it can be reopened: when the person says it is not done ("it's not working"), set state: active on that same Goal instead of starting a new one; its parent reopens with it. cancelled is final. Returns the Goal as get_goal reads it, at its new revision.`;
+var GET_GOAL_DESCRIPTION = "Read one Goal without claiming it: its outcome, state, revision, progress, blockers, the conversation on it (each question with its options and what was decided), `next`, the one step to take, and `more`, where to read further. The conversation carries everything the person said, every open question and your newest entry; your older entries are left out and counted \u2014 history: true reads every entry in full. Another account's Goals, and another agent's Goal that is not below one of yours, are not disclosed.\n\ndiagnose: true is for when a read has CONFUSED you \u2014 not for the working loop. It adds `diagnosis`, which asks every reader that already answers a question about your work and NAMES the reader behind every value, so you never guess which of two places to look: what state your work is really in (the stored `goals.state` beside the derived `goal_execution_state`, which can differ); whether anything is armed to ring and when (`ladder_candidates`, with the ladder's own last decision); whether a wake fired for you and what it did (durable `wake.*` events, beside when your process was last heard from); and what has reached you (`list_waiting` \u2014 review flags, unstarted work, open questions, the person's newest words). Read `diagnosis.disagreements` FIRST: each one is two readers giving different values for the same fact, with both values and both sources, and it never chooses between them \u2014 that is yours to do, from the Goal's own history. `diagnosis.looked` names every reader asked, including any that could not answer, so an empty answer is never confused with a broken one.";
+var UPDATE_GOAL_DESCRIPTION = `Update an owned Goal at an exact revision. State, ownership, dependencies, children, progress, title, and review acknowledgement are explicit; stale revisions are rejected. title is the work's name in one to five words, as a person would refer to it out loud (it is spoken on a call and heads every list); null clears it. reviewed: true acknowledges new evidence and closes the Deliveries addressed to you on that Goal, never over an open decision. dueAt (an ISO instant, or null) makes the Goal wait until then; when it passes you are woken for it \u2014 use it for a promise to follow up later. withdraw: [questionId] takes back a question YOU asked on this Goal that is still open \u2014 because you acted on it yourself, it no longer matters, or you asked it wrongly (e.g. waiting: hard when nothing was blocked): it is cancelled, not answered, its card closes and it stops ringing; the id is the one the conversation shows. state: done means the work was accomplished, and it can be reopened: when the person says it is not done ("it's not working"), set state: active on that same Goal instead of starting a new one; its parent reopens with it. state: done while children are still open records your part as done: the Goal waits and closes by itself when its last open child closes. cancelled is final. Returns the Goal as get_goal reads it, at its new revision.`;
 var CLAIM_GOAL_DESCRIPTION = "Claim the oldest runnable or review-pending Goal you own, or pass goalId to claim that Goal. Another agent's Goal that has gone quiet for 3 days (check_replies lists them as stalledOthers) is taken over when you claim it, and becomes yours to finish or cancel. Returns the Goal as get_goal reads it, and creates or renews the execution lease.";
 var CHECK_REPLIES_DESCRIPTION = "What is waiting for you: your open Deliveries (a request the user started toward you, a handoff), one row each with its Goals, how many decisions are still open, and the newest words in brief; `assigned`, your Goals nobody has started yet, however they became yours (claim_goal({goalId}) starts one); and `review`, your Goals with something new on them \u2014 the user's answers and notes are Entries on the Goal, not Deliveries. A pure read with no arguments: nothing is consumed, acknowledged or claimed by reading it, so call it on startup, after a long wait, or whenever you want to know what is outstanding. To act on one, claim its Goal (claim_goal) or reread a Delivery in full with contact({deliveryId}). Once you have acted on what arrived, update_goal with reviewed: true clears the Goal from `review` and closes the Deliveries addressed to you on it.";
 var CheckRepliesSchema = z3.object({}).strict();
@@ -133,16 +141,15 @@ var AGENT_TOOLS = [
   { name: "update_goal", description: UPDATE_GOAL_DESCRIPTION, inputSchema: mcpInputSchema(UpdateGoalToolSchema) }
 ];
 var AGENT_TOOL_NAMES = AGENT_TOOLS.map((t) => t.name);
-var DONE_MESSAGE = "When the work is done, send one message through contact saying what is done and anything the person needs to do or check.";
 function serverInstructions(opts) {
   const calls = opts.waits ? "A Call holds one bounded window here; continue with contact({deliveryId}) to hold the next or reread that exact Delivery." : "A Call returns after one read; continue with contact({deliveryId}) to reread that exact Delivery.";
-  return `On startup and after a wake, call check_replies for the open Deliveries addressed to you, and claim_goal for your runnable or review-pending Goal and the conversation on it. get_goal rereads it without claiming. Every read ends in \`next\`, the one step to take. Notifications return immediately: keep working and collect answers through claim_goal/get_goal. ${calls} Evidence can repeat: reads do not acknowledge or hide it. Report progress and acknowledge review with update_goal, never as a contact. ${DONE_MESSAGE} Never infer ringing from an open Call Delivery. Soft waiting and re-presentation are unsupported. Your user is remote. Always interact with the user through Paigy. For decisions, approvals, or questions, contact them with structured options. Never assume anyone is reading the terminal stdout.
+  return `On startup and after a wake, call check_replies for the open Deliveries addressed to you, and claim_goal for your runnable or review-pending Goal and the conversation on it. get_goal rereads it without claiming. Every read ends in \`next\`, the one step to take. Notifications return immediately: keep working and collect answers through claim_goal/get_goal. ${calls} Evidence can repeat: reads do not acknowledge or hide it. Report progress and acknowledge review with update_goal, never as a contact. Never infer ringing from an open Call Delivery. Soft waiting and re-presentation are unsupported. Your user is remote. Always interact with the user through Paigy. For decisions, approvals, or questions, contact them with structured options. Never assume anyone is reading the terminal stdout.
 
 HOW TO ASK:
 1. One question per ask. Five questions are five objects in \`asks\`, in one contact, so each can be answered on its own; one question with five parts settles nothing until all five are answered.
 2. Name the Goal you are working on as the ask's \`parentId\`: the question goes onto that Goal and its answer comes back there. Without one, Paigy places it.
 3. \`waiting: hard\` only for a decision you are blocked on; \`waiting: none\` for a question you can keep working around.
-4. Never hold the process open with while-loops. Let the current process finish or schedule a wakeup, and collect answers with \`check_replies\` or \`claim_goal\` on the next wake.`;
+4. Never hold the process open with while-loops. For an open Call with a pending decision, follow its \`next\` with another bounded \`contact({deliveryId})\` tool call; a returned wait window is not a completed conversation. Otherwise, yield only with a working listener or scheduled wakeup, and collect answers with \`check_replies\` or \`claim_goal\` on that wake.`;
 }
 function entryWords(entry) {
   const content = entry.content;
@@ -750,18 +757,20 @@ var UserSettingsSchema = z4.object({
    *  clobber guard as voiceMode: absent = leave unchanged on write. */
   broker: BrokerTuningSchema.optional()
 });
-var HistoryItemSchema = z4.object({
+var HistoryWorkSchema = z4.object({
   id: z4.string(),
-  /** 'user' = a request you sent; 'agent' = a notification an agent sent you. */
-  initiator: z4.enum(["user", "agent"]),
   title: z4.string(),
-  /** The agent on the other end (its name). */
-  name: z4.string(),
-  createdAt: z4.string(),
-  /** When the agent fetched your request (user→agent only). */
-  agentAckedAt: z4.string().nullable(),
-  /** When you answered the agent's notification (agent→user only). */
-  humanAckedAt: z4.string().nullable()
+  state: z4.enum(["done", "cancelled"]),
+  /** Who held it (`agent:<tokenId>` or `human:<userId>`). */
+  assignee: z4.string()
+});
+var HistoryEntrySchema = z4.union([
+  z4.object({ at: z4.string(), card: InboxItemSchema }),
+  z4.object({ at: z4.string(), work: HistoryWorkSchema })
+]);
+var HistoryPageSchema = z4.object({
+  entries: z4.array(HistoryEntrySchema),
+  next: z4.string().nullable()
 });
 var ACTIVITY_LINES = 2;
 var ACTIVITY_LINE_MAX = 80;
@@ -945,6 +954,9 @@ var QueueItemSchema = z4.object({
   progressLine: z4.string().nullable().optional(),
   reviewPending: z4.boolean().default(false),
   dueAt: z4.string().nullable().default(null),
+  /** WHEN ITS OWNER SAID DONE WHILE CHILDREN WERE OPEN (#2704): its own work is finished and it closes
+   *  with its last open child. Null otherwise; optional, so hand-built queues need not spell it. */
+  finishedAt: z4.string().nullable().optional(),
   /** The Goal this one was opened under; null at the root. */
   parentGoalId: z4.string().nullable().default(null),
   /** Goals opened under this one — only those the same list holds. */
@@ -953,8 +965,17 @@ var QueueItemSchema = z4.object({
   dependencyGoalIds: z4.array(z4.string()).default([]),
   /** True while any gate is on a Goal that is not done — the walk draws it dashed. */
   blocked: z4.boolean().default(false),
-  /** Every decision need on it, open or settled — the page decides which to show. */
+  /** Its questions: every OPEN one, and at most ten settled, newest settled first
+   *  (20260929133308) — the page decides which of them to show. NOT the whole set: `asked` and
+   *  `answered` are, and a settled one's words are a line (280 characters), its body read when the
+   *  question is opened. */
   questions: z4.array(QueueQuestionSchema).default([]),
+  /** HOW MANY QUESTIONS THIS WORK HAS ASKED, and how many are answered — the Goal's own totals,
+   *  bounded at 100 server-side. A tally counted off `questions` is a wrong number that looks
+   *  right once the cap bites (`walk/trees.ts` `tallyOf`). Optional, and defaulted from the array
+   *  by the projection, so hand-built queues (fixtures, the demo) need not spell them. */
+  asked: z4.number().optional(),
+  answered: z4.number().optional(),
   /** Every note on it the person replied to (`QueueReplySchema`) — the page decides which to show.
    *  Optional, not defaulted: absent is none, and every hand-built queue (fixtures, the demo) need
    *  not spell an empty list. */
@@ -1089,6 +1110,19 @@ var DeliveryConfigSchema = z4.object({
    *  carries credentials; only a `poll` registration can come back with null here. */
   realtime: z4.object({ url: z4.string(), anonKey: z4.string() }).nullable()
 });
+var HostDecisionSchema = z4.object({
+  /** The agent's token id: the row's `recipient`. */
+  agent: z4.string().uuid(),
+  decision: z4.enum(["stood_back", "took_over"]),
+  /** The work it was about: the Goal `claim_goal` would hand that agent next. */
+  goalId: z4.string().uuid().nullable().optional(),
+  /** When the server last heard from the agent, as the host read it: the presence it stood back for. */
+  seenAt: z4.string().datetime().nullable().optional(),
+  /** When that work last moved (`claimable.since` on `check_replies`), the fact the bound is judged on. */
+  since: z4.string().datetime().nullable().optional(),
+  /** What the host said, in its log's own words: why it stood back, or what the take-over did. */
+  said: z4.string().max(300).optional()
+});
 var WakeNudgeSchema = z4.object({
   kind: z4.enum(["reply", "request", "callback"]),
   notificationId: z4.string().optional(),
@@ -1133,6 +1167,9 @@ var DeviceTokenSchema = z4.object({
    *  landed in the FIRST granted workspace and the agent rediscovered its own repo from
    *  the thread each time (host.ts, live catch 2026-08-06 — prompt-papered until now). */
   workspace: z4.string().nullable().optional(),
+  /** Local host recovery must preserve the launch's runtime and Paigy identity. */
+  harness: z4.enum(["claude", "codex", "agy"]).optional(),
+  session_id: z4.string().uuid().optional(),
   uik_pub: z4.string().nullable().optional()
 });
 var SupportRequestSchema = z4.object({

package/dist/{chunk-TRMYDJ5H.js → chunk-YNKTKLQD.js}

@@ -6,7 +6,7 @@ import {
   saveToken,
   setIdentity,
   sleep
-} from "./chunk-VYWIPFEY.js";
+} from "./chunk-6C6CO7H3.js";
 
 // src/identity.ts
 var CLIENT_LABELS = {

package/dist/{dist-GJOOJ4FR.js → dist-33DA5X2G.js}

@@ -9,6 +9,7 @@ import {
   NameTakenError,
   NotifyRequestSchema,
   PROTO,
+  RevokedError,
   TOKEN_PATH,
   UnpairedError,
   acceptTriage,
@@ -36,6 +37,7 @@ import {
   reach,
   reachAs,
   readToken,
+  recordDecision,
   registerDelivery,
   repoFromRemote,
   requestCode,
@@ -53,7 +55,7 @@ import {
   updateGoal,
   updateSlot,
   whoAmI
-} from "./chunk-VYWIPFEY.js";
+} from "./chunk-6C6CO7H3.js";
 export {
   AGENT_TOOLS,
   AGENT_TOOL_NAMES,
@@ -65,6 +67,7 @@ export {
   NameTakenError,
   NotifyRequestSchema,
   PROTO,
+  RevokedError,
   TOKEN_PATH,
   UnpairedError,
   acceptTriage,
@@ -92,6 +95,7 @@ export {
   reach,
   reachAs,
   readToken,
+  recordDecision,
   registerDelivery,
   repoFromRemote,
   requestCode,

package/dist/enable.js

@@ -3,9 +3,9 @@ import {
   PAIGY_TOOL_IDS,
   enablePaigyTools,
   installSessionListening
-} from "./chunk-76ILN3YV.js";
-import "./chunk-HGXXGOGG.js";
-import "./chunk-VYWIPFEY.js";
+} from "./chunk-6MEUSSRH.js";
+import "./chunk-RLN2B5IZ.js";
+import "./chunk-6C6CO7H3.js";
 
 // src/enable.ts
 function main() {

package/dist/index.js

@@ -6,7 +6,7 @@ import {
   resolvePairing,
   startPairing,
   suggestedAgentName
-} from "./chunk-TRMYDJ5H.js";
+} from "./chunk-YNKTKLQD.js";
 import {
   ENABLE_COMMAND,
   OnboardSchema,
@@ -15,11 +15,11 @@ import {
   SERVER_INSTRUCTIONS,
   TOOLS,
   paigyToolsAllowlisted
-} from "./chunk-76ILN3YV.js";
+} from "./chunk-6MEUSSRH.js";
 import {
   decideListen,
   listenerAlive
-} from "./chunk-HGXXGOGG.js";
+} from "./chunk-RLN2B5IZ.js";
 import {
   clearSurface,
   writeSurface
@@ -39,7 +39,7 @@ import {
   sessionId,
   slotName,
   whoAmI
-} from "./chunk-VYWIPFEY.js";
+} from "./chunk-6C6CO7H3.js";
 
 // src/index.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";

package/dist/listen.js

@@ -3,7 +3,7 @@ import {
   entryWords,
   removeListenMark,
   writeListenMark
-} from "./chunk-HGXXGOGG.js";
+} from "./chunk-RLN2B5IZ.js";
 import {
   agentName,
   checkReplies,
@@ -11,7 +11,7 @@ import {
   getGoal,
   slotName,
   subscribeWake
-} from "./chunk-VYWIPFEY.js";
+} from "./chunk-6C6CO7H3.js";
 
 // src/listen.ts
 import { spawn } from "child_process";
@@ -124,6 +124,7 @@ var { brief: BRIEF, release: RELEASE } = listenOptions(process.argv);
 var line = (text) => void process.stdout.write(text + "\n");
 var emit = (obj) => line(JSON.stringify(obj));
 var listeningAs = () => slotName(agentName()) ?? agentName();
+var SWEEP_EVERY_MS = Number(process.env.PAIGY_SWEEP_MS) || 9e4;
 function saidIn(delivery) {
   return ("entries" in delivery ? delivery.entries : []).filter((entry) => entry.kind === "contribution").map((entry) => entryWords(entry)).filter(Boolean).join("\n");
 }
@@ -192,7 +193,10 @@ async function main() {
   process.on("exit", () => removeListenMark(slot));
   if (!BRIEF) emit({ type: "listening", channel: sub.channel });
   await sweep("boot");
+  const heartbeat = setInterval(() => void sweep("timer"), SWEEP_EVERY_MS);
+  heartbeat.unref?.();
   const shutdown = async () => {
+    clearInterval(heartbeat);
     removeListenMark(slot);
     await sub.close();
     process.exit(0);
@@ -224,6 +228,7 @@ if (isEntry()) {
   }
 }
 export {
+  SWEEP_EVERY_MS,
   brief,
   catchUpReason,
   launchEnv,

package/dist/onboard.js

@@ -3,13 +3,13 @@ import {
   resolvePairing,
   startPairing,
   suggestedAgentName
-} from "./chunk-TRMYDJ5H.js";
+} from "./chunk-YNKTKLQD.js";
 import {
   autoConfigureClients,
   claudeInstallHint,
   openBrowser
-} from "./chunk-76ILN3YV.js";
-import "./chunk-HGXXGOGG.js";
+} from "./chunk-6MEUSSRH.js";
+import "./chunk-RLN2B5IZ.js";
 import {
   TOKEN_PATH,
   agentName,
@@ -20,7 +20,7 @@ import {
   saveToken,
   setIdentity,
   whoAmI
-} from "./chunk-VYWIPFEY.js";
+} from "./chunk-6C6CO7H3.js";
 
 // src/onboard.ts
 function reportRegistered() {

package/dist/slot.js

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

package/dist/stalled.js

@@ -29,7 +29,7 @@ async function main() {
   const dir = join(homedir(), ".paigy", "stalled-reminded");
   const mark = join(dir, `${session || "session"}-${day}`);
   if (existsSync(mark)) return;
-  const { checkReplies } = await import("./dist-GJOOJ4FR.js");
+  const { checkReplies } = await import("./dist-33DA5X2G.js");
   const reply = stopReply((await checkReplies()).stalled ?? [], input.hook_event_name ?? "Stop");
   if (!reply) return;
   mkdirSync(dir, { recursive: true });

package/dist/statusline.js

@@ -7,7 +7,7 @@ import {
   readToken,
   sessionSlot,
   slotName
-} from "./chunk-VYWIPFEY.js";
+} from "./chunk-6C6CO7H3.js";
 
 // src/statusline.ts
 import { realpathSync } from "fs";

package/package.json

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