@paigy/mcp 0.40.24 → 0.40.25

package/README.md

@@ -117,7 +117,7 @@ Then pair: `PAIGY_AGENT=gemini npx -p @paigy/mcp@latest paigy-mcp-onboard`.
 ## Tools
 
 One catalog, on every transport (2026-09-11): the agent tools are `AGENT_TOOLS` in
-`packages/schema/src/tools.ts` — contact, check_replies, create_goal, claim_goal,
+`packages/schema/src/tools.ts` — who_is_working, contact, manage_goals, claim_goal,
 get_goal, update_goal — and both this server and the hosted MCP
 (`apps/api/src/mcp`) publish that list and dispatch it through the SDK's one `runTool`.
 This server adds only onboard, pair and unpair, the tools that mint and delete the token
@@ -125,10 +125,12 @@ file this machine holds. See the [SDK contract](../../packages/sdk/README.md) fo
 single-Goal start shape. Notification returns immediately. Call holds one cancellable
 ~45-second window here (the hosted transport returns after one read); continue with
 contact({deliveryId}) without sending another ask. Durable Entries and accepted answers can
-repeat on reads; check_replies lists every open Delivery addressed to you (a request the
-user started toward you, an answer relayed to something you asked, a handoff) without
-consuming any of it, and claim_goal is the catch-up for your own Goals. Bookkeeping ids
-(`operationId`, `idempotencyKey`) are minted here, never asked of the model. Retired
+repeat on reads; contact with nothing to send receives what is addressed to you (a request the
+user started toward you, an answer relayed to something you asked, a handoff, a question you owe) without
+consuming any of it until you acknowledge it (`ackEventIds`), and claim_goal is the catch-up for
+your own Goals. manage_goals creates, edits, assigns, organizes and closes work, a change at a
+time. Bookkeeping (`operationId`, the manage request id, the revision an edit was read at) is
+minted here, never asked of the model. Retired
 reply-lease/ACK/work/callback tools and hidden notification aliases are rejected.
 
 The standalone listener below is still a **legacy host and target-release blocker**.
@@ -154,7 +156,7 @@ wake channel and reads what is waiting on every nudge. Keep it alive past the te
 with `paigy-listen --install` (launchd on macOS, systemd user unit on Linux;
 `--uninstall` removes it).
 
-The read is `check_replies` — the open Deliveries addressed to this agent — and it
+The read is `receive` (behind `contact({})`) — the open Deliveries addressed to this agent — and it
 **consumes nothing**: no lease, no acknowledgement, and the same read twice returns the
 same list. So the daemon hands the launcher what it found and stops there; claiming is
 the agent's own first act (`claim_goal`), because the daemon shares this machine's
@@ -231,7 +233,7 @@ codex exec "Paigy goal $PAIGY_GOAL_ID. claim_goal it first. The user said: $PAIG
 ## Stalled work (turn-end hook — Claude Code, Codex, Gemini CLI, Antigravity)
 
 An agent that goes quiet leaves its Goals behind. Three things hand it that work back, all
-reading one rule (no progress for 3 days, `COLD_AFTER_MS`): `check_replies` lists it under
+reading one rule (no progress for 3 days, `COLD_AFTER_MS`): `contact({})` lists it under
 `stalled`, `paigy-listen` carries it in `PAIGY_WORK` (and launches for it on boot), and this
 hook holds a session's turn end once a day to list it. One program, four tools:
 

package/dist/{chunk-TP7DM2MP.js → chunk-2ROD77AW.js}

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

package/dist/{chunk-WR2M3RME.js → chunk-EJYXBEWN.js}

@@ -1424,7 +1424,7 @@ var SPOKEN_HOUR = {
   eleven: 11,
   twelve: 12
 };
-function parseWhen(said2, tz, nowMs, read = "earliest") {
+function parseWhen(said2, tz, nowMs, read22 = "earliest") {
   const text = said2.trim();
   if (!text) return null;
   const rel = RELATIVE.exec(text);
@@ -1463,13 +1463,13 @@ function parseWhen(said2, tz, nowMs, read = "earliest") {
       if (hour === 12) hour = 0;
     } else if (hour < 12 && dayShift === 0 && hour <= today.h) hour += 12;
   } else {
-    const parts = PARTS[read];
+    const parts = PARTS[read22];
     const part = Object.keys(parts).find((k) => new RegExp(`\\b${k}\\b`, "i").test(text));
     if (/\btonight\b/i.test(text)) hour = parts["night"];
     else if (part) hour = parts[part];
     else if (dayShift > 0) hour = 9;
     else if (/\bend of (the )?day\b|\beod\b/i.test(text)) hour = END_OF_DAY;
-    else if (read === "ring" && VAGUE.test(text)) return new Date(nowMs + 30 * 6e4).toISOString();
+    else if (read22 === "ring" && VAGUE.test(text)) return new Date(nowMs + 30 * 6e4).toISOString();
     else return null;
   }
   const at2 = instantAt(tz, {
@@ -1492,8 +1492,8 @@ function parseWhen(said2, tz, nowMs, read = "earliest") {
   }) : at2;
   return new Date(rolled ?? at2).toISOString();
 }
-function parseDelay(said2, tz, nowMs, read = "earliest") {
-  const at2 = parseWhen(said2, tz, nowMs, read);
+function parseDelay(said2, tz, nowMs, read22 = "earliest") {
+  const at2 = parseWhen(said2, tz, nowMs, read22);
   if (!at2) return null;
   return Math.max(0, Math.round((Date.parse(at2) - nowMs) / 1e3));
 }
@@ -1551,9 +1551,17 @@ var StartContactSchema = z2.object({
   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 ReceiveContactSchema = z2.object({
+  wait: z2.boolean().optional().describe(
+    "Only controls when this returns. true (the default when you send and acknowledge nothing): wait up to about 45 seconds for incoming communication addressed to you, and return as soon as some is available. false: return what is waiting now. It does not mean work is blocked, set urgency, or ask for a call. `waitOutcome` says which happened: `available`, `expired` (nothing arrived in the window; wait again without sending again), or `not_waited` (a hosted connection never holds a wait)."
+  ),
+  ackEventIds: z2.array(z2.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 (an ask with `answers`), never acknowledged away: that id is refused until it is answered."
+  )
+}).strict();
+var ContactSchema = z2.union([StartContactSchema, z2.object({ deliveryId: z2.string().uuid() }).strict(), ReceiveContactSchema]);
 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', 'select', '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 starts a new Goal of yours. 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'. Each ask is sent exactly as written, with no reading in between: a bundled ask arrives as one card, so separate questions 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; Where your work stands while under way is progress: report it with update_goal, not contact. Send options (or waiting:'hard') when you actually need an answer. Each option's label must stand on its own \u2014 the person may see only the labels \u2014 so never a label that points into your text ('All three', 'Option 2', '1 and 3 only'). select:'many' makes the card a checklist, for independent options they may want several of; select:'one' (the default) a pick, for alternatives. The person can always answer in their own words, so never add an 'Other' option. 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 CONTACT_DESCRIPTION = "Contact the user with one or more asks/questions. Pass an array of asks (each with 'ask', optional 'options', 'select', '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 starts a new Goal of yours. Notification returns immediately; collect answers by receiving (below). On stdio, a Call holds one cancellable ~45s window; continue with ONLY {deliveryId}. One question per 'ask'; several questions are several objects in 'asks'. Each ask is sent exactly as written, with no reading in between: a bundled ask arrives as one card, so separate questions are separate asks. An ask with no options that is not blocking is a report, never a claim on them, so no answer is owed and none should be awaited. A report reaches the person only when it answers something they asked you, or once the Goal is done; any other report is recorded as the Goal's progress and nobody is notified. So when the work is finished, mark the Goal done first, then send one message saying what is done and anything they need to do or check. On a Goal whose report card is still open, a report that does reach them is added to that card, with no new push. Send options (or waiting:'hard') when you actually need an answer. Each option's label must stand on its own \u2014 the person may see only the labels \u2014 so never a label that points into your text ('All three', 'Option 2', '1 and 3 only'). select:'many' makes the card a checklist, for independent options they may want several of; select:'one' (the default) a pick, for alternatives. The person can always answer in their own words, so never add an 'Other' option. If the person is already on a call, a contact that reaches them 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.\n\nRECEIVING: contact with no asks sends nothing and returns `events`, a limited batch of what is addressed to you (not a history page): `question`, a Question you owe (answer it with an ask whose `answers` is its questionId); `update`, something new on one of your Goals (a reply, an answer: read it with get_goal); `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`; claim_goal starts it) and your work gone quiet (`stalled`).";
 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
@@ -1573,10 +1581,6 @@ var CreateGoalSchema = z3.object({
    *  repo name. Delegated work inherits this from its parent Goal when omitted. */
   repo: z3.string().trim().min(1).max(200).optional()
 });
-var CreateGoalToolSchema = CreateGoalSchema.extend({
-  idempotencyKey: CreateGoalSchema.shape.idempotencyKey.optional().describe("Optional. One is minted per call; pass your own only so a retry lands on the same Goal.")
-}).strict();
-var CREATE_GOAL_DESCRIPTION = 'Create a durable Goal for an outcome. Without parentGoalId it is placed against your open Goals: if one already IS this work, that Goal comes back (existing: true) and nothing new is created \u2014 continue it; if the work belongs under one, it is created there (parentGoalId in the receipt); otherwise it is a root. Pass parentGoalId yourself to put it under a specific Goal. Pass repo to anchor the work to a specific repository ("owner/repo" or repo name); delegated children inherit it. Pass title to name it in one to five words, as a person would refer to it out loud ("the night rings") \u2014 it heads every list and is spoken on a call; without one the brain writes it. Admission only: claim it before doing work, then update it as it advances. Returns an admission receipt with goalId, current state, revision, ownerParticipant, and the next step; no Goal content or execution lease.';
 var UpdateGoalSchema = z3.object({
   revision: z3.number().int().positive(),
   changes: z3.object({
@@ -1600,7 +1604,65 @@ var UpdateGoalSchema = z3.object({
   reason: z3.string().trim().min(1).max(2e3),
   operationId: z3.string().uuid().optional()
 }).strict();
-var UpdateGoalToolSchema = UpdateGoalSchema.omit({ operationId: true }).extend({ goalId: z3.string().uuid() }).strict();
+var UpdateGoalToolSchema = z3.object({
+  goalId: z3.string().uuid(),
+  revision: UpdateGoalSchema.shape.revision,
+  changes: UpdateGoalSchema.shape.changes.innerType().pick({ progress: true, reviewed: true, dueAt: true, withdraw: true }).strict().refine((v) => Object.keys(v).length > 0),
+  reason: UpdateGoalSchema.shape.reason
+}).strict();
+var changedGoal = z3.string().uuid().describe("The Goal to change, as a read shows it.");
+var goalTitle = z3.string().trim().min(1).max(80).describe("The Goal's short display name: one to five words, how a person refers to it out loud.");
+var goalOutcome = z3.string().trim().min(1).max(1e4).describe("The full desired result. There is no third description field.");
+var CreateChange = z3.object({
+  kind: z3.literal("create"),
+  title: goalTitle,
+  outcome: goalOutcome,
+  ownerId: z3.string().trim().min(1).optional().describe("Who owns the work: an agent's participant (as who_is_working shows it) or the person's. Omitted: you."),
+  parentGoalId: z3.string().uuid().optional().describe("The Goal it belongs under. Omitted: a root."),
+  sourceEntryIds: z3.array(z3.string().uuid()).max(20).optional().describe("The whole Entries the work came from, ones you can read.")
+}).strict();
+var EditChange = z3.object({ kind: z3.literal("edit"), goalId: changedGoal, title: goalTitle.optional(), outcome: goalOutcome.optional() }).strict();
+var StateChange = z3.object({ kind: z3.literal("state"), goalId: changedGoal, state: z3.enum(["open", "completed", "canceled"]).describe(
+  "completed: the Goal's own work is done now (refused while required children are open); open: reopen it; canceled: it will not be done."
+) }).strict();
+var AssignChange = z3.object({ kind: z3.literal("assign"), goalId: changedGoal, ownerId: z3.string().trim().min(1).describe("The new owner's participant.") }).strict();
+var DeferChange = z3.object({ kind: z3.literal("defer"), goalId: changedGoal, until: z3.string().datetime({ offset: true }).nullable().describe(
+  "Postpone it until this instant (its owner is woken then), or null to take the postponement back."
+) }).strict();
+var MoveChange = z3.object({ kind: z3.literal("move"), goalId: changedGoal, parentGoalId: z3.string().uuid().nullable().describe(
+  "Its new parent, or null for a root. Only this Goal moves; its new parent's other children stay."
+) }).strict();
+var DependencyChange = z3.object({
+  kind: z3.literal("dependency"),
+  change: z3.enum(["add", "remove"]),
+  goalId: changedGoal,
+  dependsOnGoalId: z3.string().uuid().describe("The Goal it waits on."),
+  action: z3.enum(["start", "complete"]).describe("What waits: starting goalId, or completing it."),
+  reason: z3.string().trim().min(1).max(2e3).optional().describe("Why, as an explanation, never as policy.")
+}).strict();
+var read = { revision: z3.number().int().positive().optional() };
+var GoalChangeSchema = z3.discriminatedUnion("kind", [
+  CreateChange,
+  EditChange.extend(read),
+  StateChange.extend(read),
+  AssignChange.extend(read),
+  DeferChange.extend(read),
+  MoveChange.extend(read),
+  DependencyChange
+]);
+var editNames = (changes, ctx) => changes.forEach((c, i) => {
+  if (c.kind === "edit" && c.title === void 0 && c.outcome === void 0) {
+    ctx.addIssue({ code: z3.ZodIssueCode.custom, path: ["changes", i], message: "an edit supplies title, outcome, or both" });
+  }
+});
+var ManageGoalsSchema = z3.object({
+  requestId: z3.string().uuid().optional(),
+  changes: z3.array(GoalChangeSchema).min(1).max(50)
+}).strict().superRefine((v, ctx) => editNames(v.changes, ctx));
+var ManageGoalsToolSchema = z3.object({
+  changes: z3.array(z3.discriminatedUnion("kind", [CreateChange, EditChange, StateChange, AssignChange, DeferChange, MoveChange, DependencyChange])).min(1).max(50).describe("The changes, applied in order, each on its own.")
+}).strict().superRefine((v, ctx) => editNames(v.changes, ctx));
+var MANAGE_GOALS_DESCRIPTION = "Create, edit, assign, organize or close work. Every change here changes Goals; answering, withdrawing or asking Questions stays in contact. Each change applies independently: a refused one names why (`results[i].error`, e.g. goal_revision_conflict, goal_children_open, goal_not_joined, goal_not_found) and the rest still apply, so read every result: a partial result is never a complete success. Kinds: create (title, outcome, ownerId, parentGoalId, sourceEntryIds) returns the new Goal's id in `results[i].goalId`, in the order requested, to use in later calls; edit (title and/or outcome); state (open, completed, canceled); assign (ownerId); defer (until, or null); move (parentGoalId, or null for a root: only this Goal moves); dependency (add or remove: goalId waits on dependsOnGoalId to start or to complete). A Goal cannot be completed while its required children or dependencies remain open: finish or move them first. Finishing the children does not prove the parent's own work is done. An edit applies at the version you last read: if someone changed the Goal since, it is refused as goal_revision_conflict, so read it again (get_goal) and reconsider. You may change a Goal you own or have written on. Returns `ok` (every change applied), `results` per change (applied or failed), and `goals`, each changed Goal's id, state, title, outcome and revision.";
 var ClaimGoalSchema = z3.object({ goalId: z3.string().uuid().optional() }).strict();
 var GetGoalSchema = z3.object({
   goalId: z3.string().uuid(),
@@ -1613,18 +1675,24 @@ var GetGoalSchema = z3.object({
   diagnose: z3.boolean().optional()
 }).strict();
 var GET_GOAL_DESCRIPTION = "Read one Goal without claiming it, including others (the ten most recent other contributors, with names, latest entry headlines and times): 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. A question in that conversation reads `open` (nothing yet), `answered` (a choice was made, and `answer` carries it), `replied` (they said something and the read settled the question on their words \u2014 NO option of yours was chosen, and the words are the reply line beside it, so read that before you act), or `closed`. 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. Every Goal of your person is readable, whichever of their agents owns it; another account's Goals 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 a Goal you are on at an exact revision. You are on a Goal you own, or one you have written on (an update with progress, or a contact on it); any of your person's agents may write on any of their Goals, and one that never touched a Goal is refused (409 goal_not_joined). State, ownership, dependencies, children, progress, title, and review acknowledgement are explicit; stale revisions are rejected. A CONTACT ON THIS GOAL MOVES ITS REVISION: a question filed on a Goal is a change to it, so an update prepared before a contact and sent after it is refused as stale (409 goal_revision_conflict) \u2014 re-read the Goal, then write. 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 a pending answer to your question or the oldest runnable or review-pending Goal you own. Pass goalId to join any Goal of your person; its assignment stays unchanged. Read others before overlapping another agent\u2019s work. Joining lets you contribute and change its state; use update_goal with ownerParticipant when the assignment itself should change. Returns the Goal as get_goal reads it, and marks you as on it, which never shuts another agent out: other agents of your person may write on it and change it too, and two changes at once are told apart by revision (409 goal_revision_conflict).";
-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();
+var UPDATE_GOAL_DESCRIPTION = "Report work on a Goal you are on, at an exact revision: progress, review acknowledgement, when to wake for it, and withdrawing a question of yours. What the Goal is (its title, outcome, state, owner, parent, dependencies) changes with manage_goals. You are on a Goal you own, or one you have written on (an update with progress, or a contact on it); any of your person's agents may write on any of their Goals, and one that never touched a Goal is refused (409 goal_not_joined). Stale revisions are rejected. A CONTACT ON THIS GOAL MOVES ITS REVISION: a question filed on a Goal is a change to it, so an update prepared before a contact and sent after it is refused as stale (409 goal_revision_conflict) \u2014 re-read the Goal, then write. progress says where the work stands. reviewed: true acknowledges new evidence and closes the Deliveries addressed to you on that Goal, never over an open decision (contact({ackEventIds}) does the same for an `update` event). 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. Returns the Goal as get_goal reads it, at its new revision.";
+var CLAIM_GOAL_DESCRIPTION = "Claim a pending answer to your question or the oldest runnable or review-pending Goal you own. Pass goalId to join any Goal of your person; its assignment stays unchanged. Read others before overlapping another agent\u2019s work. Joining lets you contribute and change it; use manage_goals (assign) when the assignment itself should change. Returns the Goal as get_goal reads it, and marks you as on it, which never shuts another agent out: other agents of your person may write on it and change it too, and two changes at once are told apart by revision (409 goal_revision_conflict).";
+var SearchToolSchema = z3.object({
+  query: z3.string().trim().min(1).max(500),
+  types: z3.array(z3.enum(["entry", "goal", "answer"])).min(1).optional(),
+  goalId: z3.string().uuid().optional(),
+  limit: z3.number().int().min(1).max(20).optional()
+}).strict();
+var SEARCH_DESCRIPTION = "Search your person's history across all of their agents: Entries (what anyone said or wrote, typed or spoken on a call), Goals (by title and outcome) and Answers (found by their Question or by the words that gave them). query is words to look for; records sharing more of its words rank first, and exact names work. types narrows it to entry, goal and/or answer (default: all three). goalId searches under one Goal: its Entries, its Questions' Answers, and it and its immediate children. limit is matches per type, 1 to 20 (default 8). Read-only. Each match carries its whole saved words, its ID and its links (an Answer carries its Question, the choice made and the Entries that support it); `omitted` counts what matched but was left out, so narrow the words or add a goalId to see it. Nothing found is not proof that nothing exists; a refused search says why. Sealed (encrypted) content is never searched or returned.";
+var WhoIsWorkingSchema = z3.object({}).strict();
 var AGENT_TOOLS = [
-  { name: "who_is_working", description: "Read your person's agents that contributed in the last 24 hours, newest first: at most 30 agents and their five most recently touched Goals, with their latest entry headline and time. Use get_goal to read a Goal and its other contributors before starting overlapping work. Read-only; no arguments.", inputSchema: mcpInputSchema(CheckRepliesSchema) },
+  { name: "who_is_working", description: "Read your person's agents that contributed in the last 24 hours, newest first: at most 30 agents and their five most recently touched Goals, with their latest entry headline and time. Use get_goal to read a Goal and its other contributors before starting overlapping work. Read-only; no arguments.", inputSchema: mcpInputSchema(WhoIsWorkingSchema) },
   { name: "contact", description: CONTACT_DESCRIPTION, inputSchema: CONTACT_SCHEMA },
-  { name: "check_replies", description: CHECK_REPLIES_DESCRIPTION, inputSchema: mcpInputSchema(CheckRepliesSchema) },
-  { name: "create_goal", description: CREATE_GOAL_DESCRIPTION, inputSchema: mcpInputSchema(CreateGoalToolSchema) },
+  { name: "manage_goals", description: MANAGE_GOALS_DESCRIPTION, inputSchema: mcpInputSchema(ManageGoalsToolSchema) },
   { name: "claim_goal", description: CLAIM_GOAL_DESCRIPTION, inputSchema: mcpInputSchema(ClaimGoalSchema) },
   { name: "get_goal", description: GET_GOAL_DESCRIPTION, inputSchema: mcpInputSchema(GetGoalSchema) },
-  { name: "update_goal", description: UPDATE_GOAL_DESCRIPTION, inputSchema: mcpInputSchema(UpdateGoalToolSchema) }
+  { name: "update_goal", description: UPDATE_GOAL_DESCRIPTION, inputSchema: mcpInputSchema(UpdateGoalToolSchema) },
+  { name: "search", description: SEARCH_DESCRIPTION, inputSchema: mcpInputSchema(SearchToolSchema) }
 ];
 var AGENT_TOOL_NAMES = AGENT_TOOLS.map((t) => t.name);
 var id = z4.string().uuid();
@@ -1655,17 +1723,6 @@ var existingGoalChanges = [
     reason: z4.string().max(500).optional()
   }).strict()
 ];
-var GoalChangeSchema = z4.union([
-  z4.object({
-    kind: z4.literal("create"),
-    title: z4.string().min(1).max(120),
-    outcome: z4.string().min(1),
-    ownerId: participant,
-    parentGoalId: id.optional(),
-    sourceEntryIds: z4.array(id)
-  }).strict(),
-  ...existingGoalChanges
-]);
 var BrainGoalChangeSchema = z4.union([
   // newSession: Paigy starts a session to own it (owner, 2026-10-06); until it has, the person owns it.
   z4.object({
@@ -2073,7 +2130,7 @@ var AwaitItemSchema = z5.discriminatedUnion("type", [
   /** The awaited ask was REPLACED by a newer notification on its thread (e.g. a
    *  post-feedback revision, #633) — the user will never answer this id. Stop
    *  awaiting it; the live ask is the thread's newest turn (await that one, or
-   *  re-orient via check_replies). */
+   *  re-orient via contact({})). */
   z5.object({
     type: z5.literal("superseded"),
     parentId: z5.string(),
@@ -2803,7 +2860,7 @@ var HostDecisionSchema = z5.object({
   goalId: z5.string().uuid().nullable().optional(),
   /** When the server last heard from the agent, as the host read it: the presence it stood back for. */
   seenAt: z5.string().datetime().nullable().optional(),
-  /** When that work last moved (`claimable.since` on `check_replies`), the fact the bound is judged on. */
+  /** When that work last moved (`claimable.since` on an agent's `contact({})` read), the fact the bound is judged on. */
   since: z5.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: z5.string().max(300).optional()
@@ -3170,28 +3227,28 @@ var authToken = (explicit) => explicit ?? tokenOverride ?? readToken();
 async function fail(what, res) {
   throw new ApiError(what, res.status, await res.text());
 }
-async function createGoal(input, opts = {}) {
+async function manageGoals(input, opts = {}) {
   const token = authToken(opts.token) ?? "";
-  const res = await ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/goals`, {
+  const res = await ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/goals/manage`, {
     method: "POST",
-    headers: { "content-type": "application/json", authorization: `Bearer ${token}`, "x-paigy-model": "goal-entry-v1" },
+    headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
     body: JSON.stringify(input)
   }));
-  if (!res.ok) await fail("create_goal", res);
+  if (!res.ok) await fail("manage_goals", res);
   return await res.json();
 }
 async function claimGoal(goalId, opts = {}) {
   const token = authToken(opts.token) ?? "";
-  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 } : {}) }));
+  const res = await ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/goals/claim`, { method: "POST", headers: { "content-type": "application/json", authorization: `Bearer ${token}` }, body: JSON.stringify(goalId ? { goalId } : {}) }));
   if (!res.ok) await fail("claim_goal", res);
   return await res.json();
 }
-async function getGoal(goalId, opts = {}, read = {}) {
+async function getGoal(goalId, opts = {}, read3 = {}) {
   const token = authToken(opts.token) ?? "";
-  const query = [read.history ? "history=1" : "", read.diagnose ? "diagnose=1" : ""].filter(Boolean).join("&");
+  const query = [read3.history ? "history=1" : "", read3.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" }
+    headers: { authorization: `Bearer ${token}` }
   }));
   if (!res.ok) await fail("get_goal", res);
   return await res.json();
@@ -3199,7 +3256,7 @@ async function getGoal(goalId, opts = {}, read = {}) {
 async function updateGoal(goalId, input, opts = {}) {
   const token = authToken(opts.token) ?? "";
   const operationId = input.operationId ?? randomUUID2();
-  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 }) }));
+  const res = await ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/goals/${encodeURIComponent(goalId)}`, { method: "PATCH", headers: { "content-type": "application/json", authorization: `Bearer ${token}` }, body: JSON.stringify({ ...input, operationId }) }));
   if (!res.ok) await fail("update_goal", res);
   return await res.json();
 }
@@ -3315,7 +3372,7 @@ async function listNotes(opts = {}) {
 }
 async function listConnections(opts = {}) {
   const res = await ensureAuthed(await reach(`${BACKEND_URL}/api/tokens`, {
-    headers: { authorization: `Bearer ${authToken(opts.token)}`, "x-paigy-model": "goal-entry-v1" }
+    headers: { authorization: `Bearer ${authToken(opts.token)}` }
   }));
   if (!res.ok) throw new Error(`list_connections failed: ${res.status} ${await res.text()}`);
   return await res.json();
@@ -3353,9 +3410,18 @@ async function dismissTriage(proposalId, opts = {}) {
   if (!res.ok) throw new Error(`dismiss_triage failed: ${res.status} ${await res.text()}`);
   return await res.json();
 }
+async function searchRecords(input, opts = {}) {
+  const res = await ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/records/search`, {
+    method: "POST",
+    headers: { "content-type": "application/json", authorization: `Bearer ${authToken(opts.token) ?? ""}` },
+    body: JSON.stringify(input)
+  }));
+  if (!res.ok) await fail("search", res);
+  return await res.json();
+}
 async function whoIsWorking(opts = {}) {
   const res = await ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/agents/working`, {
-    headers: { authorization: `Bearer ${authToken(opts.token) ?? ""}`, "x-paigy-model": "goal-entry-v1" }
+    headers: { authorization: `Bearer ${authToken(opts.token) ?? ""}` }
   }));
   if (!res.ok) await fail("who_is_working", res);
   return await res.json();
@@ -3386,13 +3452,14 @@ function currentRepo(cwd = process.cwd()) {
   }
   return asked;
 }
-var NOT_SENT = "Recorded as progress, not sent: nobody was notified. If the person should see it (a result, something to try or check, a finding), contact again and say so; report progress with update_goal.";
+var NOT_SENT = "Recorded as the Goal's progress, not sent: nobody was notified. The person is told only a question, an answer to one they asked you, and what you say once the Goal is done. To close the work, mark the Goal done first, then send the one message saying what is done and anything they need to do or check.";
 var DEMOTED = "Delivered as a card, not a call: the person's settings do not allow a call right now (silent, quiet hours, or a mode). It has reached them; do not send it again, with or without a Goal.";
 async function contact(input, opts = {}) {
   const parsed = ContactSchema.parse(input);
+  if (!("asks" in parsed) && !("deliveryId" in parsed)) throw new Error("contact with nothing to send receives: call receiveContact");
   opts.signal?.throwIfAborted();
   const send2 = opts.reach ?? reach;
-  const headers = { "content-type": "application/json", authorization: `Bearer ${authToken(opts.token) ?? ""}`, "x-paigy-model": "goal-entry-v1" };
+  const headers = { "content-type": "application/json", authorization: `Bearer ${authToken(opts.token) ?? ""}` };
   let deliveryId;
   let deliveries = [];
   let recorded = [];
@@ -3437,7 +3504,7 @@ async function contact(input, opts = {}) {
   const all = deliveries.filter((d) => !!d.deliveryId && !!d.goalId).map(({ id: id2, deliveryId: deliveryId2, goalId }) => ({ ...id2 ? { id: id2 } : {}, deliveryId: deliveryId2, goalId }));
   const joinedCard = deliveries[0]?.joinedCard === true;
   const joinedCall = deliveries[0]?.joinedCall === true;
-  const read = async (signal2) => {
+  const read3 = async (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();
@@ -3451,14 +3518,14 @@ async function contact(input, opts = {}) {
     };
   };
   const settled = (d) => d.kind === "notification" || d.state === "closed" || d.answers.length > 0 || d.entries.some((e) => e.kind === "contribution");
-  if (opts.waits === false) return read(opts.signal);
+  if (opts.waits === false) return read3(opts.signal);
   const window = AbortSignal.timeout(AWAIT_WINDOW_MS);
   const signal = opts.signal ? AbortSignal.any([opts.signal, window]) : window;
   let latest;
   try {
     while (true) {
       signal.throwIfAborted();
-      latest = await read(signal);
+      latest = await read3(signal);
       if (settled(latest)) return latest;
       await sleep2(5e3, void 0, { signal });
     }
@@ -3468,13 +3535,69 @@ async function contact(input, opts = {}) {
     throw error;
   }
 }
-async function checkReplies(opts = {}) {
+async function receive(opts = {}) {
   const res = await ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/deliveries`, {
-    headers: { authorization: `Bearer ${authToken(opts.token) ?? ""}`, "x-paigy-model": "goal-entry-v1" }
+    headers: { authorization: `Bearer ${authToken(opts.token) ?? ""}` }
   }));
-  if (!res.ok) await fail("check_replies", res);
+  if (!res.ok) await fail("receive", res);
   return await res.json();
 }
+async function acknowledge(eventIds, opts = {}) {
+  const res = await ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/deliveries/ack`, {
+    method: "POST",
+    headers: { "content-type": "application/json", authorization: `Bearer ${authToken(opts.token) ?? ""}` },
+    body: JSON.stringify({ eventIds })
+  }));
+  if (!res.ok) await fail("acknowledge", res);
+  return (await res.json()).results ?? [];
+}
+var EVENT_BATCH = 20;
+function pendingEvents(w) {
+  const fromDelivery = (d) => ({
+    eventId: d.deliveryId,
+    kind: d.questions?.length ? "question" : "instruction",
+    ...d.goalIds.length ? { goalIds: d.goalIds } : {},
+    ...d.about ? { text: d.about } : {},
+    ...d.questions?.length ? { questions: d.questions } : {}
+  });
+  const deliveries = (w.deliveries ?? []).map(fromDelivery);
+  return [
+    ...deliveries.filter((e) => e.kind === "question"),
+    ...(w.review ?? []).map((r) => ({
+      eventId: r.eventId ?? r.goalId,
+      kind: "update",
+      goalIds: [r.goalId],
+      text: r.said ? `${r.title}: ${r.said}` : r.title,
+      ...r.saidAt ? { at: r.saidAt } : {}
+    })),
+    ...deliveries.filter((e) => e.kind !== "question")
+  ];
+}
+async function receiveContact(input, opts = {}) {
+  opts.signal?.throwIfAborted();
+  const acknowledged = input.ackEventIds?.length ? await acknowledge(input.ackEventIds, opts) : void 0;
+  const shaped = (waiting, waitOutcome) => {
+    const all = pendingEvents(waiting);
+    return { waiting, events: all.slice(0, EVENT_BATCH), hasMore: all.length > EVENT_BATCH, waitOutcome, ...acknowledged ? { acknowledged } : {} };
+  };
+  const wait = (input.wait ?? !input.ackEventIds?.length) && opts.waits !== false;
+  if (!wait) return shaped(await receive(opts), "not_waited");
+  const window = AbortSignal.timeout(AWAIT_WINDOW_MS);
+  const signal = opts.signal ? AbortSignal.any([opts.signal, window]) : window;
+  let latest;
+  try {
+    while (true) {
+      signal.throwIfAborted();
+      latest = await receive({ ...opts });
+      if (pendingEvents(latest).length) return shaped(latest, "available");
+      await sleep2(5e3, void 0, { signal });
+    }
+  } catch (error) {
+    opts.signal?.throwIfAborted();
+    if (window.aborted && latest) return shaped(latest, "expired");
+    throw error;
+  }
+}
 function compact(o) {
   return Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0 && v !== null && v !== "" && !(Array.isArray(v) && v.length === 0)));
 }
@@ -3531,7 +3654,7 @@ function more(g) {
     earlier,
     g.subtree?.length ? "A Goal below, in full: get_goal({ goalId }) with its goalId above." : null,
     g.parentGoalId ? `The Goal above: get_goal({ goalId: "${g.parentGoalId}" }).` : null,
-    "Anything else waiting for you (other requests, answers, reviews): check_replies()."
+    "Anything else addressed to you (requests, answers, questions you owe): contact({ wait: false })."
   ].filter((line) => !!line);
 }
 function goalView(g) {
@@ -3585,93 +3708,106 @@ function deliveryView(d) {
     notSent: d.notSent,
     joinedCard: d.joinedCard,
     joinedCall: d.joinedCall,
-    next: d.joinedCall ? `${JOINED_CALL}${d.message ? ` ${d.message}` : ""}` : d.kind === "notification" ? `${d.demoted ? `${d.demoted} ` : ""}${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 })}) to continue this same Call \u2014 each call is ONE bounded window, and never resend the ask. When a window comes back with nothing new said, they are not typing: stop rereading, leave the question open, and collect the answer with check_replies or claim_goal on your next wake. ${d.message ?? ""}`.trim() : d.message
+    next: d.joinedCall ? `${JOINED_CALL}${d.message ? ` ${d.message}` : ""}` : d.kind === "notification" ? `${d.demoted ? `${d.demoted} ` : ""}${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 })}) to continue this same Call \u2014 each call is ONE bounded window, and never resend the ask. When a window comes back with nothing new said, they are not typing: stop rereading, leave the question open, and collect the answer with contact({ wait: false }) or claim_goal on your next wake. ${d.message ?? ""}`.trim() : d.message
   });
 }
-function repliesView(r) {
-  const deliveries = r.deliveries ?? [];
-  const assigned = r.assigned ?? [];
-  const review = r.review ?? [];
-  const stalled = r.stalled ?? [];
-  const others = r.stalledOthers ?? [];
-  return {
-    deliveries: deliveries.map((d) => compact({
-      deliveryId: d.deliveryId,
-      kind: d.kind,
-      goalIds: d.goalIds,
-      openDecisions: d.decisionNeeds.filter((n) => n.state === "open").length || void 0,
-      latest: "about" in d ? d.about : void 0
-    })),
-    // WORK ASSIGNED TO YOU (owner, 2026-09-24): your Goals nobody has started, however they
-    // became yours — a Goal handed to you is not a Delivery, and must not wait for a claim to be seen.
-    ...assigned.length ? { assigned } : {},
-    // WHAT claim_goal HANDS YOU NEXT (owner, 2026-09-27: "Wake on any work"): the same predicate that
-    // starts a sleeping agent, so "nothing is waiting" is never said while a claim would hand you work
-    // — a Goal you started in a process that died is on no other list.
-    ...r.claimable ? { claimable: r.claimable } : {},
-    // NEW ON YOUR GOALS (owner, 2026-09-23): a reply is an Entry on the Goal, not a Delivery, so the
-    // Goals flagged for your review are listed here until you acknowledge them.
-    ...review.length ? { review } : {},
-    // YOUR STALLED WORK (#2257): Goals you own with no progress for three days. Named here so an
-    // agent that reads its replies also sees what it left, and says what to do about each.
-    ...stalled.length ? { stalled } : {},
-    // OTHER AGENTS' STALLED WORK (owner, 2026-09-23): any agent may take it over and close it.
-    ...others.length ? { stalledOthers: others } : {},
+function receivedView(r) {
+  const w = r.waiting;
+  const assigned = w.assigned ?? [];
+  const stalled = w.stalled ?? [];
+  const others = w.stalledOthers ?? [];
+  const owed = r.events.filter((e) => e.kind === "question");
+  const refused = (r.acknowledged ?? []).filter((a) => a.refused);
+  return compact({
+    events: r.events.map((e) => compact({ ...e })),
+    hasMore: r.hasMore || void 0,
+    waitOutcome: r.waitOutcome,
+    acknowledged: r.acknowledged?.filter((a) => a.acknowledged).map((a) => a.eventId),
+    notAcknowledged: refused.length ? refused.map((a) => ({ eventId: a.eventId, refused: a.refused })) : void 0,
+    // WORK ASSIGNED TO YOU (owner, 2026-09-24): your Goals nobody has started, however they became yours.
+    assigned,
+    // WHAT claim_goal HANDS YOU NEXT (owner, 2026-09-27: "Wake on any work"): the predicate that starts a
+    // sleeping agent, so "nothing is waiting" is never said while a claim would hand you work.
+    claimable: w.claimable,
+    // YOUR STALLED WORK (#2257), and OTHER AGENTS' (owner, 2026-09-23): any agent may take it over.
+    stalled,
+    stalledOthers: others,
     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.",
+      r.events.length ? `Handle each event, then acknowledge the ones you handled: contact({ ackEventIds: [${r.events.filter((e) => e.kind !== "question").map((e) => `"${e.eventId}"`).join(", ")}] }).` : w.claimable || assigned.length ? "No messages." : "Nothing is waiting.",
+      ...owed.length ? [`You owe ${owed.length === 1 ? "an answer" : `${owed.length} answers`}: contact({ asks: [{ ask: <your answer>, answers: "<questionId>" }] }) for each question; a question is answered, never acknowledged.`] : [],
+      ...r.hasMore ? ["More are waiting: acknowledge these, then receive again."] : [],
+      ...r.waitOutcome === "expired" ? ["Nothing arrived in the window; receive again to keep waiting, without sending again."] : [],
       ...assigned.length ? [`${assigned.length} of your Goals are assigned to you and not started (assigned): claim_goal({goalId}) to start one.`] : [],
-      // 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}) joins one without changing its owner, then finish or cancel it with update_goal.`] : [],
+      ...w.claimable && !assigned.length ? [`claim_goal() hands you ${w.claimable.title ?? w.claimable.goalId} next.`] : [],
+      ...stalled.length ? [`${stalled.length} of your Goals have had no progress for 3 days: update_goal each with progress, or finish or cancel it with manage_goals.`] : [],
+      ...others.length ? [`${others.length} of other agents' Goals have gone quiet for 3 days: claim_goal({goalId}) joins one without changing its owner.`] : [],
       // No name of its own (#2525): the API's ask, verbatim.
-      ...r.unnamed ? [r.unnamed] : []
+      ...w.unnamed ? [w.unnamed] : []
     ].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.)` : ""}`;
+function managedView(m, changes) {
+  const results = m.results ?? [];
+  const failed = results.filter((r) => r.status !== "applied");
+  return compact({
+    ok: m.ok,
+    results: results.map((r) => compact({ index: r.index, kind: changes[r.index]?.kind, status: r.status, goalId: r.goalId, error: r.error })),
+    goals: m.goals,
+    next: failed.length ? `${failed.length} of ${results.length} changes did not apply (see results[].error); the rest did. A goal_revision_conflict means the Goal changed since you read it: read it with get_goal and decide again.` : void 0
+  });
+}
+var lastRead = /* @__PURE__ */ new Map();
+var readKey = (token, goalId) => `${token ?? ""}:${goalId}`;
+function remember(token, goalId, revision) {
+  if (revision === void 0) return;
+  if (lastRead.size >= 5e3) lastRead.clear();
+  lastRead.set(readKey(token, goalId), revision);
+}
+function read2(token, goal) {
+  if (goal.goalId) remember(token, goal.goalId, goal.revision);
+  return goal;
 }
 async function runTool(name, args, opts) {
   const { waits, signal, ...client } = opts;
   const input = args ?? {};
   switch (name) {
     case "contact": {
-      const sent = await contact(input, { ...client, signal, waits });
+      const parsed = ContactSchema.parse(input);
+      if (!("asks" in parsed) && !("deliveryId" in parsed)) return receivedView(await receiveContact(parsed, { ...client, signal, waits }));
+      const sent = await contact(parsed, { ...client, signal, waits });
       return "sent" in sent ? sent : deliveryView(sent);
     }
     case "who_is_working":
-      CheckRepliesSchema.parse(input);
+      WhoIsWorkingSchema.parse(input);
       return whoIsWorking(client);
-    case "check_replies":
-      CheckRepliesSchema.parse(input);
-      return repliesView(await checkReplies(client));
-    case "create_goal": {
-      const goal = CreateGoalToolSchema.parse(input);
-      return createGoal({ ...goal, idempotencyKey: goal.idempotencyKey ?? randomUUID4() }, client);
+    case "manage_goals": {
+      const { changes } = ManageGoalsToolSchema.parse(input);
+      const versioned = changes.map((c) => {
+        if (c.kind === "create" || c.kind === "dependency") return c;
+        const revision = lastRead.get(readKey(client.token, c.goalId));
+        return revision === void 0 ? c : { ...c, revision };
+      });
+      const managed = await manageGoals({ requestId: randomUUID4(), changes: versioned }, client);
+      for (const g of managed.goals ?? []) remember(client.token, g.goalId, g.revision);
+      return managedView(managed, changes);
     }
     case "claim_goal": {
       const { goalId } = ClaimGoalSchema.parse(input);
-      return goalView(await claimGoal(goalId, client));
+      return goalView(read2(client.token, await claimGoal(goalId, client)));
     }
     case "get_goal": {
       const { goalId, history, diagnose } = GetGoalSchema.parse(input);
-      const goal = await getGoal(goalId, client, { history, diagnose });
+      const goal = read2(client.token, 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);
-      return goalView(await updateGoal(goalId, body, client));
+      return goalView(read2(client.token, await updateGoal(goalId, body, client)));
     }
+    case "search":
+      return searchRecords(SearchToolSchema.parse(input), client);
     default:
       throw new Error(`Unknown tool: ${name}`);
   }
@@ -3910,7 +4046,7 @@ export {
   ApiError,
   overrideToken,
   authToken,
-  createGoal,
+  manageGoals,
   claimGoal,
   getGoal,
   updateGoal,
@@ -3931,11 +4067,15 @@ export {
   getTriage,
   acceptTriage,
   dismissTriage,
+  searchRecords,
   whoIsWorking,
   repoFromRemote,
   currentRepo,
   contact,
-  checkReplies,
+  receive,
+  acknowledge,
+  pendingEvents,
+  receiveContact,
   runTool,
   subscribeWake,
   parseDue,

package/dist/{chunk-VUKR2E24.js → chunk-GHSB2VP6.js}

@@ -78,9 +78,17 @@ var StartContactSchema = z2.object({
   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 ReceiveContactSchema = z2.object({
+  wait: z2.boolean().optional().describe(
+    "Only controls when this returns. true (the default when you send and acknowledge nothing): wait up to about 45 seconds for incoming communication addressed to you, and return as soon as some is available. false: return what is waiting now. It does not mean work is blocked, set urgency, or ask for a call. `waitOutcome` says which happened: `available`, `expired` (nothing arrived in the window; wait again without sending again), or `not_waited` (a hosted connection never holds a wait)."
+  ),
+  ackEventIds: z2.array(z2.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 (an ask with `answers`), never acknowledged away: that id is refused until it is answered."
+  )
+}).strict();
+var ContactSchema = z2.union([StartContactSchema, z2.object({ deliveryId: z2.string().uuid() }).strict(), ReceiveContactSchema]);
 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', 'select', '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 starts a new Goal of yours. 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'. Each ask is sent exactly as written, with no reading in between: a bundled ask arrives as one card, so separate questions 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; Where your work stands while under way is progress: report it with update_goal, not contact. Send options (or waiting:'hard') when you actually need an answer. Each option's label must stand on its own \u2014 the person may see only the labels \u2014 so never a label that points into your text ('All three', 'Option 2', '1 and 3 only'). select:'many' makes the card a checklist, for independent options they may want several of; select:'one' (the default) a pick, for alternatives. The person can always answer in their own words, so never add an 'Other' option. 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 CONTACT_DESCRIPTION = "Contact the user with one or more asks/questions. Pass an array of asks (each with 'ask', optional 'options', 'select', '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 starts a new Goal of yours. Notification returns immediately; collect answers by receiving (below). On stdio, a Call holds one cancellable ~45s window; continue with ONLY {deliveryId}. One question per 'ask'; several questions are several objects in 'asks'. Each ask is sent exactly as written, with no reading in between: a bundled ask arrives as one card, so separate questions are separate asks. An ask with no options that is not blocking is a report, never a claim on them, so no answer is owed and none should be awaited. A report reaches the person only when it answers something they asked you, or once the Goal is done; any other report is recorded as the Goal's progress and nobody is notified. So when the work is finished, mark the Goal done first, then send one message saying what is done and anything they need to do or check. On a Goal whose report card is still open, a report that does reach them is added to that card, with no new push. Send options (or waiting:'hard') when you actually need an answer. Each option's label must stand on its own \u2014 the person may see only the labels \u2014 so never a label that points into your text ('All three', 'Option 2', '1 and 3 only'). select:'many' makes the card a checklist, for independent options they may want several of; select:'one' (the default) a pick, for alternatives. The person can always answer in their own words, so never add an 'Other' option. If the person is already on a call, a contact that reaches them 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.\n\nRECEIVING: contact with no asks sends nothing and returns `events`, a limited batch of what is addressed to you (not a history page): `question`, a Question you owe (answer it with an ask whose `answers` is its questionId); `update`, something new on one of your Goals (a reply, an answer: read it with get_goal); `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`; claim_goal starts it) and your work gone quiet (`stalled`).";
 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
@@ -100,10 +108,6 @@ var CreateGoalSchema = z3.object({
    *  repo name. Delegated work inherits this from its parent Goal when omitted. */
   repo: z3.string().trim().min(1).max(200).optional()
 });
-var CreateGoalToolSchema = CreateGoalSchema.extend({
-  idempotencyKey: CreateGoalSchema.shape.idempotencyKey.optional().describe("Optional. One is minted per call; pass your own only so a retry lands on the same Goal.")
-}).strict();
-var CREATE_GOAL_DESCRIPTION = 'Create a durable Goal for an outcome. Without parentGoalId it is placed against your open Goals: if one already IS this work, that Goal comes back (existing: true) and nothing new is created \u2014 continue it; if the work belongs under one, it is created there (parentGoalId in the receipt); otherwise it is a root. Pass parentGoalId yourself to put it under a specific Goal. Pass repo to anchor the work to a specific repository ("owner/repo" or repo name); delegated children inherit it. Pass title to name it in one to five words, as a person would refer to it out loud ("the night rings") \u2014 it heads every list and is spoken on a call; without one the brain writes it. Admission only: claim it before doing work, then update it as it advances. Returns an admission receipt with goalId, current state, revision, ownerParticipant, and the next step; no Goal content or execution lease.';
 var UpdateGoalSchema = z3.object({
   revision: z3.number().int().positive(),
   changes: z3.object({
@@ -127,7 +131,65 @@ var UpdateGoalSchema = z3.object({
   reason: z3.string().trim().min(1).max(2e3),
   operationId: z3.string().uuid().optional()
 }).strict();
-var UpdateGoalToolSchema = UpdateGoalSchema.omit({ operationId: true }).extend({ goalId: z3.string().uuid() }).strict();
+var UpdateGoalToolSchema = z3.object({
+  goalId: z3.string().uuid(),
+  revision: UpdateGoalSchema.shape.revision,
+  changes: UpdateGoalSchema.shape.changes.innerType().pick({ progress: true, reviewed: true, dueAt: true, withdraw: true }).strict().refine((v) => Object.keys(v).length > 0),
+  reason: UpdateGoalSchema.shape.reason
+}).strict();
+var changedGoal = z3.string().uuid().describe("The Goal to change, as a read shows it.");
+var goalTitle = z3.string().trim().min(1).max(80).describe("The Goal's short display name: one to five words, how a person refers to it out loud.");
+var goalOutcome = z3.string().trim().min(1).max(1e4).describe("The full desired result. There is no third description field.");
+var CreateChange = z3.object({
+  kind: z3.literal("create"),
+  title: goalTitle,
+  outcome: goalOutcome,
+  ownerId: z3.string().trim().min(1).optional().describe("Who owns the work: an agent's participant (as who_is_working shows it) or the person's. Omitted: you."),
+  parentGoalId: z3.string().uuid().optional().describe("The Goal it belongs under. Omitted: a root."),
+  sourceEntryIds: z3.array(z3.string().uuid()).max(20).optional().describe("The whole Entries the work came from, ones you can read.")
+}).strict();
+var EditChange = z3.object({ kind: z3.literal("edit"), goalId: changedGoal, title: goalTitle.optional(), outcome: goalOutcome.optional() }).strict();
+var StateChange = z3.object({ kind: z3.literal("state"), goalId: changedGoal, state: z3.enum(["open", "completed", "canceled"]).describe(
+  "completed: the Goal's own work is done now (refused while required children are open); open: reopen it; canceled: it will not be done."
+) }).strict();
+var AssignChange = z3.object({ kind: z3.literal("assign"), goalId: changedGoal, ownerId: z3.string().trim().min(1).describe("The new owner's participant.") }).strict();
+var DeferChange = z3.object({ kind: z3.literal("defer"), goalId: changedGoal, until: z3.string().datetime({ offset: true }).nullable().describe(
+  "Postpone it until this instant (its owner is woken then), or null to take the postponement back."
+) }).strict();
+var MoveChange = z3.object({ kind: z3.literal("move"), goalId: changedGoal, parentGoalId: z3.string().uuid().nullable().describe(
+  "Its new parent, or null for a root. Only this Goal moves; its new parent's other children stay."
+) }).strict();
+var DependencyChange = z3.object({
+  kind: z3.literal("dependency"),
+  change: z3.enum(["add", "remove"]),
+  goalId: changedGoal,
+  dependsOnGoalId: z3.string().uuid().describe("The Goal it waits on."),
+  action: z3.enum(["start", "complete"]).describe("What waits: starting goalId, or completing it."),
+  reason: z3.string().trim().min(1).max(2e3).optional().describe("Why, as an explanation, never as policy.")
+}).strict();
+var read = { revision: z3.number().int().positive().optional() };
+var GoalChangeSchema = z3.discriminatedUnion("kind", [
+  CreateChange,
+  EditChange.extend(read),
+  StateChange.extend(read),
+  AssignChange.extend(read),
+  DeferChange.extend(read),
+  MoveChange.extend(read),
+  DependencyChange
+]);
+var editNames = (changes, ctx) => changes.forEach((c, i) => {
+  if (c.kind === "edit" && c.title === void 0 && c.outcome === void 0) {
+    ctx.addIssue({ code: z3.ZodIssueCode.custom, path: ["changes", i], message: "an edit supplies title, outcome, or both" });
+  }
+});
+var ManageGoalsSchema = z3.object({
+  requestId: z3.string().uuid().optional(),
+  changes: z3.array(GoalChangeSchema).min(1).max(50)
+}).strict().superRefine((v, ctx) => editNames(v.changes, ctx));
+var ManageGoalsToolSchema = z3.object({
+  changes: z3.array(z3.discriminatedUnion("kind", [CreateChange, EditChange, StateChange, AssignChange, DeferChange, MoveChange, DependencyChange])).min(1).max(50).describe("The changes, applied in order, each on its own.")
+}).strict().superRefine((v, ctx) => editNames(v.changes, ctx));
+var MANAGE_GOALS_DESCRIPTION = "Create, edit, assign, organize or close work. Every change here changes Goals; answering, withdrawing or asking Questions stays in contact. Each change applies independently: a refused one names why (`results[i].error`, e.g. goal_revision_conflict, goal_children_open, goal_not_joined, goal_not_found) and the rest still apply, so read every result: a partial result is never a complete success. Kinds: create (title, outcome, ownerId, parentGoalId, sourceEntryIds) returns the new Goal's id in `results[i].goalId`, in the order requested, to use in later calls; edit (title and/or outcome); state (open, completed, canceled); assign (ownerId); defer (until, or null); move (parentGoalId, or null for a root: only this Goal moves); dependency (add or remove: goalId waits on dependsOnGoalId to start or to complete). A Goal cannot be completed while its required children or dependencies remain open: finish or move them first. Finishing the children does not prove the parent's own work is done. An edit applies at the version you last read: if someone changed the Goal since, it is refused as goal_revision_conflict, so read it again (get_goal) and reconsider. You may change a Goal you own or have written on. Returns `ok` (every change applied), `results` per change (applied or failed), and `goals`, each changed Goal's id, state, title, outcome and revision.";
 var ClaimGoalSchema = z3.object({ goalId: z3.string().uuid().optional() }).strict();
 var GetGoalSchema = z3.object({
   goalId: z3.string().uuid(),
@@ -140,29 +202,35 @@ var GetGoalSchema = z3.object({
   diagnose: z3.boolean().optional()
 }).strict();
 var GET_GOAL_DESCRIPTION = "Read one Goal without claiming it, including others (the ten most recent other contributors, with names, latest entry headlines and times): 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. A question in that conversation reads `open` (nothing yet), `answered` (a choice was made, and `answer` carries it), `replied` (they said something and the read settled the question on their words \u2014 NO option of yours was chosen, and the words are the reply line beside it, so read that before you act), or `closed`. 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. Every Goal of your person is readable, whichever of their agents owns it; another account's Goals 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 a Goal you are on at an exact revision. You are on a Goal you own, or one you have written on (an update with progress, or a contact on it); any of your person's agents may write on any of their Goals, and one that never touched a Goal is refused (409 goal_not_joined). State, ownership, dependencies, children, progress, title, and review acknowledgement are explicit; stale revisions are rejected. A CONTACT ON THIS GOAL MOVES ITS REVISION: a question filed on a Goal is a change to it, so an update prepared before a contact and sent after it is refused as stale (409 goal_revision_conflict) \u2014 re-read the Goal, then write. 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 a pending answer to your question or the oldest runnable or review-pending Goal you own. Pass goalId to join any Goal of your person; its assignment stays unchanged. Read others before overlapping another agent\u2019s work. Joining lets you contribute and change its state; use update_goal with ownerParticipant when the assignment itself should change. Returns the Goal as get_goal reads it, and marks you as on it, which never shuts another agent out: other agents of your person may write on it and change it too, and two changes at once are told apart by revision (409 goal_revision_conflict).";
-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();
+var UPDATE_GOAL_DESCRIPTION = "Report work on a Goal you are on, at an exact revision: progress, review acknowledgement, when to wake for it, and withdrawing a question of yours. What the Goal is (its title, outcome, state, owner, parent, dependencies) changes with manage_goals. You are on a Goal you own, or one you have written on (an update with progress, or a contact on it); any of your person's agents may write on any of their Goals, and one that never touched a Goal is refused (409 goal_not_joined). Stale revisions are rejected. A CONTACT ON THIS GOAL MOVES ITS REVISION: a question filed on a Goal is a change to it, so an update prepared before a contact and sent after it is refused as stale (409 goal_revision_conflict) \u2014 re-read the Goal, then write. progress says where the work stands. reviewed: true acknowledges new evidence and closes the Deliveries addressed to you on that Goal, never over an open decision (contact({ackEventIds}) does the same for an `update` event). 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. Returns the Goal as get_goal reads it, at its new revision.";
+var CLAIM_GOAL_DESCRIPTION = "Claim a pending answer to your question or the oldest runnable or review-pending Goal you own. Pass goalId to join any Goal of your person; its assignment stays unchanged. Read others before overlapping another agent\u2019s work. Joining lets you contribute and change it; use manage_goals (assign) when the assignment itself should change. Returns the Goal as get_goal reads it, and marks you as on it, which never shuts another agent out: other agents of your person may write on it and change it too, and two changes at once are told apart by revision (409 goal_revision_conflict).";
+var SearchToolSchema = z3.object({
+  query: z3.string().trim().min(1).max(500),
+  types: z3.array(z3.enum(["entry", "goal", "answer"])).min(1).optional(),
+  goalId: z3.string().uuid().optional(),
+  limit: z3.number().int().min(1).max(20).optional()
+}).strict();
+var SEARCH_DESCRIPTION = "Search your person's history across all of their agents: Entries (what anyone said or wrote, typed or spoken on a call), Goals (by title and outcome) and Answers (found by their Question or by the words that gave them). query is words to look for; records sharing more of its words rank first, and exact names work. types narrows it to entry, goal and/or answer (default: all three). goalId searches under one Goal: its Entries, its Questions' Answers, and it and its immediate children. limit is matches per type, 1 to 20 (default 8). Read-only. Each match carries its whole saved words, its ID and its links (an Answer carries its Question, the choice made and the Entries that support it); `omitted` counts what matched but was left out, so narrow the words or add a goalId to see it. Nothing found is not proof that nothing exists; a refused search says why. Sealed (encrypted) content is never searched or returned.";
+var WhoIsWorkingSchema = z3.object({}).strict();
 var AGENT_TOOLS = [
-  { name: "who_is_working", description: "Read your person's agents that contributed in the last 24 hours, newest first: at most 30 agents and their five most recently touched Goals, with their latest entry headline and time. Use get_goal to read a Goal and its other contributors before starting overlapping work. Read-only; no arguments.", inputSchema: mcpInputSchema(CheckRepliesSchema) },
+  { name: "who_is_working", description: "Read your person's agents that contributed in the last 24 hours, newest first: at most 30 agents and their five most recently touched Goals, with their latest entry headline and time. Use get_goal to read a Goal and its other contributors before starting overlapping work. Read-only; no arguments.", inputSchema: mcpInputSchema(WhoIsWorkingSchema) },
   { name: "contact", description: CONTACT_DESCRIPTION, inputSchema: CONTACT_SCHEMA },
-  { name: "check_replies", description: CHECK_REPLIES_DESCRIPTION, inputSchema: mcpInputSchema(CheckRepliesSchema) },
-  { name: "create_goal", description: CREATE_GOAL_DESCRIPTION, inputSchema: mcpInputSchema(CreateGoalToolSchema) },
+  { name: "manage_goals", description: MANAGE_GOALS_DESCRIPTION, inputSchema: mcpInputSchema(ManageGoalsToolSchema) },
   { name: "claim_goal", description: CLAIM_GOAL_DESCRIPTION, inputSchema: mcpInputSchema(ClaimGoalSchema) },
   { name: "get_goal", description: GET_GOAL_DESCRIPTION, inputSchema: mcpInputSchema(GetGoalSchema) },
-  { name: "update_goal", description: UPDATE_GOAL_DESCRIPTION, inputSchema: mcpInputSchema(UpdateGoalToolSchema) }
+  { name: "update_goal", description: UPDATE_GOAL_DESCRIPTION, inputSchema: mcpInputSchema(UpdateGoalToolSchema) },
+  { name: "search", description: SEARCH_DESCRIPTION, inputSchema: mcpInputSchema(SearchToolSchema) }
 ];
 var AGENT_TOOL_NAMES = AGENT_TOOLS.map((t) => t.name);
 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 Goal of your person is open to you, whichever of their agents owns it: read it with get_goal, write on it (contact with its id as parentId, or update_goal progress), and once you have written on it you may change it too. 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.
+  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})), and claim_goal for your runnable or review-pending Goal and the conversation on it. get_goal rereads it without claiming. Every Goal of your person is open to you, whichever of their agents owns it: read it with get_goal, write on it (contact with its id as parentId, or update_goal progress), and once you have written on it you may change it too (manage_goals). Create, edit, assign, organize or close work with manage_goals, never as a contact. Every read ends in \`next\`, the one step to take. Notifications return immediately: keep working and collect answers through claim_goal/get_goal. ${calls} Events repeat until you acknowledge them: reading alone acknowledges nothing. Report progress 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. 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. STOP REREADING when a window comes back with nothing new said \u2014 they are not typing, 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 \`check_replies\` or \`claim_goal\` on that 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. STOP REREADING when a window comes back with nothing new said \u2014 they are not typing, 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 \`claim_goal\` on that wake.
 5. One ask, 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.
 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. Without them it reaches the person as a bare title nobody can answer. Each option names its choice in full -- never \`All three\` or \`Option 2\`. \`select: "many"\` makes the card a checklist (options they may want several of); \`"one"\`, the default, a pick (one rules out the others). Your ask is sent exactly as you wrote it. They can always answer in their own words, so no "Other" option.
@@ -196,17 +264,6 @@ var existingGoalChanges = [
     reason: z4.string().max(500).optional()
   }).strict()
 ];
-var GoalChangeSchema = z4.union([
-  z4.object({
-    kind: z4.literal("create"),
-    title: z4.string().min(1).max(120),
-    outcome: z4.string().min(1),
-    ownerId: participant,
-    parentGoalId: id.optional(),
-    sourceEntryIds: z4.array(id)
-  }).strict(),
-  ...existingGoalChanges
-]);
 var BrainGoalChangeSchema = z4.union([
   // newSession: Paigy starts a session to own it (owner, 2026-10-06); until it has, the person owns it.
   z4.object({
@@ -607,7 +664,7 @@ var AwaitItemSchema = z5.discriminatedUnion("type", [
   /** The awaited ask was REPLACED by a newer notification on its thread (e.g. a
    *  post-feedback revision, #633) — the user will never answer this id. Stop
    *  awaiting it; the live ask is the thread's newest turn (await that one, or
-   *  re-orient via check_replies). */
+   *  re-orient via contact({})). */
   z5.object({
     type: z5.literal("superseded"),
     parentId: z5.string(),
@@ -1335,7 +1392,7 @@ var HostDecisionSchema = z5.object({
   goalId: z5.string().uuid().nullable().optional(),
   /** When the server last heard from the agent, as the host read it: the presence it stood back for. */
   seenAt: z5.string().datetime().nullable().optional(),
-  /** When that work last moved (`claimable.since` on `check_replies`), the fact the bound is judged on. */
+  /** When that work last moved (`claimable.since` on an agent's `contact({})` read), the fact the bound is judged on. */
   since: z5.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: z5.string().max(300).optional()
@@ -1555,7 +1612,7 @@ 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 check_replies. Start your own listener now, as a BACKGROUND task whose output you watch
+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:
 
   npx -y -p @paigy/mcp@latest paigy-listen

package/dist/{chunk-J7T3EB5Y.js → chunk-UAVXYNLV.js}

@@ -4,12 +4,12 @@ import {
   serverInstructions,
   sessionStartHook,
   withSessionStartHook
-} from "./chunk-VUKR2E24.js";
+} from "./chunk-GHSB2VP6.js";
 import {
   CODEX_ENV,
   agentName,
   withCodexEnv
-} from "./chunk-WR2M3RME.js";
+} from "./chunk-EJYXBEWN.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.";
@@ -51,7 +51,7 @@ var IDENTITY_TOOLS = [
   },
   {
     name: "listen",
-    description: "Am I listening for answers, and can Paigy resume this session? Takes no arguments. Returns status `listening` for harness delivery or a running listener with a ready wake adapter; `receiving` means a process is running but automatic resume is not confirmed (read its wake error or watch its output); `unpaired` means call onboard; `start` gives the exact command to run NOW as a watched background task for this session. Start it once. Codex queues into CODEX_THREAD_ID automatically when its CLI supports queue; PAIGY_ON_WAKE overrides it. A successful queue is not evidence the agent handled the answer: read check_replies and the relevant Goal, then respond with contact. This tool never subscribes or starts anything itself.",
+    description: "Am I listening for answers, and can Paigy resume this session? Takes no arguments. Returns status `listening` for harness delivery or a running listener with a ready wake adapter; `receiving` means a process is running but automatic resume is not confirmed (read its wake error or watch its output); `unpaired` means call onboard; `start` gives the exact command to run NOW as a watched background task for this session. Start it once. Codex queues into CODEX_THREAD_ID automatically when its CLI supports queue; PAIGY_ON_WAKE overrides it. A successful queue is not evidence the agent handled the answer: receive with contact({ wait: false }) and read the relevant Goal, then respond with contact. This tool never subscribes or starts anything itself.",
     inputSchema: mcpInputSchema(z.object({}))
   }
 ];

package/dist/{dist-EKLTLANV.js → dist-NMHU2UNG.js}

@@ -14,14 +14,13 @@ import {
   TOKEN_PATH,
   UnpairedError,
   acceptTriage,
+  acknowledge,
   agentName,
   authToken,
-  checkReplies,
   claimGoal,
   claimSessionEnds,
   claimSessions,
   contact,
-  createGoal,
   currentRepo,
   deleteToken,
   dismissTriage,
@@ -34,13 +33,17 @@ import {
   listConnections,
   listNotes,
   listSlots,
+  manageGoals,
   overrideToken,
   parseDue,
+  pendingEvents,
   pollToken,
   reach,
   reachAs,
   readSlot,
   readToken,
+  receive,
+  receiveContact,
   recordDecision,
   registerDelivery,
   repoFromRemote,
@@ -48,6 +51,7 @@ import {
   revokeToken,
   runTool,
   saveToken,
+  searchRecords,
   sessionId,
   sessionSlot,
   setClient,
@@ -62,7 +66,7 @@ import {
   whoAmI,
   whoIsWorking,
   withCodexEnv
-} from "./chunk-WR2M3RME.js";
+} from "./chunk-EJYXBEWN.js";
 export {
   AGENT_TOOLS,
   AGENT_TOOL_NAMES,
@@ -79,14 +83,13 @@ export {
   TOKEN_PATH,
   UnpairedError,
   acceptTriage,
+  acknowledge,
   agentName,
   authToken,
-  checkReplies,
   claimGoal,
   claimSessionEnds,
   claimSessions,
   contact,
-  createGoal,
   currentRepo,
   deleteToken,
   dismissTriage,
@@ -99,13 +102,17 @@ export {
   listConnections,
   listNotes,
   listSlots,
+  manageGoals,
   overrideToken,
   parseDue,
+  pendingEvents,
   pollToken,
   reach,
   reachAs,
   readSlot,
   readToken,
+  receive,
+  receiveContact,
   recordDecision,
   registerDelivery,
   repoFromRemote,
@@ -113,6 +120,7 @@ export {
   revokeToken,
   runTool,
   saveToken,
+  searchRecords,
   sessionId,
   sessionSlot,
   setClient,

package/dist/enable.js

@@ -3,9 +3,9 @@ import {
   PAIGY_TOOL_IDS,
   enablePaigyTools,
   installSessionListening
-} from "./chunk-J7T3EB5Y.js";
-import "./chunk-VUKR2E24.js";
-import "./chunk-WR2M3RME.js";
+} from "./chunk-UAVXYNLV.js";
+import "./chunk-GHSB2VP6.js";
+import "./chunk-EJYXBEWN.js";
 
 // src/enable.ts
 function main() {

package/dist/index.js

@@ -9,7 +9,7 @@ import {
   resolvePairing,
   startPairing,
   suggestedAgentName
-} from "./chunk-TP7DM2MP.js";
+} from "./chunk-2ROD77AW.js";
 import {
   ENABLE_COMMAND,
   OnboardSchema,
@@ -18,13 +18,13 @@ import {
   SERVER_INSTRUCTIONS,
   TOOLS,
   paigyToolsAllowlisted
-} from "./chunk-J7T3EB5Y.js";
+} from "./chunk-UAVXYNLV.js";
 import {
   decideListen,
   existingListener,
   listenerKey,
   wakeStatusPath
-} from "./chunk-VUKR2E24.js";
+} from "./chunk-GHSB2VP6.js";
 import {
   clearSurface,
   writeSurface
@@ -45,7 +45,7 @@ import {
   setClient,
   slotName,
   whoAmI
-} from "./chunk-WR2M3RME.js";
+} from "./chunk-EJYXBEWN.js";
 
 // src/index.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";

package/dist/listen.js

@@ -10,16 +10,16 @@ import {
   removeListenMark,
   wakeStatusPath,
   writeListenMark
-} from "./chunk-VUKR2E24.js";
+} from "./chunk-GHSB2VP6.js";
 import {
   agentName,
-  checkReplies,
   contact,
   getGoal,
   heartbeat,
+  receive,
   slotName,
   subscribeWake
-} from "./chunk-WR2M3RME.js";
+} from "./chunk-EJYXBEWN.js";
 
 // src/listen.ts
 import { createHash } from "crypto";
@@ -169,7 +169,7 @@ async function sweep(reason, goalId, bridge = new WakeBridge(process.env, wakeSt
   try {
     void Promise.resolve().then(() => heartbeat(void 0, { listening: true })).catch(() => {
     });
-    const { deliveries: rows, stalled, review, assigned } = await checkReplies();
+    const { deliveries: rows, stalled, review, assigned } = await receive();
     const lead = leadOf(rows, goalId);
     const full = lead ? await contact({ deliveryId: lead.deliveryId }, { waits: false }).then((d) => "sent" in d ? null : d).catch(() => null) : null;
     const deliveries = rows.map((d) => d === lead && full ? full : d);
@@ -200,7 +200,7 @@ async function sweep(reason, goalId, bridge = new WakeBridge(process.env, wakeSt
         ...(assigned ?? []).map((g) => `assigned:${g.goalId}`),
         ...!rows.length && !reviews.length && !assigned?.length ? (stalled ?? []).map((g) => `stalled:${g.goalId}:${g.since}`) : []
       ];
-      const message = `Paigy has waiting work${goalId ? ` on Goal ${goalId}` : ""}. Read check_replies and the relevant Goal conversation, handle new user input, and acknowledge only evidence actually handled. Preserve this session's current task; do not start unrelated old work. This wake is not new authorization.`;
+      const message = `Paigy has waiting work${goalId ? ` on Goal ${goalId}` : ""}. Read contact({ wait: false }) and the relevant Goal conversation, handle new user input, and acknowledge (contact({ ackEventIds })) only events actually handled. Preserve this session's current task; do not start unrelated old work. This wake is not new authorization.`;
       await bridge.deliver(fingerprints, message, launchEnv(waiting, reason, goalId));
     } else if (bridge.status().target.kind === "codex") {
       await bridge.deliver([], "", {});

package/dist/onboard.js

@@ -3,13 +3,13 @@ import {
   resolvePairing,
   startPairing,
   suggestedAgentName
-} from "./chunk-TP7DM2MP.js";
+} from "./chunk-2ROD77AW.js";
 import {
   autoConfigureClients,
   claudeInstallHint,
   openBrowser
-} from "./chunk-J7T3EB5Y.js";
-import "./chunk-VUKR2E24.js";
+} from "./chunk-UAVXYNLV.js";
+import "./chunk-GHSB2VP6.js";
 import {
   TOKEN_PATH,
   agentName,
@@ -20,7 +20,7 @@ import {
   saveToken,
   setIdentity,
   whoAmI
-} from "./chunk-WR2M3RME.js";
+} from "./chunk-EJYXBEWN.js";
 
 // src/onboard.ts
 function reportRegistered() {

package/dist/slot.js

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

package/dist/stalled.js

@@ -15,7 +15,7 @@ function stopReply(stalled, event = "Stop") {
   if (!stalled.length) return null;
   const list = stalled.slice(0, 8).map((g) => `"${g.title}" (${g.goalId})`).join(", ");
   const more = stalled.length > 8 ? ` and ${stalled.length - 8} more` : "";
-  const reason = `Before you stop: ${stalled.length} of your Paigy Goals have had no progress for 3 days: ${list}${more}. For each, update_goal with progress, finish it, or cancel it.`;
+  const reason = `Before you stop: ${stalled.length} of your Paigy Goals have had no progress for 3 days: ${list}${more}. For each, update_goal with progress, or finish or cancel it with manage_goals.`;
   return event === "AfterAgent" ? { decision: "block", reason, systemMessage: reason } : { decision: "block", reason };
 }
 async function main() {
@@ -29,8 +29,8 @@ 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-EKLTLANV.js");
-  const reply = stopReply((await checkReplies()).stalled ?? [], input.hook_event_name ?? "Stop");
+  const { receive } = await import("./dist-NMHU2UNG.js");
+  const reply = stopReply((await receive()).stalled ?? [], input.hook_event_name ?? "Stop");
   if (!reply) return;
   mkdirSync(dir, { recursive: true });
   writeFileSync(mark, "");

package/dist/statusline.js

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

package/package.json

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