@paigy/mcp 0.40.38 → 0.40.40

package/dist/{chunk-3YXZUGFL.js → chunk-H2EBILBE.js}

@@ -1,4 +1,4 @@
-// ../../../../../../private/tmp/paigy-draft-reaches/packages/schema/dist/index.js
+// ../../packages/schema/dist/index.js
 import { z as z12 } from "zod";
 import { z } from "zod";
 import { z as z3 } from "zod";
@@ -17,6 +17,7 @@ import { zodToJsonSchema as zodToJsonSchema5 } from "zod-to-json-schema";
 import { z as z10 } from "zod";
 import { zodToJsonSchema as zodToJsonSchema6 } from "zod-to-json-schema";
 import { z as z11 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema7 } from "zod-to-json-schema";
 var OPTIONS_MIN = 2;
 var OPTIONS_MAX = 6;
 var OPTION_LABEL_MAX = 50;
@@ -46,7 +47,7 @@ var OptionInputSchema = z.object({
   imgUrl: OptionSchema.shape.image
 }).strict();
 var NIGHT = { from: 23, to: 7 };
-var ASK_MAX = 250;
+var ASK_MAX = 80;
 var UNITS_MAX = 12;
 var UNIT_TITLE_MAX = 50;
 var UNIT_BODY_MAX = 200;
@@ -111,15 +112,15 @@ var CompletionSchema = z3.object({
 }).strict();
 var CompleteChangeSchema = CompletionSchema.extend({ kind: z3.literal("complete") });
 var ASKING_RULES = `HOW TO ASK:
-1. Write one question per object. Five questions are five objects in \`questions\`, 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 question's \`goalId\`: the question goes onto that Goal and its answer comes back there. It must exist: create it with manage_goals first.
-3. \`workItBlocks\` only for work you are truly blocked on (it asks for a call); leave it out for a question you can keep working around.
-4. Never hold the process open with while-loops. A wait that comes back \`expired\` is not a finished conversation: wait again with contact({wait:true}) only while you have nothing else to do. While a Call you placed is open, keep receiving window after window until it ends, even when a window is empty: the person may give follow-ups or instructions. With no open Call, STOP WAITING when a window comes back with nothing new \u2014 the question stays open, and its answer reaches you on the Goal. Otherwise, yield only with a working listener or scheduled wakeup, and collect answers with \`contact({wait:false})\` or \`get_goals\` on that wake.
-5. One question, one row. Never restate a question that is still waiting inside a new contact: keep waiting on the original, or the answer lands on one copy and the other stays open. Take back one that no longer matters with \`withdrawQuestionIds\`.
-6. Read the Goal's conversation before asking. Never ask again what was answered or already shipped \u2014 and tell its states apart: \`answered\` carries the choice in \`answer\`, while \`replied\` means they said something and chose none of your options, so that question is still yours to settle and their words are the line beside it.
-7. A question carries its options when you have them; a free-text question may omit them. Each option\u2019s label must stand on its own and name its choice in full -- never \`All three\` or \`Option 2\`. \`pickMode: "many"\` makes the card a checklist (options they may want several of); \`"one"\`, the default, a pick (one rules out the others); \`"rank"\` an ordering. Each question is sent exactly as written, with no reading in between. They can always answer in their own words, so never add an 'Other' option.
-8. A diagnosis says when, why and how it happens, then proposes one fix. Never options first.
-9. GIVE A REPORT ITS REPLY: an update takes \`reply\` too, one line the person can tap instead of typing, written in THEIR voice for THAT report ("Sounds good, I'll test later") \u2014 the same care you give a question's options. What they tap is what you read back, which tells you whether they verified your work or only received it. One line, because a report has one way to close, and it may not change what happens next: a reply that would is a question. Requested delivery and completed-Goal reports require a reply (reply_required); ordinary progress may omit it.`;
+1. One question per object in \`questions\`, so each is answered on its own.
+2. \`goalId\` names the existing Goal it is about (create one with manage_goals first); the answer comes back there.
+3. \`workItBlocks\` only when you are truly blocked: it asks for a call.
+4. No while-loops. While any Call is open, even one your question joined from their items, keep receiving through empty windows; otherwise stop at one: the answer reaches you on the Goal. Yield only with a listener or wakeup.
+5. One question, one row: never re-send one still waiting; take back one that no longer matters with \`withdrawQuestionIds\`.
+6. Read the Goal before asking; never re-ask what was answered or shipped. \`replied\` means they chose no option: it is still yours to settle.
+7. Give options when you have them. Each label names its choice in full (never "Option 2"); never add "Other". \`pickMode\`: one (default), many, rank.
+8. A diagnosis says when, why and how it happens, then proposes one fix.
+9. Give a report its \`reply\`: one line in THEIR voice for THAT report, so you learn whether they verified it or only received it. Required when it reaches them or completes a Goal.`;
 function draft2020(node) {
   if (Array.isArray(node)) return node.map(draft2020);
   if (node && typeof node === "object") {
@@ -162,7 +163,7 @@ var userExplicitlyRequested = z4.enum(["any", "call"]).optional().describe(
   `Only what the person said about THIS message, in so many words: "any" when they asked you to send it to them ("send it to my phone", "message me the result"), "call" when they asked to be called about it. It is then delivered (a call rings for the whole contact, and carries everything waiting on them); omitted, an update is only recorded as the Goal's progress unless the person needs it. Never set it to make a message louder.`
 );
 var units = z4.array(UnitInputSchema).optional().describe(
-  `The context this message needs, as up to ${UNITS_MAX} units in reading order, each {title, body}: a title of at most ${UNIT_TITLE_MAX} characters and a body of at most ${UNIT_BODY_MAX}. One idea per unit. Leave it out when the main text says it all.`
+  `The context this message needs, as up to ${UNITS_MAX} units in reading order, each {title, body}: a title of at most ${UNIT_TITLE_MAX} characters and a body of at most ${UNIT_BODY_MAX}. One idea per unit. Leave it out when the main text says it all. Over a cap is refused by name (ask_too_long, too_many_units, unit_title_too_long, unit_body_too_long) and nothing is sent.`
 );
 var UpdateInputSchema = z4.object({
   message: z4.string().trim().min(1).describe(`The one point, at most ${ASK_MAX} characters; the context goes in units.`),
@@ -217,7 +218,7 @@ var questionFields = {
   ),
   goalId: z4.string().uuid().describe("The Goal the question is about, which must exist (create it with manage_goals first). Its answer comes back there."),
   units,
-  options: z4.array(OptionInputSchema).min(1).max(6).optional().describe("The choices, when you have them. Each label stands on its own, at most 50 characters; a hint, at most 200."),
+  options: z4.array(OptionInputSchema).min(1).max(6).optional().describe("The choices, when you have them. Each label stands on its own, at most 50 characters; a hint, at most 200. They can always answer in their own words, so no 'Other' or 'None of these'."),
   // HOW THE OPTIONS ARE ANSWERED, SAID BY THE AGENT (owner, 2026-10-02: "one and many makes sense";
   // brain_prompts.md §1: structured agent questions need no model). The app draws all three.
   pickMode: z4.enum(["one", "many", "rank"]).optional().describe(
@@ -259,7 +260,9 @@ var QuestionDependencySchema = z4.object({
   reason: reason.optional()
 }).strict().refine(actionFits, ACTION_FITS);
 var sendFields = {
-  completions: z4.array(CompletionSchema).min(1).max(20).optional().describe("Close existing Goals and deliver their completion reports atomically. Ordinary updates never close work."),
+  completions: z4.array(CompletionSchema).min(1).max(20).optional().describe(
+    "COMPLETIONS close and report in one operation, the same contract as manage_goals kind:complete: closure and the report commit together or neither does. Required children and dependencies must already be finished. options suggest next steps: a tap acknowledges the report and requests that step, and never reopens the Goal (follow-up work needs a new one). No reviewer rejudges it: say only what your evidence supports. Ordinary updates never close a Goal."
+  ),
   updates: z4.array(UpdateInputSchema).min(1).max(20).optional().describe(
     "News: progress, findings, a result. An update asks nothing. It reaches the person only when they asked for it (userExplicitlyRequested), when it answers something they said, or once its Goal is done; otherwise it is recorded as the Goal's progress and nobody is notified."
   ),
@@ -273,7 +276,7 @@ var sendFields = {
 };
 var ContactSchema = z4.object({
   ...sendFields,
-  questions: z4.array(QuestionInputSchema).min(1).max(20).optional().describe("Questions for the person, one per object."),
+  questions: z4.array(QuestionInputSchema).min(1).max(20).optional().describe("Questions for the person, one per object, each sent exactly as written, with no reading in between."),
   /** RECEIVING (2I, I2; brain_prompts.md §2.2): the events this agent handled. */
   ackEventIds: z4.array(z4.string().uuid()).min(1).max(100).optional().describe(
     "The exact eventIds of the events you have handled: an acknowledgment (ACK). Reading alone acknowledges nothing, so an event comes back until you acknowledge it; after that the next batch can come. Each recipient acknowledges separately, for itself only. A Question you owe is answered (answers), never acknowledged away."
@@ -289,15 +292,13 @@ var ContactWireSchema = z4.object({
   questions: z4.array(QuestionWireSchema).min(1).max(20).optional()
 }).strict().refine(sendsAnything, "a contact sends at least one update, question, answer, withdrawal or question dependency");
 var CONTACT_SCHEMA = { type: "object", ...mcpInputSchema(ContactSchema) };
-var CONTACT_DESCRIPTION = "Send to and receive from the person: completions, updates, questions, answers to questions addressed to you, withdrawals of your own questions, and what a question holds up. Every Goal you name must already exist: create it with manage_goals first; an unknown Goal is refused and nothing is sent. Every item applies on its own: read `results`, where a failed item names why while the rest still apply.\n\n" + ASKING_RULES + `
-
-CUT A LONG MESSAGE BEFORE YOU SEND IT: a question, an update's message or an answer is the one point, in at most ${ASK_MAX} characters; everything else it needs goes in 'units', up to ${UNITS_MAX} {title, body} in reading order, one idea each, every title at most ${UNIT_TITLE_MAX} characters and every body at most ${UNIT_BODY_MAX}. The person sees the main text and the titles, and opens a unit to read its body. Over a cap is refused by name (ask_too_long, too_many_units, unit_title_too_long, unit_body_too_long) and nothing is sent.
+var CONTACT_DESCRIPTION = "Send to and receive from the person: completions, updates, questions, answers to questions addressed to you, withdrawals, and what a question holds up. Every Goal named must exist: an unknown one refuses the whole contact. Each item applies on its own: read `results`, where a failed one names why.\n\n" + ASKING_RULES + `
 
-UPDATES ask nothing, so no answer is owed and none should be awaited. An update reaches the person only when they asked you for it (userExplicitlyRequested), when it answers something they said, or once its Goal is done; any other is recorded as the Goal's progress and nobody is notified. Ordinary updates never close a Goal. On a Goal whose report card is still open, an update that reaches them is added to that card, with no new push. If the person is already on a call, anything that reaches them joins that call, with no ring.
+LENGTH: the question, message or answer is the one point, at most ${ASK_MAX} characters; the rest goes in \`units\`, one idea each. Over a cap is refused by name and nothing is sent. Several results are several updates.
 
-COMPLETIONS close and report in one operation: completions:[{goalId,message,units?,reply,options?}]. The same contract works in manage_goals changes with kind:complete. message is at most 50 characters; use units when useful for initial state, changes, current state (verification and limits), and next steps / leftover work with its owner. reply is one acknowledgement in the person's voice. Optional options:[{label,hint}] suggest next steps: a tap acknowledges the report and requests that step from its author. It never reopens the completed Goal; follow-up work needs a new Goal. Closure and the report commit together or neither does. Required children and dependencies must already be finished. No Reviewer rejudges your completion; say only what your evidence supports.
+UPDATES ask nothing. One reaches the person only when they asked for it, it answers something they said, or its Goal is done; else it is kept as progress. One that reaches them joins an open report card or a live call.
 
-RECEIVING: a contact that sends nothing returns \`events\`, a limited batch of what is addressed to you (not a history page): \`question\`, a Question you owe (answer it in answers, with its questionId); \`update\`, something new on one of your Goals (a reply, an answer: read it with get_goals); \`instruction\`, a request or note sent to you. \`hasMore\` says more are waiting. Reading acknowledges nothing: once you have handled events, confirm their eventIds with contact({ackEventIds}), and the next batch can come. contact({}) waits up to about 45 seconds for something to arrive; contact({wait:false}) returns at once. It also lists work given to you that nobody has started (\`assigned\`; your first write to it starts it) and your work gone quiet (\`stalled\`).`;
+RECEIVING: contact({}) waits ~45 s; contact({wait:false}) returns \`events\` at once. Confirm the ones you handled with contact({ackEventIds}).`;
 var CreateGoalSchema = z5.object({
   outcome: z5.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
@@ -431,8 +432,8 @@ var AGENT_TOOLS = [
 ];
 var AGENT_TOOL_NAMES = AGENT_TOOLS.map((t) => t.name);
 function serverInstructions(opts) {
-  const waits = opts.waits ? "contact({..., wait:true}) holds one bounded ~45 s window for a response to what you sent; contact({}) holds one for anything addressed to you." : "A contact here returns after one read (`waitOutcome: not_waited`); answers wake you, and contact({wait:false}) collects them.";
-  return `On startup and after a wake, call contact({wait:false}) for the events addressed to you (acknowledge the ones you handled with contact({ackEventIds})), which hand you your work: answers, assignments, reviews and due Goals. get_goals reads a Goal and the conversation on it; a read never puts you on it. You are on a Goal from your first write to it (a contact update, question or answer naming it, or a manage_goals change); there is nothing to claim or join. Every Goal of your person is open to you, whichever of their agents owns it: read it with get_goals, write on it (a contact naming its id) and change it (manage_goals). Create, edit, assign and organize work with manage_goals. Complete and report atomically with contact.completions or manage_goals kind:complete; both take the same completion contract. A contact only names Goals that already exist. Every read ends in \`next\`, the one step to take. Sending returns immediately unless you ask it to wait: keep working and collect answers by receiving or through get_goals. ${waits} Events repeat until you acknowledge them: reading alone acknowledges nothing; an \`update\` event acknowledged is a review cleared. Report progress as a contact update: one the person does not need yet is kept as the Goal's progress and reaches no one. To follow up later, defer the Goal with manage_goals: you are woken when its time comes. 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.
+  const waits = opts.waits ? "contact({wait:true}) waits ~45 s for a reply to what you sent; contact({}) for anything addressed to you." : "A contact here returns after one read; answers wake you, and contact({wait:false}) collects them.";
+  return `On startup and after a wake, contact({wait:false}) returns your events. They repeat until you acknowledge them with contact({ackEventIds}); reading acknowledges nothing. get_goals reads a Goal and its conversation; your first write to one puts you on it, and every Goal of your person is open to you. manage_goals creates, assigns and organizes work; to follow up later, defer the Goal with manage_goals (you're woken when due). Complete and report in one step: contact.completions or manage_goals kind:complete. Every read ends in \`next\`: your next step. ${waits} Report progress as a contact update; one they don't need yet stays on the Goal. An open Call is not proof it rang. Your user is remote: reach them only through Paigy, never the terminal; ask decisions with options.
 
 ${ASKING_RULES}`;
 }
@@ -518,11 +519,28 @@ var messageBase = {
   obligationIds: z6.array(id)
 };
 var BrainMessageSchema = z6.union([
-  z6.object({ ...messageBase, to: z6.object({ kind: z6.literal("user") }).strict() }).strict(),
+  // A MESSAGE TO THE PERSON KEEPS ITS SENTENCES (turns.md): the talker writes them one by one, and each is
+  // its own unit of speech (`<cycle>:<key>:<n>`). `text` is the same words joined, for every reader of a
+  // message's words. Absent on results written before sentences.
+  z6.object({
+    ...messageBase,
+    to: z6.object({ kind: z6.literal("user") }).strict(),
+    sentences: z6.array(z6.string().min(1)).min(1).optional(),
+    // THE REPORTS IT TELLS, BY THEIR OWN IDENTITY (call 9d1c096c, 2026-10-15): the talker's message names the report
+    // Entries it speaks of, so the plan's line names that report rather than re-finding it by its Goal. Absent on
+    // results written before it.
+    tells: z6.array(z6.object({ id }).strict()).optional()
+  }).strict(),
   z6.object({
     ...messageBase,
     to: z6.object({ kind: z6.literal("agent"), agentId: z6.string().regex(/^agent:(?!paigy$)\S+$/) }).strict(),
-    call: z6.object({ callId: id, listen: z6.literal(true) }).strict().optional()
+    call: z6.object({ callId: id, listen: z6.literal(true) }).strict().optional(),
+    // WHAT IT ASKS THE AGENT, IN UNDER TEN WORDS (owner, 2026-10-15: "Yes, add the summary"): the talker's own, stored
+    // as the sent Entry's summary, which the recap's "Sent to <agent>: …" row shows. Absent on results written before it.
+    summary: z6.string().optional(),
+    // THE PERSON ASKED TO BE CALLED BACK ONCE THIS AGENT'S WORK IS DONE (turns.md, step 0): the agent owes
+    // the call, and its next contact about it rings them (`public.callbacks`).
+    callback: z6.literal(true).optional()
   }).strict()
 ]);
 var BrainSearchSchema = z6.object({
@@ -546,92 +564,97 @@ var BrainResultSchema = z6.object({
   next: BrainNextSchema,
   search: BrainSearchSchema.optional()
 }).strict();
-var str = z6.string();
+var str2 = z6.string();
 var strs = z6.array(z6.string());
 var CompactResultSchema = z6.object({
-  next: z6.object({ say: strs, then: z6.enum(["listen", "hold", "end", "none"]), waitFor: strs, reason: str, instructions: strs }).strict(),
-  messages: z6.array(z6.object({ key: str, to: str, text: str, about: strs, entries: strs, owed: strs, inviteToCall: z6.boolean() }).strict()),
-  entries: z6.array(z6.object({ key: str, from: str, on: strs }).strict()),
-  answers: z6.array(z6.object({ question: str, entries: strs, summary: str, picked: strs }).strict()),
+  next: z6.object({ say: strs, then: z6.enum(["listen", "hold", "end", "none"]), waitFor: strs, reason: str2, instructions: strs }).strict(),
+  messages: z6.array(z6.object({ key: str2, to: str2, text: str2, about: strs, entries: strs, owed: strs, inviteToCall: z6.boolean() }).strict()),
+  entries: z6.array(z6.object({ key: str2, from: str2, on: strs }).strict()),
+  answers: z6.array(z6.object({ question: str2, entries: strs, summary: str2, picked: strs }).strict()),
   changes: z6.array(z6.object({
-    key: str,
+    key: str2,
     what: z6.enum(["goal", "question", "lesson"]),
     op: z6.enum(["create", "edit", "assign", "open", "complete", "cancel", "defer", "move", "block", "unblock", "withdraw", "remember", "revise"]),
-    id: str,
-    text: str,
-    title: str,
-    who: str,
-    under: str,
+    id: str2,
+    text: str2,
+    title: str2,
+    who: str2,
+    under: str2,
     gate: z6.enum(["start", "complete", "answer", "none"]),
-    options: z6.array(z6.object({ id: str, label: str }).strict()),
+    options: z6.array(z6.object({ id: str2, label: str2 }).strict()),
     pick: z6.enum(["one", "many", "rank", "words"]),
     entries: strs
   }).strict()),
   feedback: z6.array(strs),
-  search: z6.object({ query: str, within: strs, goal: str }).strict()
+  search: z6.object({ query: str2, within: strs, goal: str2 }).strict()
 }).strict();
 var COMPACT_RESULT_JSON_SCHEMA = (({ $schema: _, ...rest }) => rest)(
   zodToJsonSchema2(CompactResultSchema, { $refStrategy: "none" })
 );
-var str2 = z7.string();
+var str3 = z7.string();
 var strs2 = z7.array(z7.string());
 var TalkerReplySchema = z7.object({
   /** What to say and send, messages to the person first: spoken in the order written. `to` is "user"
-   *  or an agent's handle; `about` names handles; `blocks` is the item a question to an agent must be
-   *  answered before ("" for none). */
-  messages: z7.array(z7.object({ key: str2, to: str2, text: str2, about: strs2, blocks: str2 }).strict()),
+   *  or an agent's handle; `sentences` is what a message to the person says, one short sentence each
+   *  ([] to an agent); `text` is what a message to an agent says ("" to the person); `summary` is what it
+   *  asks the agent, in under ten words, as the person would put it ("" to the person; owner, 2026-10-15:
+   *  "Yes, add the summary"), which the recap's "Sent to <agent>: …" row shows; `about` names
+   *  handles; `blocks` is the item a question to an agent must be answered before ("" for none);
+   *  `callback` is true on a message to the agent doing work the person asked to be called back about
+   *  once it is done (false otherwise): that agent then owes the call (turns.md, step 0). */
+  messages: z7.array(z7.object({ key: str3, to: str3, sentences: strs2, text: str3, summary: str3, about: strs2, blocks: str3, callback: z7.boolean() }).strict()),
   /** What the call does next: listen, hold (the person asked for a moment) or end (they asked to). */
   then: z7.enum(["listen", "hold", "end"]),
   /** The person's replies to items (replies, owner 2026-10-07): the item's handle, the chosen option
    *  IDs, the line handles, how they replied in under ten words (keeping any condition), and `defer`:
    *  "" when their words settle the item, else what a reply that puts it off waits for -- "call" (the
    *  end of this call), a question's handle (that question's answer) or an ISO time. */
-  replies: z7.array(z7.object({ item: str2, options: strs2, lines: strs2, summary: str2, defer: str2 }).strict()),
+  replies: z7.array(z7.object({ item: str3, options: strs2, lines: strs2, summary: str3, defer: str3 }).strict()),
   /** The line handles that tell the talker how to run this call; they last until it ends and reach no agent. */
   instruction: strs2,
   /** The line handles the filer acts on, and the only ones it reads (3e): new work, a change to existing
    *  work, feedback on Paigy, anything said to an agent, and any rule meant to outlast the call. */
   file: strs2,
   /** Evidence to fetch for a second round: a search, an item's full text, or an agent by name. */
-  need: z7.object({ kind: z7.enum(["search", "item", "agent", ""]), text: str2 }).strict(),
+  need: z7.object({ kind: z7.enum(["search", "item", "agent", ""]), text: str3 }).strict(),
   /** The handle of the item to explain ("" for none). */
-  explain: str2
+  explain: str3
 }).strict();
 var TALKER_REPLY_JSON_SCHEMA = (({ $schema: _, ...rest }) => rest)(
   zodToJsonSchema3(TalkerReplySchema, { $refStrategy: "none" })
 );
-var str3 = z8.string();
+var str4 = z8.string();
 var strs3 = z8.array(z8.string());
 var FilerReplySchema = z8.object({
   /** Which Goals each new line goes on: a line's handle, Goal handles (or keys of new Goals), and what
    *  the line says in at most ten words. */
-  filed: z8.array(z8.object({ line: str3, goals: strs3, summary: str3 }).strict()),
+  filed: z8.array(z8.object({ line: str4, goals: strs3, summary: str4 }).strict()),
   goals: z8.array(z8.object({
     op: z8.enum(["create", "edit", "complete", "cancel", "reopen", "assign", "defer", "move", "block", "unblock"]),
-    key: str3,
-    goal: str3,
-    title: str3,
-    outcome: str3,
-    owner: str3,
-    under: str3,
-    until: str3,
-    on: str3,
+    key: str4,
+    goal: str4,
+    title: str4,
+    outcome: str4,
+    owner: str4,
+    under: str4,
+    until: str4,
+    on: str4,
     gate: z8.enum(["start", "complete", "answer", ""]),
-    why: str3
+    why: str4
   }).strict()),
   questions: z8.array(z8.object({
     op: z8.enum(["create", "edit", "assign", "withdraw"]),
-    key: str3,
-    question: str3,
-    text: str3,
-    summary: str3,
-    to: str3,
-    goal: str3,
-    options: z8.array(z8.object({ id: str3, label: str3 }).strict()),
+    key: str4,
+    question: str4,
+    text: str4,
+    summary: str4,
+    to: str4,
+    goal: str4,
+    options: z8.array(z8.object({ id: str4, label: str4 }).strict()),
     pick: z8.enum(["one", "many", "rank", "words", ""]),
-    blocks: str3
+    blocks: str4
   }).strict()),
-  lessons: z8.array(z8.object({ op: z8.enum(["remember", "revise", "withdraw"]), lesson: str3, text: str3, scope: str3 }).strict()),
+  lessons: z8.array(z8.object({ op: z8.enum(["remember", "revise", "withdraw"]), lesson: str4, text: str4, scope: str4 }).strict()),
   /** Line handles whose words comment on Paigy itself. */
   feedback: strs3
 }).strict();
@@ -692,6 +715,27 @@ var TidyReplySchema = z10.object({
 var TIDY_REPLY_JSON_SCHEMA = (({ $schema: _, ...rest }) => rest)(
   zodToJsonSchema6(TidyReplySchema, { $refStrategy: "none" })
 );
+var HandoutReplySchema = z11.object({
+  assign: z11.array(z11.object({
+    /** The Goal's handle (G). */
+    goal: z11.string(),
+    /** The agent's handle (A). */
+    to: z11.string(),
+    /** At most ten words, naming the Goal of theirs it is most like: the reason the hand-out records. */
+    why: z11.string()
+  }).strict()),
+  /** The Goals no listed agent's work is even loosely like: Paigy starts a session for them (owner, 2026-10-24,
+   *  Goal 37603006, "One per family of related Goals"). */
+  new: z11.array(z11.object({
+    /** The Goal's handle (G). */
+    goal: z11.string(),
+    /** At most ten words: why nothing active fits it. */
+    why: z11.string()
+  }).strict())
+}).strict();
+var HANDOUT_REPLY_JSON_SCHEMA = (({ $schema: _, ...rest }) => rest)(
+  zodToJsonSchema7(HandoutReplySchema, { $refStrategy: "none" })
+);
 function entryWords(entry) {
   const content = entry.content;
   if (content && "sealed" in content) return "";
@@ -720,42 +764,6 @@ var LIVE_MS = 3 * 6e4;
 var WORKING_MS = 60 * 6e4;
 var WORKING_TIER_MS = 2 * 60 * 6e4;
 var RECENT_TIER_MS = 24 * 60 * 6e4;
-var json = z11.lazy(() => z11.union([
-  z11.string(),
-  z11.number().finite(),
-  z11.boolean(),
-  z11.null(),
-  z11.array(json),
-  z11.record(json)
-]));
-var clock = z11.number().int().nonnegative().safe();
-var HeardEventSchema = z11.object({
-  eventId: z11.string().uuid(),
-  source: z11.enum(["phone", "bot"]),
-  sequence: clock,
-  kind: z11.string().min(1),
-  phoneAtMs: clock.optional(),
-  botAtMs: clock.optional(),
-  payload: z11.record(json)
-}).strict();
-var HeardCursorSchema = HeardEventSchema.pick({ source: true, sequence: true, eventId: true });
-var HeardPageSchema = z11.object({
-  events: z11.array(HeardEventSchema).max(200),
-  next: HeardCursorSchema.nullable()
-}).strict();
-var MAX_EVENTS = 50;
-var MAX_BYTES = 8e4;
-var batchBytes = (events) => {
-  let bytes = 0;
-  for (const char of JSON.stringify({ events })) {
-    const point = char.codePointAt(0);
-    bytes += point < 128 ? 1 : point < 2048 ? 2 : point < 65536 ? 3 : 4;
-  }
-  return bytes;
-};
-var HeardBatchSchema = z11.object({
-  events: z11.array(HeardEventSchema).min(1).max(MAX_EVENTS)
-}).strict().refine((value) => batchBytes(value.events) <= MAX_BYTES, "heard_batch_too_large");
 var ContextSchema = z12.object({
   title: z12.string().min(1).describe("One-line headline of what you need (required, non-empty)."),
   description: z12.array(z12.string().min(1)).describe(
@@ -1080,6 +1088,10 @@ var AgendaTurnSchema = z12.object({
   /** The spoken sentences of the turn, in order. No count: how long a turn is is the brain's call
    *  (owner, 2026-09-25), and a count here refused whole plans. */
   info: z12.array(z12.string().min(1)).default([]),
+  /** THE ID OF EACH SENTENCE, when the plan names them (turns.md): a talker message's sentences are its
+   *  `info`, one piece each, and `units[i]` is the id the bot's line receipt carries for `info[i]`
+   *  (`<cycle>:<key>:<n>`), so what was heard is known per sentence. Absent on every other turn. */
+  units: z12.array(z12.string().min(1)).optional(),
   question: z12.string().min(1).nullable(),
   /** True on the one turn carrying the agent's own declared question. */
   asks: z12.boolean().optional(),
@@ -1104,6 +1116,21 @@ var AgendaTurnSchema = z12.object({
    *  the phone (`asking`, so the agenda goes gold and its options show) without treating the line as a
    *  question turn — the talker owns re-asking and the waits, so `question` stays null. */
   onTable: z12.boolean().optional(),
+  /** THE CARRIED ITEM THIS LINE TELLS (Goal 2a1e50eb, owner 2026-10-14: "Build the whole design") — a
+   *  request the Call carries that asks NOTHING: a report, a progress note, another agent's waiting news.
+   *  Its request Entry id, so the phone can make that agenda row the current one while it is read
+   *  (`telling` on the `turn` topic, `docs/clients/app/walk/design.md` §11).
+   *
+   *  A FIELD OF ITS OWN, NEVER `claimId`: the claim is the RETURN identity — answers route by it and the
+   *  record tags the line with it (`workId`) — and an answer must never route to an Entry that asks
+   *  nothing. Absent on a turn speaking for a question (`claimId` says that) and on one speaking for no
+   *  carried item at all (an opener, a sign-off, Paigy's own line). */
+  telling: z12.string().optional(),
+  /** PAIGY'S OWN LINE (owner, 2026-10-15; calls ed2cbdce, ad50ad25): a turn that speaks for no item -- an
+   *  opener, a sign-off, a reply about nothing an agent asked or told -- is recorded as Paigy's, not as the
+   *  agent that rang. Absent on every turn that speaks for an item (`agentId` names whose), and on plans
+   *  from before it: a bot that does not know it records the ringing agent, as before. */
+  speaksFor: z12.literal("paigy").optional(),
   select: SelectShapeSchema.optional(),
   options: z12.array(OptionSchema.omit({ id: true })).optional(),
   /* `pace` STOOD HERE (#826). A turn could carry seconds and the model chose them. The walk
@@ -1192,7 +1219,7 @@ var InboxItemSchema = z12.object({
   questions: z12.array(CallQuestionSchema).optional(),
   /** The same call carrying order, including request Entries with no DecisionNeed as reports.
    *  Additive: questions stays decision-only for every other surface and older bundles. */
-  callItems: z12.array(CallQuestionSchema.extend({ state: z12.enum(["open", "answered", "report"]) })).optional(),
+  callItems: z12.array(CallQuestionSchema.extend({ state: z12.enum(["open", "answered", "report"]), acknowledged: z12.boolean().optional() })).optional(),
   visuals: z12.array(VisualSchema).optional(),
   /** The connected agent's name (the single pairing name — user-typed, or the
    *  agent's suggestion, or a default silly name). */
@@ -1257,6 +1284,21 @@ var InboxItemSchema = z12.object({
    *  urgency (see the main README's "premier use case" + docs/delivery/notify/states.md). Drives the
    *  inbox's blocking badge and the extra confirm step before dismissing it. */
   blocking: z12.boolean().default(false),
+  /** WHAT FREED THIS QUESTION (owner, 2026-10-16, Goal 2383ef14: "we don't really show the question
+   *  at the top until the question it could reply to with is resolved. And then we show it again
+   *  with the context of the other thing that was resolved"; asked how it should carry that, "The
+   *  answer above it"). A question they answered with a question of their own waits for theirs
+   *  (`private.ask_back`) and drops out of the front while it waits; when it comes back, the card
+   *  draws their question and the answer it got ABOVE the ask, as one card. Absent on a question
+   *  nothing ever held back. */
+  freedBy: z12.object({
+    questionId: z12.string(),
+    asked: z12.string(),
+    answer: z12.string(),
+    answeredAt: z12.string(),
+    /** The answer in ten words, when the talker wrote one beside it. */
+    summary: z12.string().optional()
+  }).optional(),
   /** The user's locked-in answer; present only for replied items (GET /api/replied/:id). */
   answer: UserAnswerSchema.optional(),
   /** THE TARGET FACTS A CARD RENDERS (#1796 point 5, 2026-09-11): the Delivery it is a view of,
@@ -1316,8 +1358,8 @@ var MissedCallSchema = z12.enum([
   "inbox",
   "dismiss"
 ]);
-var clock2 = (h) => h === 0 ? "midnight" : h === 12 ? "noon" : h < 12 ? `${h} am` : `${h - 12} pm`;
-var QUIET = ` Nothing rings from ${clock2(NIGHT.from)} to ${clock2(NIGHT.to)} your time; the count waits for morning.`;
+var clock = (h) => h === 0 ? "midnight" : h === 12 ? "noon" : h < 12 ? `${h} am` : `${h - 12} pm`;
+var QUIET = ` Nothing rings from ${clock(NIGHT.from)} to ${clock(NIGHT.to)} your time; the count waits for morning.`;
 var BrokerTuningSchema = z12.object({
   /** 'none' = skip the spoken ack after a mapped answer (power users find it slow). */
   ackVerbosity: z12.enum(["normal", "none"]).optional(),
@@ -1654,6 +1696,13 @@ var QueueItemSchema = z12.object({
    *  can see (`replies`, `questions[].answeredAt`) miss a spontaneous note entirely — a `request`
    *  Entry with no `about_id` is in neither. */
   lastPersonAt: z12.string().nullable().optional(),
+  /** EACH SIDE'S NEWEST WORD IN THE LAST DAY (owner, 2026-10-13, the Work tab's order): the person's
+   *  (`yours`) and the agents' (`theirs`), each null when that side wrote nothing on it in 24 hours.
+   *  `latest` holds one Entry, so whichever side wrote first is hidden there; Work orders a Goal by
+   *  these two and draws the side it was placed by under its title. Optional, so hand-built queues
+   *  and a door older than 20261013045542 need not spell them. */
+  yours: GoalLatestSchema.nullable().optional(),
+  theirs: GoalLatestSchema.nullable().optional(),
   /** WHAT THIS ROW IS, IN TWELVE CHARACTERS (#2928) — the hash of every other field on it, stamped
    *  by the one projection that builds the row (`apps/api/src/goal/queue.ts`). It is how the
    *  incremental read knows a row has not moved: the phone echoes back the revs it holds
@@ -1925,10 +1974,20 @@ var CallRecapSchema = z12.object({
     title: z12.string(),
     owner: z12.string(),
     state: z12.string(),
+    /** Presented Entry content and its author, separately from the current Goal owner. */
+    items: z12.array(z12.object({ entryId: z12.string(), author: z12.string(), text: z12.string(), summary: z12.string().nullable(), acknowledged: z12.boolean().optional() })).optional(),
     /** Whether the call put it to the person. An item it carried and never said has no row on the
      *  review (owner, 2026-10-08: "why do we get the third one when it didn't happen in the call?"). */
     presented: z12.boolean(),
-    questions: z12.array(z12.object({ id: z12.string().uuid(), state: z12.string(), title: z12.string() })),
+    /** Whether THIS call created it — the third way a call touches work, beside carrying a request
+     *  there and filing words there (owner, 2026-10-08, Goal `5b4b1a0a`: "Show the new work, keep my
+     *  words under it"). Created work is never carried, so it is never `presented`; without this the
+     *  row is dropped by the "only what happened on the call" filter. False on a database before
+     *  20261013080133. */
+    created: z12.boolean(),
+    /** `request` is the Entry that asked it — what a line's `about` names when the line answered or put
+     *  it off. Optional: an older API sent none. */
+    questions: z12.array(z12.object({ id: z12.string().uuid(), state: z12.string(), title: z12.string(), request: z12.string().optional() })),
     /** `words` is always what they SAID, verbatim — the record, never replaced. `summary` is what
      *  the line says in ten words (owner, 2026-10-07): the filer's, or the talker's for the answer it
      *  gave, so the row scans like a chosen option and their own words stay under it. Absent when
@@ -1964,7 +2023,44 @@ var CallRecapSchema = z12.object({
   })),
   more: z12.object({ lines: z12.number(), entries: z12.number(), topics: z12.number() }),
   /** Last stored position on this page when another exists; absent before paging shipped. */
-  next: z12.number().int().nonnegative().nullable().optional()
+  next: z12.number().int().nonnegative().nullable().optional(),
+  /** THE CALL AS ONE LIST OF ROWS (owner, 2026-10-14: "we only really want a thing like transcript but
+   *  built from the summaries", then "the transcript tabs should show the same but with full words").
+   *  Both tabs draw these rows, in this order: Summary from `summary`, Transcript from `words`.
+   *  - `put`: an item put to the person, at the first agent line that voiced it. Paigy's sentences
+   *    that voiced it are folded into `spoken`, never rows of their own.
+   *  - `said`: the person's words, one row per reply or per filed line no reply covers.
+   *  - `did`: what Paigy did ("Sent to Mouth: …", "Recorded: …", "Filed on …").
+   *  `by` is the row's real author, never inferred from `kind`: a relay Paigy sent to an agent is
+   *  Paigy's, not the person's. Optional and additive (owner: "make sure whatever you do is backward
+   *  compatible"): an API before it sends none, and the screen falls back to `topics` and `said`. */
+  timeline: z12.array(z12.object({
+    id: z12.string(),
+    position: z12.number(),
+    atMs: z12.number(),
+    kind: z12.enum(["put", "said", "did"]),
+    by: z12.object({ participant: z12.string().nullable(), agentId: z12.string().nullable(), name: z12.string().nullable() }),
+    goalId: z12.string().uuid().nullable(),
+    requestId: z12.string().nullable(),
+    summary: z12.string().nullable(),
+    words: z12.string(),
+    /** Paigy's sentences folded into this row: on a `put` row, what it said putting the item to the
+     *  person (before their next row); on a `said` row, what it said in reply (until their next row).
+     *  `atMs` is when each was said; optional, absent before 2026-10-14's fix. */
+    spoken: z12.array(z12.object({ lineId: z12.string(), words: z12.string(), atMs: z12.number().optional() })),
+    /** On a `said` row: the work these words were filed on, and whether they answered (recorded) a
+     *  question. They replace the "Filed on ..." and "Recorded: ..." rows that repeated the person's own
+     *  summary (Brain, 2026-10-14). Optional: absent from an API before it. */
+    filedOn: z12.array(z12.object({ goalId: z12.string().uuid(), title: z12.string() })).optional(),
+    recorded: z12.boolean().optional(),
+    settled: z12.object({ requestId: z12.string(), answer: z12.string() }).nullable().optional(),
+    acknowledged: z12.boolean().optional(),
+    /** On a `put` row: still waiting for the person's answer (not settled, not answered, not put off).
+     *  The server's judgement; the screen draws "Still waiting for your answer" from it. Optional: absent
+     *  from an API before it, where the screen falls back to its own reading. */
+    waiting: z12.boolean().optional(),
+    lineIds: z12.array(z12.string())
+  })).optional()
 });
 
 // src/listening.ts
@@ -1985,14 +2081,21 @@ function sessionStartHook() {
 [ -f "\${HOME}/.paigy/token.json" ] || exit 0  # not paired on this machine: nothing to listen as
 cat <<'PAIGY'
 Paigy: nothing pushes answers into a session started in a terminal \u2014 an answer waits for your
-next contact({ wait: false }). Start your own listener now, as a BACKGROUND task whose output you watch
-(your harness's monitor/background-task tool), and leave it running for this session:
+next contact({ wait: false }). Start your own listener now with your harness's MONITOR tool, the kind
+that wakes you on every line it prints (in Claude Code: Monitor, not a background Bash command, which
+only tells you when it exits). When the monitor expires, start it again:
 
-  npx -y -p @paigy/mcp@latest paigy-listen
+  npx -y -p @paigy/mcp@latest paigy-listen --brief
 
 Each line it prints is a Delivery waiting for you: read the Goal, and reply with contact when
-the answer needs a decision. Start it once; if it is already running, do nothing. Then call
-contact({ wait: false }) once: work handed to you before this session started waits there.
+the answer needs a decision.
+
+ONE LISTENER PER SESSION, AND ANOTHER SESSION'S IS NOT YOURS. Identities here are per session, so
+a paigy-listen you find in ps is almost certainly another session listening as itself, and
+starting yours takes nothing from it. Never decide this from ps: the listen tool reads the mark
+for YOUR OWN slot and answers in one call. Ask it, or just start the listener above; only a
+second one for the same slot is the mistake. Then call contact({ wait: false }) once: work handed
+to you before this session started waits there.
 PAIGY
 exit 0
 `;
@@ -2028,7 +2131,7 @@ function decideListen(f) {
   return {
     status: "start",
     command: `PAIGY_AGENT=${word(f.slot)} PAIGY_SESSION_ID=${word(f.session)} ${f.env.CODEX_THREAD_ID ? `CODEX_THREAD_ID=${word(f.env.CODEX_THREAD_ID)} ` : ""}${f.env.PAIGY_ON_WAKE ? `PAIGY_ON_WAKE=${word(f.env.PAIGY_ON_WAKE)} ` : ""}${word(f.execPath)} ${word(f.listenJs)} --brief`,
-    how: "Run this command NOW as a watched background task (your harness's background-task/monitor tool), and leave it running for this session. Each line it prints is a Delivery waiting for you: read the Goal it names with get_goals, and answer with contact. Start it once."
+    how: "Run this command NOW with your harness's MONITOR tool, the kind that wakes you on every line it prints (in Claude Code: Monitor, not a background Bash command, which only tells you when it exits); start it again when the monitor expires. Each line it prints is a Delivery waiting for you: read the Goal it names with get_goals, and answer with contact. Start it once."
   };
 }
 function listenMark(slot, home = homedir()) {
@@ -2044,6 +2147,12 @@ function writeListenMark(slot, pid, home = homedir()) {
 function removeListenMark(slot, home = homedir()) {
   rmSync(listenMark(slot, home), { force: true });
 }
+function clear(path) {
+  try {
+    rmSync(path, { force: true });
+  } catch {
+  }
+}
 function listenerAlive(slot, home = homedir()) {
   const path = listenMark(slot, home);
   let pid;
@@ -2053,7 +2162,7 @@ function listenerAlive(slot, home = homedir()) {
     return null;
   }
   if (!Number.isInteger(pid) || pid <= 0) {
-    rmSync(path, { force: true });
+    clear(path);
     return null;
   }
   try {
@@ -2061,7 +2170,7 @@ function listenerAlive(slot, home = homedir()) {
     return pid;
   } catch (e) {
     if (e.code === "EPERM") return pid;
-    rmSync(path, { force: true });
+    clear(path);
     return null;
   }
 }
@@ -2074,6 +2183,100 @@ function wakeStatusPath(slot, home = homedir()) {
 function existingListener(slot, env, home = homedir()) {
   return listenerAlive(listenerKey(slot, env), home) ?? (env.CODEX_THREAD_ID ? listenerAlive(slot, home) : null);
 }
+var UNLISTENED_EVERY_MS = 10 * 6e4;
+var WATCHING_CLIENTS = /* @__PURE__ */ new Set(["claude-code"]);
+var NON_WATCHING_CLIENTS = /* @__PURE__ */ new Set(["claude-ai", "cursor", "cursor-vscode", "windsurf", "cline", "roo-cline", "continue", "vscode", "visual studio code", "zed", "antigravity"]);
+function canWatch(f) {
+  if (harnessDriven(f.env) || f.env.PAIGY_ON_WAKE || f.env.CODEX_THREAD_ID) return "yes";
+  const c = f.client?.toLowerCase();
+  if (c && WATCHING_CLIENTS.has(c)) return "yes";
+  if (c && NON_WATCHING_CLIENTS.has(c)) return "no";
+  return "unknown";
+}
+function unlistenedNote(f, _now) {
+  if (harnessDriven(f.env) || f.pidAlive) return null;
+  const decision = decideListen(f);
+  if (decision.status !== "start") return null;
+  const head = `NOTHING CAN REACH THIS SESSION WHILE IT RESTS. No listener runs for your slot (${f.slot}) and no harness pump delivers to it`;
+  switch (canWatch(f)) {
+    case "no":
+      return { unlistened: `${head}, and this host cannot run a listener. Work reaches you only as you act \u2014 it rides your tool calls, as it did this one \u2014 so call contact({ wait: false }) before you stop.` };
+    case "yes":
+      return { unlistened: `${head}. Start the listener below as a watched background task; a listener you see in ps belongs to another session's slot, never to yours.`, listen_command: decision.command };
+    default:
+      return { unlistened: `${head}. If this host can run a watched background task, start the listener below; if it cannot, work reaches you only as you act, so call contact({ wait: false }) before you stop.`, listen_command: decision.command };
+  }
+}
+var ReachTeller = class {
+  constructor(every = UNLISTENED_EVERY_MS) {
+    this.every = every;
+  }
+  every;
+  checked = /* @__PURE__ */ new Map();
+  async note(slot, tool, d) {
+    const now = d.now();
+    const last = this.checked.get(slot);
+    if (last !== void 0 && now - last < this.every) return null;
+    this.checked.set(slot, now);
+    let note;
+    try {
+      note = unlistenedNote(d.facts(), now);
+    } catch {
+      return null;
+    }
+    if (!note) return null;
+    let waiting = null;
+    if (tool !== "contact") {
+      try {
+        waiting = waitingSummary(await d.poll());
+      } catch {
+      }
+    }
+    return { paigy_reach: { ...note, ...waiting ?? {} } };
+  }
+};
+function withReach(shaped, reach) {
+  if (!reach || !shaped || typeof shaped !== "object" || Array.isArray(shaped)) return shaped;
+  return { ...reach, ...shaped };
+}
+var HOOKED_HARNESSES = "Claude Code and Codex";
+function listenBlock(decision, f, stale) {
+  const block = {
+    listen: decision,
+    listen_permanent: `\`${ENABLE_LISTEN_COMMAND}\` installs the SessionStart hook for ${HOOKED_HARNESSES}, so every future session there is told this at its start. Other hosts are not hooked; their sessions learn it as they act.`
+  };
+  if (decision.status === "start") {
+    block.listen_prompt = canWatch(f) === "no" ? "This host cannot run a listener, so nothing reaches this session while it rests. Work arrives with your tool calls; call contact({ wait: false }) before you stop." : "Start your own listener NOW, as described in `listen` \u2014 a watched background task, left running for this session. Without it, every answer waits until you call contact({ wait: false }).";
+  }
+  if (stale) {
+    block.hook_refresh = `The SessionStart hook on this machine is an older text. Ask the user to re-run \`${ENABLE_LISTEN_COMMAND}\` to refresh it \u2014 the old one tells a session to skip its listener when it sees another session's.`;
+  }
+  return block;
+}
+var ENABLE_LISTEN_COMMAND = "npx -y -p @paigy/mcp@latest paigy-enable-tools";
+function hookStale(home = homedir()) {
+  try {
+    return readFileSync(join(home, ".paigy", "hooks", "session-start.sh"), "utf8") !== sessionStartHook();
+  } catch {
+    return false;
+  }
+}
+function waitingSummary(received) {
+  const r = received ?? {};
+  const events = Array.isArray(r.events) ? r.events : [];
+  const ids = events.map((e) => String(e?.eventId ?? "")).filter(Boolean);
+  const claimable = r.claimable && typeof r.claimable === "object" ? String(r.claimable.title ?? "") : "";
+  if (!ids.length && !claimable) return null;
+  const kinds = events.map((e) => String(e?.kind ?? "event")).join(", ");
+  const parts = [
+    ids.length ? `${ids.length} event${ids.length === 1 ? "" : "s"} addressed to you (${kinds})` : "",
+    claimable ? `work waiting: ${claimable}` : ""
+  ].filter(Boolean);
+  return {
+    waiting: `${parts.join("; ")}. Nothing acknowledged them \u2014 handle them with contact, and acknowledge with contact({ ackEventIds }) so they stop repeating. Read a Goal with get_goals before acting on a summary of it.`,
+    ...ids.length ? { waiting_events: ids } : {}
+  };
+}
 
 export {
   mcpInputSchema,
@@ -2089,5 +2292,10 @@ export {
   removeListenMark,
   listenerKey,
   wakeStatusPath,
-  existingListener
+  existingListener,
+  ReachTeller,
+  withReach,
+  listenBlock,
+  ENABLE_LISTEN_COMMAND,
+  hookStale
 };