@paigy/mcp 0.40.26 → 0.40.27

package/README.md

@@ -84,7 +84,7 @@ args = ["-y", "@paigy/mcp@latest"]
 env = { PAIGY_AGENT = "codex" }
 ```
 
-Then pair: `PAIGY_AGENT=codex npx -p @paigy/mcp@latest paigy-mcp-onboard` (or have the agent call the `pair` tool — it pairs under its own name automatically).
+Then pair: `PAIGY_AGENT=codex npx -p @paigy/mcp@latest paigy-mcp-onboard` (or have the agent call the `configure` tool — it pairs under its own name automatically).
 
 ### Gemini CLI
 
@@ -117,11 +117,12 @@ 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` — who_is_working, contact, manage_goals, claim_goal,
-get_goal, search, send_feedback — and both this server and the hosted MCP
+`packages/schema/src/tools.ts` — contact, manage_goals, get_goal, search, check_activity,
+send_feedback — 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
-file this machine holds, and listen. See the [SDK contract](../../packages/sdk/README.md) for the
+This server adds only `configure`, the one identity tool, which pairs, reports who you are,
+renames and logs this agent out (`logOut: true`) over the token file this machine holds, and listen.
+`onboard` is now `configure`; `pair` and `unpair` are folded into it (2026-10-07). See the [SDK contract](../../packages/sdk/README.md) for the
 contact shape. Sending returns immediately unless it asks to `wait`: `wait: true` holds one
 cancellable ~45-second window here for a response to what was sent (the hosted transport
 returns after one read), and `contact({})` holds one for anything addressed to you; after an
@@ -134,8 +135,10 @@ acknowledged with `ackEventIds`, and a Goal is postponed with manage_goals `defe
 when its time comes). Durable Entries and accepted answers can
 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
+consuming any of it until you acknowledge it (`ackEventIds`), and get_goal reads a Goal.
+`claim_goal` is gone (2026-10-07): you are on a Goal from your first write to it (a contact
+naming it, or a manage_goals change), never from a read, so there is nothing to claim or join;
+`who_is_working` is now `check_activity`. 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.
@@ -165,10 +168,10 @@ with `paigy-listen --install` (launchd on macOS, systemd user unit on Linux;
 
 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
-token with the agent it launches and a second claimer on one identity eats the first
-one's claim.
+same list. So the daemon hands the launcher what it found and stops there; it never
+writes, because an agent is on a Goal from its first write and the daemon shares this
+machine's token with the agent it launches: a write here would put that agent on work it
+never started.
 
 To launch an agent — any agent, not just Claude — when work arrives, set
 `PAIGY_ON_WAKE` to a command before `--install`:
@@ -179,7 +182,7 @@ To launch an agent — any agent, not just Claude — when work arrives, set
 | `PAIGY_EVENT` | the wake that caused this run — `boot`, `wake:reply`, `wake:request`… |
 | `PAIGY_PARENT_ID` | the thread to continue on (`PAIGY_THREAD_ID` is the same value, for existing scripts) |
 | `PAIGY_DELIVERY_ID` | the Delivery being acted on (`get_goal` on `PAIGY_GOAL_ID` reads its conversation) |
-| `PAIGY_GOAL_ID` | the Goal it belongs to — `claim_goal` it **first** |
+| `PAIGY_GOAL_ID` | the Goal it belongs to — read it with `get_goal` **first** |
 | `PAIGY_TEXT` | what the person said, in prose |
 
 Hand `$PAIGY_WORK` to a harness that can read JSON and decide for itself; use the
@@ -190,7 +193,7 @@ Goal" from "an empty id".
 
 ```sh
 # Claude Code — hand it everything and let it plan:
-PAIGY_ON_WAKE='claude -p "Handle the Paigy work in $PAIGY_WORK — claim_goal first, and read a Goal you do not recognize with get_goal."' \
+PAIGY_ON_WAKE='claude -p "Handle the Paigy work in $PAIGY_WORK — read each Goal it names with get_goal first."' \
   npx -y -p @paigy/mcp paigy-listen --install
 
 # Codex terminal session: no custom script and no new conversation.
@@ -234,7 +237,7 @@ script and branch on `$PAIGY_EVENT` there:
 ```sh
 #!/bin/sh
 # ~/.paigy/on-wake.sh — chmod +x, then PAIGY_ON_WAKE=~/.paigy/on-wake.sh
-codex exec "Paigy goal $PAIGY_GOAL_ID. claim_goal it first. The user said: $PAIGY_TEXT. Reply with contact when done."
+codex exec "Paigy goal $PAIGY_GOAL_ID. Read it with get_goal first. The user said: $PAIGY_TEXT. Reply with contact when done."
 ```
 
 ## Stalled work (turn-end hook — Claude Code, Codex, Gemini CLI, Antigravity)

package/dist/{chunk-OVSAQW3K.js → chunk-4C6SDQ7A.js}

@@ -1689,7 +1689,7 @@ CUT A LONG MESSAGE BEFORE YOU SEND IT: a question, an update's message or an ans
 
 UPDATES ask nothing, so no answer is owed and none should be awaited. An update reaches the person only when they asked you for it (userExplicitlyRequested), when it answers something they said, or once its Goal is done; any other is recorded as the Goal's progress and nobody is notified. So when the work is finished, mark the Goal done first (manage_goals), then send one update saying what is done and anything they need to do or check. On a Goal whose report card is still open, an update that reaches them is added to that card, with no new push. If the person is already on a call, anything that reaches them joins that call, with no ring.
 
-RECEIVING: a contact that sends nothing returns \`events\`, a limited batch of what is addressed to you (not a history page): \`question\`, a Question you owe (answer it in answers, with its questionId); \`update\`, something new on one of your Goals (a reply, an answer: read it with get_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\`).`;
+RECEIVING: a contact that sends nothing returns \`events\`, a limited batch of what is addressed to you (not a history page): \`question\`, a Question you owe (answer it in answers, with its questionId); \`update\`, something new on one of your Goals (a reply, an answer: read it with get_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\`; your first write to it 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
@@ -1735,7 +1735,7 @@ 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."),
+  ownerId: z3.string().trim().min(1).optional().describe("Who owns the work: an agent's participant (as check_activity 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();
@@ -1780,8 +1780,7 @@ var ManageGoalsSchema = z3.object({
 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: the Goal waits until then and its owner is woken when it passes; null takes it back); 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 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_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: the Goal waits until then and its owner is woken when it passes; null takes it back); 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 any Goal of your person; a change puts you on it. Returns `ok` (every change applied), `results` per change (applied or failed), and `goals`, each changed Goal's id, state, title, outcome and revision.";
 var GetGoalSchema = z3.object({
   goalId: z3.string().uuid(),
   /** Every entry in full. Without it the read carries the person's words, open questions and your
@@ -1792,8 +1791,7 @@ var GetGoalSchema = z3.object({
    *  between two of them named. Off by default; `docs/model/goal/diagnose-design.md`. */
   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 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 GET_GOAL_DESCRIPTION = "Read one Goal (a read never puts you on 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 SearchToolSchema = z3.object({
   query: z3.string().trim().min(1).max(500),
   types: z3.array(z3.enum(["entry", "goal", "answer"])).min(1).optional(),
@@ -1801,7 +1799,7 @@ var SearchToolSchema = z3.object({
   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 CheckActivitySchema = z3.object({}).strict();
 var FEEDBACK_TEXT_MAX = 5e4;
 var SendFeedbackSchema = z3.object({
   text: z3.string().trim().min(1).max(FEEDBACK_TEXT_MAX).describe(`The report, in markdown: what happened, what was expected, how to reproduce it, versions, evidence. At most ${FEEDBACK_TEXT_MAX} characters.`),
@@ -1810,12 +1808,11 @@ var SendFeedbackSchema = z3.object({
 }).strict();
 var SEND_FEEDBACK_DESCRIPTION = "Send feedback about Paigy itself (a bug report, an idea) straight to the Paigy team. Send it only when the person asked you to, or agreed when you offered: it goes to Paigy, never to the person, and nobody answers it here. Not for your work or a question for the person: use contact for those. Returns whether it was stored.";
 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(WhoIsWorkingSchema) },
   { name: "contact", description: CONTACT_DESCRIPTION, inputSchema: CONTACT_SCHEMA },
   { 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: "search", description: SEARCH_DESCRIPTION, inputSchema: mcpInputSchema(SearchToolSchema) },
+  { name: "check_activity", 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(CheckActivitySchema) },
   { name: "send_feedback", description: SEND_FEEDBACK_DESCRIPTION, inputSchema: mcpInputSchema(SendFeedbackSchema) }
 ];
 var AGENT_TOOL_NAMES = AGENT_TOOLS.map((t) => t.name);
@@ -3057,7 +3054,7 @@ var HostDecisionSchema = z7.object({
   /** The agent's token id: the row's `recipient`. */
   agent: z7.string().uuid(),
   decision: z7.enum(["stood_back", "took_over"]),
-  /** The work it was about: the Goal `claim_goal` would hand that agent next. */
+  /** The work it was about: the Goal waiting on that agent next (`claimable` on its `contact({})` read). */
   goalId: z7.string().uuid().nullable().optional(),
   /** When the server last heard from the agent, as the host read it: the presence it stood back for. */
   seenAt: z7.string().datetime().nullable().optional(),
@@ -3438,12 +3435,6 @@ async function manageGoals(input, opts = {}) {
   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}` }, body: JSON.stringify(goalId ? { goalId } : {}) }));
-  if (!res.ok) await fail("claim_goal", res);
-  return await res.json();
-}
 async function getGoal(goalId, opts = {}, read3 = {}) {
   const token = authToken(opts.token) ?? "";
   const query = [read3.history ? "history=1" : "", read3.diagnose ? "diagnose=1" : ""].filter(Boolean).join("&");
@@ -3622,11 +3613,11 @@ async function sendFeedback(input, opts = {}) {
   if (!res.ok) await fail("send_feedback", res);
   return await res.json();
 }
-async function whoIsWorking(opts = {}) {
+async function checkActivity(opts = {}) {
   const res = await ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/agents/working`, {
     headers: { authorization: `Bearer ${authToken(opts.token) ?? ""}` }
   }));
-  if (!res.ok) await fail("who_is_working", res);
+  if (!res.ok) await fail("check_activity", res);
   return await res.json();
 }
 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 update saying what is done and anything they need to do or check. If the person asked you, in so many words, to send them this, send it again with userExplicitlyRequested: "any" on that update.`;
@@ -3905,7 +3896,7 @@ function deliveryView(d) {
     acknowledged: d.acknowledged?.filter((a) => a.acknowledged).map((a) => a.eventId),
     next: [
       failures(d.results),
-      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}` : pending ? `${d.demoted ? `${d.demoted} ` : ""}Decision pending on this call. ${d.waitOutcome === "expired" ? "Nothing was said in the window. " : ""}Wait for the answer with contact({wait:true}) \u2014 one bounded window each time, and never resend the question. When a window comes back with nothing new, they are not typing: stop waiting, leave the question open, and collect the answer with contact({wait:false}) or claim_goal on your next wake. ${d.message ?? ""}`.trim() : d.message
+      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}` : pending ? `${d.demoted ? `${d.demoted} ` : ""}Decision pending on this call. ${d.waitOutcome === "expired" ? "Nothing was said in the window. " : ""}Wait for the answer with contact({wait:true}) \u2014 one bounded window each time, and never resend the question. When a window comes back with nothing new, they are not typing: stop waiting, leave the question open, and collect the answer with contact({wait:false}) or get_goal on your next wake. ${d.message ?? ""}`.trim() : d.message
     ].filter(Boolean).join(" ")
   });
 }
@@ -3942,8 +3933,8 @@ function receivedView(r, now = Date.now()) {
     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.
+    // THE WORK WAITING ON 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 work is.
     claimable: w.claimable,
     // YOUR STALLED WORK (#2257), and OTHER AGENTS' (owner, 2026-09-23): any agent may take it over.
     stalled,
@@ -3953,10 +3944,10 @@ function receivedView(r, now = Date.now()) {
       ...owed.length ? [`You owe ${owed.length === 1 ? "an answer" : `${owed.length} answers`}: contact({ answers: [{ questionId: "<questionId>", answer: { text: <your answer> } }] }) 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.`] : [],
-      ...w.claimable && !assigned.length ? [`claim_goal() hands you ${w.claimable.title ?? w.claimable.goalId} next.`] : [],
+      ...assigned.length ? [`${assigned.length} of your Goals are assigned to you and not started (assigned): read one with get_goal({goalId}); your first write to it starts it.`] : [],
+      ...w.claimable && !assigned.length ? [`Next waiting on you: ${w.claimable.title ?? w.claimable.goalId} (get_goal({ goalId: "${w.claimable.goalId}" })).`] : [],
       ...stalled.length ? [`${stalled.length} of your Goals have had no progress${stalled.length === 1 ? " " : ""}${quietFor(stalled, now)}: report on each with a contact update, or finish or cancel it with manage_goals.`] : [],
-      ...others.length ? [`${others.length} of other agents' Goals have gone quiet${others.length === 1 ? " " : ""}${quietFor(others, now)}: claim_goal({goalId}) joins one without changing its owner.`] : [],
+      ...others.length ? [`${others.length} of other agents' Goals have gone quiet${others.length === 1 ? " " : ""}${quietFor(others, now)}: read one with get_goal({goalId}); a write to it puts you on it without changing its owner.`] : [],
       // No name of its own (#2525): the API's ask, verbatim.
       ...w.unnamed ? [w.unnamed] : []
     ].join(" ")
@@ -3993,9 +3984,9 @@ async function runTool(name, args, opts) {
       const sent = await contact(parsed, { ...client, signal, waits });
       return "sent" in sent ? notSentView(sent) : deliveryView(sent);
     }
-    case "who_is_working":
-      WhoIsWorkingSchema.parse(input);
-      return whoIsWorking(client);
+    case "check_activity":
+      CheckActivitySchema.parse(input);
+      return checkActivity(client);
     case "send_feedback":
       return sendFeedback(SendFeedbackSchema.parse(input), client);
     case "manage_goals": {
@@ -4009,10 +4000,6 @@ async function runTool(name, args, opts) {
       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(read2(client.token, await claimGoal(goalId, client)));
-    }
     case "get_goal": {
       const { goalId, history, diagnose } = GetGoalSchema.parse(input);
       const goal = read2(client.token, await getGoal(goalId, client, { history, diagnose }));
@@ -4287,7 +4274,6 @@ export {
   overrideToken,
   authToken,
   manageGoals,
-  claimGoal,
   getGoal,
   AWAIT_WINDOW_MS,
   hatch,
@@ -4307,7 +4293,7 @@ export {
   acceptTriage,
   dismissTriage,
   searchRecords,
-  whoIsWorking,
+  checkActivity,
   readDelivery,
   contact,
   receive,

package/dist/{chunk-5MQ3J6S3.js → chunk-A5FYZK6P.js}

@@ -4,54 +4,38 @@ import {
   serverInstructions,
   sessionStartHook,
   withSessionStartHook
-} from "./chunk-7LQKX73K.js";
+} from "./chunk-X3GTDW5G.js";
 import {
   CODEX_ENV,
   agentName,
   withCodexEnv
-} from "./chunk-OVSAQW3K.js";
+} from "./chunk-4C6SDQ7A.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.";
+var CONFIGURE_DESCRIPTION = "Set this agent up with Paigy \u2014 call it FIRST, before contact, and any time you're unsure who you are. One call does whatever the situation needs: NOT SET UP \u2192 if this machine holds a device credential (the user ran the Paigy desktop app or harness) it hatches an identity INSTANTLY, no code and no approval; otherwise it starts the code ceremony. ALREADY SET UP \u2192 returns your current identity and the two things left to decide, renaming it or logging out. 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 (pick your own; 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.\n\nTHE CODE CEREMONY does not open a browser; the user enters the code in the Paigy app (or scans `qr`). A result with { user_code, device_code, qr, user_message } has already started polling for approval in the background: you MUST immediately print the `user_message` (the bare code) to the user, AND in that same turn call configure again with that `device_code` to collect the result. It returns the moment the user approves; on { status:'pending' } call again to keep waiting; on { status:'awaiting_confirmation' } (E2EE) show the bare `user_message` verify code and call again to finish. The leading text block of every result states the code plainly, so it shows even if you emit no prose.\n\nOn { status:'paired' }, or whenever it returns `enable_command`, ALWAYS follow the `enable_prompt`: PRINT that command for the user to run, so Paigy's tools stop prompting each time. 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.\n\nLOG OUT with { logOut: true }: it logs out THIS agent only \u2014 its token is revoked server-side and its local entry removed. Other agents and this device's credential are untouched, and a later configure re-hatches instantly while the device credential exists. Disconnecting the device itself is not an agent tool.";
 var SERVER_INSTRUCTIONS = serverInstructions({ waits: true });
 
 // src/tools.ts
 import { z } from "zod";
-var OnboardSchema = z.object({
-  name: z.string().max(60).optional(),
-  voice: z.string().max(40).optional(),
-  /** Continue a code ceremony already in flight — same meaning as `pair`'s. */
-  device_code: z.string().optional(),
-  /** Which allowlist to REPORT on (never written by `start`). */
-  scope: z.enum(["user", "project"]).optional()
-});
-var PairSchema = z.object({
-  device_code: z.string().optional().describe("Omit to start pairing (returns an approval link to show the user). Pass the device_code from that first call to finish, once the user has approved."),
-  name: z.string().min(1).max(60).optional().describe("Hatch path only: the name you choose for this identity. Pick your own \u2014 ONE or TWO words, the way you'd introduce yourself on a call (it is spoken aloud and shown in lists). 'Piper', 'Blue Heron' \u2014 never a sentence or a task description."),
-  voice: z.string().optional().describe("Hatch path only: your voice on calls \u2014 one of rachel, george, jessica, brian, lily.")
+var ConfigureSchema = z.object({
+  name: z.string().min(1).max(60).optional().describe("Who you are: the name you choose when hatching, or the new one to RENAME yourself to when already set up. Pick your own \u2014 ONE or TWO words, the way you'd introduce yourself on a call (it is spoken aloud and shown in lists). 'Piper', 'Blue Heron' \u2014 never a sentence or a task description."),
+  voice: z.string().max(40).optional().describe("Your voice on calls \u2014 one of rachel, george, jessica, brian, lily."),
+  device_code: z.string().optional().describe("Continue a code ceremony already in flight: the device_code a previous configure returned. Omit it otherwise."),
+  /** Which allowlist to REPORT on (never written). */
+  scope: z.enum(["user", "project"]).optional().describe("Which tool allowlist to report on (user or project settings). Read-only."),
+  logOut: z.boolean().optional().describe("true: log THIS agent out \u2014 its token is revoked and its local entry removed. Other agents and this device's credential are untouched.")
 });
 var IDENTITY_TOOLS = [
   {
-    // ONE rail for starting a session (#875). `pair`, the `paigy-mcp-onboard` CLI and
-    // `enable_tools` were three doors into one flow, and "onboard" was the word people
-    // reached for attached to the tool that did the least. It's the door now.
-    name: "onboard",
-    description: ONBOARD_DESCRIPTION,
-    inputSchema: mcpInputSchema(OnboardSchema)
-  },
-  {
-    name: "pair",
-    description: "Pair this agent with the user's Paigy account (one-time) \u2014 required before contact work. FAST PATH: if this machine already holds a device credential (the user ran the Paigy desktop harness or app), calling pair hatches a fresh identity INSTANTLY \u2014 no code, no approval. Pass { name, voice } to choose who you are (pick your own; voices: rachel, george, jessica, brian, lily). Only when no device credential exists does the code ceremony below run. It does NOT open a browser; the user enters the code in the Paigy app (or scans `qr`). Step 1: call with NO args \u2014 returns { user_code, device_code, qr, user_message } AND starts polling for approval in the background. REQUIRED: You MUST immediately print the `user_message` (the bare code) as a text message to the user, AND in that same turn call step 2 (pair with the device_code). This ensures the user sees the code in chat while the tool blocks/polls in the background for approval. Step 2: call with that device_code to collect the result. Because approval is already being polled in the background, this returns the moment the user approves; on { status:'pending' } just call again to keep waiting; on { status:'awaiting_confirmation' } (E2EE) show the bare `user_message` verify code and call again to finish. The leading text block of every result states the code plainly, so it shows even if you emit no prose. On { status:'paired' } ALWAYS follow the `enable_prompt` \u2014 PRINT the returned `enable_command` so the user can allowlist Paigy's tools and notify/await stop prompting each time. Printing is the whole job: that command writes your own permission allowlist, so you must not run it and a host will block you if you try.",
-    inputSchema: mcpInputSchema(PairSchema)
-  },
-  {
-    name: "unpair",
-    description: "Log out / unpair this agent from the user's Paigy account: revokes the token server-side (it stops working everywhere) and deletes the local ~/.paigy/token.json. Takes no arguments. After this, contact won't work until the user pairs again with the pair tool.",
-    inputSchema: mcpInputSchema(z.object({}))
+    // ONE rail for starting a session (#875), and since 2026-10-07 the only identity tool: `onboard`
+    // renamed, and `pair` (which it already did everything of) and `unpair` (`logOut`) folded in.
+    name: "configure",
+    description: CONFIGURE_DESCRIPTION,
+    inputSchema: mcpInputSchema(ConfigureSchema)
   },
   {
     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: receive with contact({ wait: false }) and read 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 configure; `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({}))
   }
 ];
@@ -218,9 +202,8 @@ function claudeInstallHint(skip = agentName()) {
   return "Claude Code detected \u2014 to add Paigy there, run /plugin marketplace add paigy-ai/mcp then /plugin install paigy (pairing carries over; no need to pair again). Note: If you run this inside a live session, type /reload-plugins afterward so the agent connects to the new tools.";
 }
 var ENABLE_COMMAND = "npx -y -p @paigy/mcp@latest paigy-enable-tools";
-var PROMPTS_ON_PURPOSE = /* @__PURE__ */ new Set(["pair", "unpair"]);
 var PAIGY_TOOL_IDS = [
-  ...TOOL_NAMES.filter((n) => !PROMPTS_ON_PURPOSE.has(n)),
+  ...TOOL_NAMES,
   ...HIDDEN_ALIASES
 ].map((n) => `mcp__paigy__${n}`);
 function withPaigyAllowlist(existing, tools) {
@@ -332,8 +315,7 @@ function installSessionListening() {
 
 export {
   SERVER_INSTRUCTIONS,
-  OnboardSchema,
-  PairSchema,
+  ConfigureSchema,
   TOOLS,
   openBrowser,
   autoConfigureClients,

package/dist/{chunk-BLWC44CQ.js → chunk-UQDA7X3W.js}

@@ -6,7 +6,7 @@ import {
   saveToken,
   setIdentity,
   sleep
-} from "./chunk-OVSAQW3K.js";
+} from "./chunk-4C6SDQ7A.js";
 
 // src/identity.ts
 var CLIENT_LABELS = {
@@ -34,12 +34,12 @@ async function identify(who, ask) {
       who = await setIdentity({ ...ask.name ? { name: ask.name } : {}, ...ask.voice ? { voice: ask.voice } : {} });
       renamed = true;
     } catch (e) {
-      const message2 = e instanceof NameTakenError ? e.message : `The rename did not go through (${e.message}); nothing changed. Call onboard again to retry, or carry on.`;
+      const message2 = e instanceof NameTakenError ? e.message : `The rename did not go through (${e.message}); nothing changed. Call configure again to retry, or carry on.`;
       return { name: who.name, voice: who.voice, message: message2 };
     }
   }
   const voice = who.voice ? ` (voice: ${who.voice})` : "";
-  const message = !who.name ? [renamed && who.voice ? `Your voice is ${who.voice} now.` : "", who.unnamed ?? "Set up, with no name yet."].filter(Boolean).join(" ") : renamed ? `Renamed \u2014 this agent is "${who.name}"${voice} now.` : `Already set up as "${who.name}"${voice}. Ask the user if they want to rename it or unpair; otherwise carry on.`;
+  const message = !who.name ? [renamed && who.voice ? `Your voice is ${who.voice} now.` : "", who.unnamed ?? "Set up, with no name yet."].filter(Boolean).join(" ") : renamed ? `Renamed \u2014 this agent is "${who.name}"${voice} now.` : `Already set up as "${who.name}"${voice}. Ask the user if they want to rename it or log it out; otherwise carry on.`;
   return { name: who.name, voice: who.voice, message };
 }
 

package/dist/{chunk-7LQKX73K.js → chunk-X3GTDW5G.js}

@@ -219,7 +219,7 @@ CUT A LONG MESSAGE BEFORE YOU SEND IT: a question, an update's message or an ans
 
 UPDATES ask nothing, so no answer is owed and none should be awaited. An update reaches the person only when they asked you for it (userExplicitlyRequested), when it answers something they said, or once its Goal is done; any other is recorded as the Goal's progress and nobody is notified. So when the work is finished, mark the Goal done first (manage_goals), then send one update saying what is done and anything they need to do or check. On a Goal whose report card is still open, an update that reaches them is added to that card, with no new push. If the person is already on a call, anything that reaches them joins that call, with no ring.
 
-RECEIVING: a contact that sends nothing returns \`events\`, a limited batch of what is addressed to you (not a history page): \`question\`, a Question you owe (answer it in answers, with its questionId); \`update\`, something new on one of your Goals (a reply, an answer: read it with get_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\`).`;
+RECEIVING: a contact that sends nothing returns \`events\`, a limited batch of what is addressed to you (not a history page): \`question\`, a Question you owe (answer it in answers, with its questionId); \`update\`, something new on one of your Goals (a reply, an answer: read it with get_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\`; your first write to it 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
@@ -265,7 +265,7 @@ 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."),
+  ownerId: z3.string().trim().min(1).optional().describe("Who owns the work: an agent's participant (as check_activity 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();
@@ -310,8 +310,7 @@ var ManageGoalsSchema = z3.object({
 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: the Goal waits until then and its owner is woken when it passes; null takes it back); 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 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_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: the Goal waits until then and its owner is woken when it passes; null takes it back); 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 any Goal of your person; a change puts you on it. Returns `ok` (every change applied), `results` per change (applied or failed), and `goals`, each changed Goal's id, state, title, outcome and revision.";
 var GetGoalSchema = z3.object({
   goalId: z3.string().uuid(),
   /** Every entry in full. Without it the read carries the person's words, open questions and your
@@ -322,8 +321,7 @@ var GetGoalSchema = z3.object({
    *  between two of them named. Off by default; `docs/model/goal/diagnose-design.md`. */
   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 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 GET_GOAL_DESCRIPTION = "Read one Goal (a read never puts you on 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 SearchToolSchema = z3.object({
   query: z3.string().trim().min(1).max(500),
   types: z3.array(z3.enum(["entry", "goal", "answer"])).min(1).optional(),
@@ -331,7 +329,7 @@ var SearchToolSchema = z3.object({
   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 CheckActivitySchema = z3.object({}).strict();
 var FEEDBACK_TEXT_MAX = 5e4;
 var SendFeedbackSchema = z3.object({
   text: z3.string().trim().min(1).max(FEEDBACK_TEXT_MAX).describe(`The report, in markdown: what happened, what was expected, how to reproduce it, versions, evidence. At most ${FEEDBACK_TEXT_MAX} characters.`),
@@ -340,24 +338,23 @@ var SendFeedbackSchema = z3.object({
 }).strict();
 var SEND_FEEDBACK_DESCRIPTION = "Send feedback about Paigy itself (a bug report, an idea) straight to the Paigy team. Send it only when the person asked you to, or agreed when you offered: it goes to Paigy, never to the person, and nobody answers it here. Not for your work or a question for the person: use contact for those. Returns whether it was stored.";
 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(WhoIsWorkingSchema) },
   { name: "contact", description: CONTACT_DESCRIPTION, inputSchema: CONTACT_SCHEMA },
   { 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: "search", description: SEARCH_DESCRIPTION, inputSchema: mcpInputSchema(SearchToolSchema) },
+  { name: "check_activity", 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(CheckActivitySchema) },
   { name: "send_feedback", description: SEND_FEEDBACK_DESCRIPTION, inputSchema: mcpInputSchema(SendFeedbackSchema) }
 ];
 var AGENT_TOOL_NAMES = AGENT_TOOLS.map((t) => t.name);
 function serverInstructions(opts) {
   const waits = opts.waits ? "contact({..., wait:true}) holds one bounded ~45 s window for a response to what you sent; contact({}) holds one for anything addressed to you." : "A contact here returns after one read (`waitOutcome: not_waited`); answers wake you, and contact({wait:false}) collects them.";
-  return `On startup and after a wake, call contact({wait:false}) for the events addressed to you (acknowledge the ones you handled with contact({ackEventIds})), 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 (a contact naming its id), 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; a contact only names Goals that already exist. Every read ends in \`next\`, the one step to take. Sending returns immediately unless you ask it to wait: keep working and collect answers by receiving or through claim_goal/get_goal. ${waits} Events repeat until you acknowledge them: reading alone acknowledges nothing; an \`update\` event acknowledged is a review cleared. Report progress as a contact update: one the person does not need yet is kept as the Goal's progress and reaches no one. To follow up later, defer the Goal with manage_goals: you are woken when its time comes. Never infer ringing from an open Call Delivery. Soft waiting and re-presentation are unsupported. Your user is remote. Always interact with the user through Paigy. For decisions, approvals, or questions, contact them with structured options. Never assume anyone is reading the terminal stdout.
+  return `On startup and after a wake, call contact({wait:false}) for the events addressed to you (acknowledge the ones you handled with contact({ackEventIds})), which hand you your work: answers, assignments, reviews and due Goals. get_goal reads a Goal and the conversation on it; a read never puts you on it. You are on a Goal from your first write to it (a contact update, question or answer naming it, or a manage_goals change); there is nothing to claim or join. Every Goal of your person is open to you, whichever of their agents owns it: read it with get_goal, write on it (a contact naming its id) and change it (manage_goals). Create, edit, assign, organize or close work with manage_goals, never as a contact; a contact only names Goals that already exist. Every read ends in \`next\`, the one step to take. Sending returns immediately unless you ask it to wait: keep working and collect answers by receiving or through get_goal. ${waits} Events repeat until you acknowledge them: reading alone acknowledges nothing; an \`update\` event acknowledged is a review cleared. Report progress as a contact update: one the person does not need yet is kept as the Goal's progress and reaches no one. To follow up later, defer the Goal with manage_goals: you are woken when its time comes. Never infer ringing from an open Call Delivery. Soft waiting and re-presentation are unsupported. Your user is remote. Always interact with the user through Paigy. For decisions, approvals, or questions, contact them with structured options. Never assume anyone is reading the terminal stdout.
 
 HOW TO ASK:
 1. One question per question object. Five questions are five objects in \`questions\`, in one contact, so each can be answered on its own; one question with five parts settles nothing until all five are answered.
 2. Name the Goal you are working on as the question's \`goalId\`: the question goes onto that Goal and its answer comes back there. It must exist: create it with manage_goals first.
 3. \`workItBlocks\` only for work you are truly blocked on (it asks for a call); leave it out for a question you can keep working around.
-4. Never hold the process open with while-loops. A wait that comes back \`expired\` is not a finished conversation: wait again with contact({wait:true}) only while you have nothing else to do. STOP WAITING when a window comes back with nothing new \u2014 the question stays open, and its answer reaches you on the Goal. Otherwise, yield only with a working listener or scheduled wakeup, and collect answers with \`contact({wait:false})\` or \`claim_goal\` on that wake.
+4. Never hold the process open with while-loops. A wait that comes back \`expired\` is not a finished conversation: wait again with contact({wait:true}) only while you have nothing else to do. STOP WAITING when a window comes back with nothing new \u2014 the question stays open, and its answer reaches you on the Goal. Otherwise, yield only with a working listener or scheduled wakeup, and collect answers with \`contact({wait:false})\` or \`get_goal\` on that wake.
 5. One question, one row. Never restate a question that is still waiting inside a new contact: keep waiting on the original, or the answer lands on one copy and the other stays open. Take back one that no longer matters with \`withdrawQuestionIds\`.
 6. Read the Goal's conversation before asking. Never ask again what was answered or already shipped \u2014 and tell its states apart: \`answered\` carries the choice in \`answer\`, while \`replied\` means they said something and chose none of your options, so that question is still yours to settle and their words are the line beside it.
 7. A question carries its options. 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\`. \`pickMode: "many"\` makes the card a checklist (options they may want several of); \`"one"\`, the default, a pick (one rules out the others); \`"rank"\` an ordering. Your question is sent exactly as you wrote it. They can always answer in their own words, so no "Other" option.
@@ -1585,7 +1582,7 @@ var HostDecisionSchema = z7.object({
   /** The agent's token id: the row's `recipient`. */
   agent: z7.string().uuid(),
   decision: z7.enum(["stood_back", "took_over"]),
-  /** The work it was about: the Goal `claim_goal` would hand that agent next. */
+  /** The work it was about: the Goal waiting on that agent next (`claimable` on its `contact({})` read). */
   goalId: z7.string().uuid().nullable().optional(),
   /** When the server last heard from the agent, as the host read it: the presence it stood back for. */
   seenAt: z7.string().datetime().nullable().optional(),
@@ -1816,7 +1813,7 @@ next contact({ wait: false }). Start your own listener now, as a BACKGROUND task
 
 Each line it prints is a Delivery waiting for you: read the Goal, and reply with contact when
 the answer needs a decision. Start it once; if it is already running, do nothing. Then call
-claim_goal once: work handed to you before this session started waits there.
+contact({ wait: false }) once: work handed to you before this session started waits there.
 PAIGY
 exit 0
 `;
@@ -1852,7 +1849,7 @@ function decideListen(f) {
   return {
     status: "start",
     command: `PAIGY_AGENT=${word(f.slot)} PAIGY_SESSION_ID=${word(f.session)} ${f.env.CODEX_THREAD_ID ? `CODEX_THREAD_ID=${word(f.env.CODEX_THREAD_ID)} ` : ""}${f.env.PAIGY_ON_WAKE ? `PAIGY_ON_WAKE=${word(f.env.PAIGY_ON_WAKE)} ` : ""}${word(f.execPath)} ${word(f.listenJs)} --brief`,
-    how: "Run this command NOW as a watched background task (your harness's background-task/monitor tool), and leave it running for this session. Each line it prints is a Delivery waiting for you: claim_goal the Goal it names, read it, and answer with contact. Start it once."
+    how: "Run this command NOW as a watched background task (your harness's background-task/monitor tool), and leave it running for this session. Each line it prints is a Delivery waiting for you: read the Goal it names with get_goal, and answer with contact. Start it once."
   };
 }
 function listenMark(slot, home = homedir()) {

package/dist/{dist-WGFUXFS4.js → dist-N6ZJUJV7.js}

@@ -17,7 +17,7 @@ import {
   acknowledge,
   agentName,
   authToken,
-  claimGoal,
+  checkActivity,
   claimSessionEnds,
   claimSessions,
   contact,
@@ -64,9 +64,8 @@ import {
   subscribeWake,
   updateSlot,
   whoAmI,
-  whoIsWorking,
   withCodexEnv
-} from "./chunk-OVSAQW3K.js";
+} from "./chunk-4C6SDQ7A.js";
 export {
   AGENT_TOOLS,
   AGENT_TOOL_NAMES,
@@ -86,7 +85,7 @@ export {
   acknowledge,
   agentName,
   authToken,
-  claimGoal,
+  checkActivity,
   claimSessionEnds,
   claimSessions,
   contact,
@@ -133,6 +132,5 @@ export {
   subscribeWake,
   updateSlot,
   whoAmI,
-  whoIsWorking,
   withCodexEnv
 };

package/dist/enable.js

@@ -3,9 +3,9 @@ import {
   PAIGY_TOOL_IDS,
   enablePaigyTools,
   installSessionListening
-} from "./chunk-5MQ3J6S3.js";
-import "./chunk-7LQKX73K.js";
-import "./chunk-OVSAQW3K.js";
+} from "./chunk-A5FYZK6P.js";
+import "./chunk-X3GTDW5G.js";
+import "./chunk-4C6SDQ7A.js";
 
 // src/enable.ts
 function main() {
@@ -16,14 +16,14 @@ function main() {
     if (arg === "-h" || arg === "--help") {
       console.log("usage: paigy-enable-tools [--scope user|project]");
       console.log("");
-      console.log("Allowlist Paigy's notify/await tools in Claude Code so they run without an");
+      console.log("Allowlist Paigy's tools in Claude Code so they run without an");
       console.log("approval prompt each time \u2014 an unattended session can't stall on a dialog.");
       console.log("");
       console.log("  --scope user     ~/.claude/settings.json (default) \u2014 every project");
       console.log("  --scope project  ./.claude/settings.json \u2014 just this repo");
       console.log("");
       console.log(`Adds: ${PAIGY_TOOL_IDS.join(", ")}`);
-      console.log("Leaves pair/unpair out, so they stay human-approved. Safe to re-run.");
+      console.log("Safe to re-run.");
       return;
     }
     if (arg === "--scope") {

package/dist/index.js

@@ -9,23 +9,22 @@ import {
   resolvePairing,
   startPairing,
   suggestedAgentName
-} from "./chunk-BLWC44CQ.js";
+} from "./chunk-UQDA7X3W.js";
 import {
+  ConfigureSchema,
   ENABLE_COMMAND,
-  OnboardSchema,
   PAIGY_TOOL_IDS,
-  PairSchema,
   SERVER_INSTRUCTIONS,
   TOOLS,
   paigyToolsAllowlisted
-} from "./chunk-5MQ3J6S3.js";
+} from "./chunk-A5FYZK6P.js";
 import {
   decideListen,
   existingListener,
   harnessDriven,
   listenerKey,
   wakeStatusPath
-} from "./chunk-7LQKX73K.js";
+} from "./chunk-X3GTDW5G.js";
 import {
   clearSurface,
   writeSurface
@@ -46,7 +45,7 @@ import {
   setClient,
   slotName,
   whoAmI
-} from "./chunk-OVSAQW3K.js";
+} from "./chunk-4C6SDQ7A.js";
 
 // src/index.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -113,7 +112,7 @@ function pairedResult(token, sas, note) {
   if (note) base.note = note;
   base.enable_tool_ids = PAIGY_TOOL_IDS;
   base.enable_command = ENABLE_COMMAND;
-  base.enable_prompt = "REQUIRED \u2014 before you do anything else, print `enable_command` to the user and say: \"Run this to let Paigy's tools work without an approval prompt each time \u2014 it only allowlists the notify/await tools; pair and unpair still ask.\" Print it every time you pair; don't skip it.";
+  base.enable_prompt = "REQUIRED \u2014 before you do anything else, print `enable_command` to the user and say: \"Run this to let Paigy's tools work without an approval prompt each time \u2014 it only allowlists Paigy's own tools.\" Print it every time you pair; don't skip it.";
   base.enable_apply = "You cannot apply this yourself, and must not try: it writes YOUR OWN permission allowlist, which hosts block as privilege escalation no matter what the user said here. PRINT the command and move on \u2014 don't wait for them to run it, and don't re-ask. Paigy's tools still work meanwhile; they just prompt for approval each time until the user runs it. If the host isn't Claude Code, tell them to add `enable_tool_ids` to that tool's own allowlist instead, merging \u2014 never clobbering.";
   return { content: [{ type: "text", text: JSON.stringify(base) }] };
 }
@@ -130,7 +129,7 @@ Check it matches the code on the phone, then type it there to confirm.` },
           sas,
           device_code,
           user_message: `# ${sas}`,
-          verify_message: `STOP HERE: end your turn now with \`user_message\` (the bare code) as your entire reply \u2014 do NOT call pair again in this same turn, or the code text is dropped before the user sees it. This is the verification code they compare + type on their phone; it REPLACES any earlier one. Poll for their confirmation by calling pair with this device_code on your NEXT turn.`,
+          verify_message: `STOP HERE: end your turn now with \`user_message\` (the bare code) as your entire reply \u2014 do NOT call configure again in this same turn, or the code text is dropped before the user sees it. This is the verification code they compare + type on their phone; it REPLACES any earlier one. Poll for their confirmation by calling configure with this device_code on your NEXT turn.`,
           message: "No token is issued until the user confirms the code match on their phone (E2EE account)."
         })
       }
@@ -152,7 +151,7 @@ function renderPairOutcome(outcome, device_code) {
           text: JSON.stringify({
             status: "pending",
             device_code,
-            message: "Still awaiting approval \u2014 the user hasn't entered the code yet. Call pair again with this device_code RIGHT NOW to keep waiting; each call returns after ~45s so it can't be killed by a host tool-call timeout. Nothing is lost between calls: the code stays valid and approval keeps being polled in the background, so a re-call returns the instant they approve."
+            message: "Still awaiting approval \u2014 the user hasn't entered the code yet. Call configure again with this device_code RIGHT NOW to keep waiting; each call returns after ~45s so it can't be killed by a host tool-call timeout. Nothing is lost between calls: the code stays valid and approval keeps being polled in the background, so a re-call returns the instant they approve."
           })
         }]
       };
@@ -162,7 +161,7 @@ function unidentifiedResult() {
   return { isError: true, content: [{ type: "text", text: JSON.stringify({
     error: "no_identity",
     slot: agentName(),
-    message: `This session has no Paigy identity yet, so nothing was sent \u2014 it will not speak as another session. This machine holds a device credential but hatching under it just failed (it may have been revoked), so call \`pair\` (no arguments) to set this session up, then retry \u2014 it re-hatches if the credential recovered and runs the code ceremony if it didn't. To reuse an existing identity instead, start the session with PAIGY_AGENT set to its slot (${listSlots().filter((s) => s !== "Desktop").join(", ") || "none yet"}).`
+    message: `This session has no Paigy identity yet, so nothing was sent \u2014 it will not speak as another session. This machine holds a device credential but hatching under it just failed (it may have been revoked), so call \`configure\` (no arguments) to set this session up, then retry \u2014 it re-hatches if the credential recovered and runs the code ceremony if it didn't. To reuse an existing identity instead, start the session with PAIGY_AGENT set to its slot (${listSlots().filter((s) => s !== "Desktop").join(", ") || "none yet"}).`
   }) }] };
 }
 function pairStartResult(start, loggedOut) {
@@ -204,7 +203,7 @@ This session isn't on a connected computer, so it asks by code.`;
       expires_in: start.expiresIn,
       qr: ascii,
       user_message: userMessage,
-      message: "REQUIRED: print user_message for the user \u2014 the LINK is the primary action, the code is the fallback, and `qr` is there for a phone when they ask. Then call pair again with device_code to collect approval. Do not open a browser yourself."
+      message: "REQUIRED: print user_message for the user \u2014 the LINK is the primary action, the code is the fallback, and `qr` is there for a phone when they ask. Then call configure again with device_code to collect approval. Do not open a browser yourself."
     }) }
   ] };
 }
@@ -241,7 +240,7 @@ async function runPair(device_code, name, voice, note) {
     if ("ok" in dt) return pairedResult(
       dt,
       void 0,
-      "Hatched instantly under this device's credential \u2014 no code needed. " + (dt.message ? `${dt.message} Set it with onboard({ name }).` : name ? "" : `You were given a default name ("${dt.name}") \u2014 the user never chose it, so don't announce it as their agent's identity. They can rename it in the app, or you can re-call pair with { name, voice }.`)
+      "Hatched instantly under this device's credential \u2014 no code needed. " + (dt.message ? `${dt.message} Set it with configure({ name }).` : name ? "" : `You were given a default name ("${dt.name}") \u2014 the user never chose it, so don't announce it as their agent's identity. They can rename it in the app, or you can call configure with { name, voice }.`)
     );
     miss = dt;
   }
@@ -260,7 +259,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
     return await handleTool(request, extra?.signal);
   } catch (e) {
     if (e instanceof UnpairedError) {
-      const IDENTITY_TOOLS = /* @__PURE__ */ new Set(["pair", "onboard", "unpair"]);
+      const IDENTITY_TOOLS = /* @__PURE__ */ new Set(["configure"]);
       const hatched = IDENTITY_TOOLS.has(request.params.name) ? null : await hatchUnderDevice();
       const next = afterUnpaired(hatched, listSlots().includes("Desktop"));
       if (next === "retry") return await handleTool(request, extra?.signal);
@@ -273,26 +272,46 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
 function suggestedAgentName2() {
   return suggestedAgentName(server.getClientVersion?.()?.name);
 }
+async function logOutResult() {
+  const token = readToken();
+  let revoked = false;
+  if (token) {
+    try {
+      revoked = await revokeToken(token);
+    } catch {
+      revoked = false;
+    }
+  }
+  const removed = deleteToken();
+  clearPairing();
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify({
+        ok: true,
+        revoked,
+        removed,
+        message: token ? `Logged out. Server token ${revoked ? "revoked" : "revoke not confirmed"}; local token ${removed ? "deleted" : "was already absent"}.` : "No token found \u2014 already logged out."
+      })
+    }]
+  };
+}
 async function handleTool(request, signal) {
   switch (request.params.name) {
-    case "pair": {
-      const a = PairSchema.parse(request.params.arguments ?? {});
-      return runPair(a.device_code, a.name, a.voice);
-    }
     // ONE rail for "get this agent talking to Paigy" (#875). `pair`, the `paigy-mcp-onboard`
     // CLI and `enable_tools` were three doors into one flow, each knowing a different slice
-    // of the state — so "onboard" was the word people reached for and the tool that did the
-    // least, and a half-configured agent (paired but not allowlisted, or holding a token for
-    // a slot it can no longer resolve) had nothing to ask.
+    // of the state, and a half-configured agent (paired but not allowlisted, or holding a token
+    // for a slot it can no longer resolve) had nothing to ask. Since 2026-10-07 (owner) it is
+    // `configure`, the only identity tool: `onboard` renamed, `pair` gone (this did all of it),
+    // and `unpair` folded in as `logOut`.
     //
     // It reports state and does the next thing, and it is IDEMPOTENT: calling it when
     // everything is fine costs one round trip and returns who you are. Reporting never
     // mutates — the allowlist check is read-only on purpose, because a status call that
     // quietly edits the user's settings is the opposite of what this is for.
-    // `start` stays accepted, unlisted — it shipped under that name for one afternoon.
-    case "start":
-    case "onboard": {
-      const { name, voice, device_code, scope } = OnboardSchema.parse(request.params.arguments ?? {});
+    case "configure": {
+      const { name, voice, device_code, scope, logOut } = ConfigureSchema.parse(request.params.arguments ?? {});
+      if (logOut) return logOutResult();
       if (device_code) return runPair(device_code, name, voice);
       const slot = agentName();
       const secret = readToken();
@@ -311,14 +330,14 @@ async function handleTool(request, signal) {
               ...allowlisted ? {} : {
                 enable_tool_ids: PAIGY_TOOL_IDS,
                 enable_command: ENABLE_COMMAND,
-                enable_prompt: "Print `enable_command` to the user: \"Run this to let Paigy's tools work without an approval prompt each time \u2014 it only allowlists the notify/await tools; pair and unpair still ask.\" You cannot run it yourself (it writes your own permission allowlist, which hosts block as privilege escalation) \u2014 print it, don't wait for it, and carry on."
+                enable_prompt: "Print `enable_command` to the user: \"Run this to let Paigy's tools work without an approval prompt each time \u2014 it only allowlists Paigy's own tools.\" You cannot run it yourself (it writes your own permission allowlist, which hosts block as privilege escalation) \u2014 print it, don't wait for it, and carry on."
               },
               // Setup is done, so the only things left are the user's to decide. Named here
               // rather than left implicit: an agent that reports "ready" and stops gives the
               // user no way to act on an identity they may not want.
               actions: {
-                rename: "Call onboard again with { name } (and optionally { voice }) to change it.",
-                unpair: "Call the `unpair` tool to disconnect this agent from the account."
+                rename: "Call configure again with { name } (and optionally { voice }) to change it.",
+                logOut: "Call configure({ logOut: true }) to log this agent out (other agents and this device stay paired)."
               },
               message: me.message
             }) }]
@@ -328,30 +347,6 @@ async function handleTool(request, signal) {
       }
       return runPair(void 0, name, voice);
     }
-    case "unpair": {
-      const token = readToken();
-      let revoked = false;
-      if (token) {
-        try {
-          revoked = await revokeToken(token);
-        } catch {
-          revoked = false;
-        }
-      }
-      const removed = deleteToken();
-      clearPairing();
-      return {
-        content: [{
-          type: "text",
-          text: JSON.stringify({
-            ok: true,
-            revoked,
-            removed,
-            message: token ? `Unpaired. Server token ${revoked ? "revoked" : "revoke not confirmed"}; local token ${removed ? "deleted" : "was already absent"}.` : "No token found \u2014 already unpaired."
-          })
-        }]
-      };
-    }
     // AM I LISTENING? (#2265) Decides and hands over — `listening.ts` owns the rule and the four
     // answers. The facts are read here, once: the harness's session mark, a token to listen as,
     // a live listener's mark for this slot, and where THIS server's node and daemon live. The

package/dist/listen.js

@@ -11,7 +11,7 @@ import {
   removeListenMark,
   wakeStatusPath,
   writeListenMark
-} from "./chunk-7LQKX73K.js";
+} from "./chunk-X3GTDW5G.js";
 import {
   agentName,
   getGoal,
@@ -20,7 +20,7 @@ import {
   receive,
   slotName,
   subscribeWake
-} from "./chunk-OVSAQW3K.js";
+} from "./chunk-4C6SDQ7A.js";
 
 // src/listen.ts
 import { createHash } from "crypto";
@@ -145,9 +145,9 @@ function brief(waiting, reason, as, goalId) {
   const stalled = waiting.stalled?.length ? ` \xB7 ${waiting.stalled.length} of your Goals stalled 3+ days: update, finish or cancel each` : "";
   const review = waiting.review ?? [];
   const named = (goalId ? review.find((g) => g.goalId === goalId) : void 0) ?? review[0];
-  const fresh = review.length ? ` \xB7 new on ${review.length === 1 ? "your Goal" : `${review.length} of your Goals`}, first ${named.goalId} ("${named.title}"): claim_goal to read it` : "";
+  const fresh = review.length ? ` \xB7 new on ${review.length === 1 ? "your Goal" : `${review.length} of your Goals`}, first ${named.goalId} ("${named.title}"): get_goal to read it` : "";
   const assigned = waiting.assigned ?? [];
-  const mine = assigned.length ? ` \xB7 assigned to you: ${assigned.length === 1 ? "1 Goal" : `${assigned.length} Goals`}, first ${assigned[0].goalId} ("${assigned[0].title}"): claim_goal({goalId}) to start it` : "";
+  const mine = assigned.length ? ` \xB7 assigned to you: ${assigned.length === 1 ? "1 Goal" : `${assigned.length} Goals`}, first ${assigned[0].goalId} ("${assigned[0].title}"): get_goal({goalId}) to read it; your first write starts it` : "";
   if (!lead) return `Paigy \xB7 ${reason === "boot" ? `listening as ${as}` : reason}${mine}${fresh || (mine ? "" : " \xB7 nothing waiting")}${stalled}`;
   const said = saidIn(lead) || ("about" in lead ? lead.about : "");
   const shown = said.length > 160 ? `${said.slice(0, 160)}\u2026` : said;

package/dist/onboard.js

@@ -3,13 +3,13 @@ import {
   resolvePairing,
   startPairing,
   suggestedAgentName
-} from "./chunk-BLWC44CQ.js";
+} from "./chunk-UQDA7X3W.js";
 import {
   autoConfigureClients,
   claudeInstallHint,
   openBrowser
-} from "./chunk-5MQ3J6S3.js";
-import "./chunk-7LQKX73K.js";
+} from "./chunk-A5FYZK6P.js";
+import "./chunk-X3GTDW5G.js";
 import {
   TOKEN_PATH,
   agentName,
@@ -20,7 +20,7 @@ import {
   saveToken,
   setIdentity,
   whoAmI
-} from "./chunk-OVSAQW3K.js";
+} from "./chunk-4C6SDQ7A.js";
 
 // src/onboard.ts
 function reportRegistered() {
@@ -58,8 +58,8 @@ Paigy MCP onboarding (agent: "${agentName()}")
       console.log(`Already set up as "${who.name}"${who.voice ? ` (voice: ${who.voice})` : ""}.
 `);
       console.log("Nothing to do. What's left is yours to decide:");
-      console.log('  rename  \u2014 PAIGY_NAME="New name" paigy-mcp-onboard  (or the `onboard` MCP tool)');
-      console.log("  unpair  \u2014 the MCP `unpair` tool, or delete this slot from ~/.paigy/token.json\n");
+      console.log('  rename  \u2014 PAIGY_NAME="New name" paigy-mcp-onboard  (or the `configure` MCP tool)');
+      console.log("  log out \u2014 the MCP `configure` tool with { logOut: true }, or delete this slot from ~/.paigy/token.json\n");
       return;
     }
     console.log("The saved token is no longer valid \u2014 re-pairing.\n");

package/dist/slot.js

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

package/dist/stalled.js

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

package/dist/statusline.js

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

package/package.json

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