@paigy/mcp 0.40.17 → 0.40.19

package/README.md

@@ -215,19 +215,48 @@ script and branch on `$PAIGY_EVENT` there:
 codex exec "Paigy goal $PAIGY_GOAL_ID. claim_goal it first. The user said: $PAIGY_TEXT. Reply with contact when done."
 ```
 
-## Stalled work (Claude Code stop hook)
+## 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
 `stalled`, `paigy-listen` carries it in `PAIGY_WORK` (and launches for it on boot), and this
-hook holds a Claude Code session's stop once a day to list it:
+hook holds a session's turn end once a day to list it. One program, four tools:
+
+**Claude Code** (`~/.claude/settings.json`) — installed by the paigy plugin:
 
 ```json
 { "hooks": { "Stop": [{ "hooks": [{ "type": "command", "command": "npx -y -p @paigy/mcp paigy-stalled" }] }] } }
 ```
 
+**Codex** (`~/.codex/config.toml`) — its `Stop` event takes the same `{ decision, reason }`, so
+the same program serves it. Written for you when you pair from another tool:
+
+```toml
+[[hooks.Stop]]
+
+[[hooks.Stop.hooks]]
+type = "command"
+command = "npx -y -p @paigy/mcp@latest paigy-stalled --agent codex"
+timeout = 60
+```
+
+**Gemini CLI / Antigravity** (`~/.gemini/settings.json`, `~/.gemini/antigravity-cli/settings.json`)
+— the turn-end event there is `AfterAgent`, and the reminder also arrives as a `systemMessage`,
+which is the field that event promises will reach somebody:
+
+```json
+{ "hooks": { "AfterAgent": [{ "matcher": "*", "hooks": [{ "name": "paigy-stalled", "type": "command",
+  "command": "npx -y -p @paigy/mcp@latest paigy-stalled --agent antigravity", "timeout": 60000 }] }] } }
+```
+
+`--agent <slot>` is not optional outside Claude Code: a hook is not the MCP server, so it never
+inherits the `PAIGY_AGENT` that server was registered with, and without the flag it reads this
+session's own slot — a different identity, with no stalled work of its own. Pass the same value as
+the tool's MCP registration (`codex`, `antigravity`, or whatever you set `PAIGY_AGENT` to).
+
 It is silent when nothing is stalled, when the stop is already being continued by a hook, and
-after it has reminded that session once today.
+after it has reminded that session once today. Codex's older `notify` program is not a place for
+this: it is spawned fire-and-forget with stdio null, so nothing it prints can reach the agent.
 
 ## Statusline (Claude Code)
 

package/dist/{chunk-7VLZIOLF.js → chunk-76ILN3YV.js}

@@ -4,10 +4,10 @@ import {
   serverInstructions,
   sessionStartHook,
   withSessionStartHook
-} from "./chunk-MWHYYLCE.js";
+} from "./chunk-HGXXGOGG.js";
 import {
   agentName
-} from "./chunk-V5AQASR7.js";
+} from "./chunk-VYWIPFEY.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.";
@@ -99,6 +99,55 @@ function withPaigyMcpToml(existing, agent) {
   ].join("\n");
   return existing + entry;
 }
+function stalledHookCommand(agent) {
+  return `npx -y -p @paigy/mcp@latest paigy-stalled --agent ${agent}`;
+}
+function withPaigyStopHookToml(existing, agent) {
+  if (existing.includes("paigy-stalled")) return null;
+  const entry = [
+    "",
+    "[[hooks.Stop]]",
+    "",
+    "[[hooks.Stop.hooks]]",
+    'type = "command"',
+    `command = "${stalledHookCommand(agent)}"`,
+    "timeout = 60",
+    // seconds, in Codex — a cold `npx` resolve is slow the first time
+    ""
+  ].join("\n");
+  return existing + entry;
+}
+function withPaigyStopHookJson(existing, agent) {
+  let config = {};
+  if (existing) {
+    try {
+      config = JSON.parse(existing);
+    } catch {
+      return null;
+    }
+  }
+  const hooks = config.hooks ?? {};
+  const kept = (hooks.AfterAgent ?? []).map((group) => ({ ...group, hooks: (group.hooks ?? []).filter((hook) => hook.name !== "paigy-stalled") })).filter((group) => group.hooks.length > 0);
+  config.hooks = {
+    ...hooks,
+    AfterAgent: [
+      ...kept,
+      {
+        matcher: "*",
+        hooks: [
+          {
+            name: "paigy-stalled",
+            type: "command",
+            command: stalledHookCommand(agent),
+            timeout: 6e4
+            // milliseconds, in Gemini CLI
+          }
+        ]
+      }
+    ]
+  };
+  return JSON.stringify(config, null, 2);
+}
 function autoConfigureClients(skip = agentName()) {
   const home = homedir();
   const registered = [];
@@ -118,6 +167,20 @@ function autoConfigureClients(skip = agentName()) {
       } catch {
       }
     }
+    for (const path of [
+      join(home, ".gemini", "settings.json"),
+      join(home, ".gemini", "antigravity-cli", "settings.json")
+    ]) {
+      try {
+        if (!existsSync(dirname(path))) continue;
+        const existing = existsSync(path) ? readFileSync(path, "utf8") : null;
+        const updated = withPaigyStopHookJson(existing, "antigravity");
+        if (updated === null) continue;
+        writeFileSync(path, updated);
+        registered.push(`Paigy's turn-end reminder (${path})`);
+      } catch {
+      }
+    }
   }
   if (skip !== "codex") {
     const codexConfig = join(home, ".codex", "config.toml");
@@ -129,6 +192,12 @@ function autoConfigureClients(skip = agentName()) {
           writeFileSync(codexConfig, updated);
           registered.push(`OpenAI Codex (${codexConfig})`);
         }
+        const afterMcp = existsSync(codexConfig) ? readFileSync(codexConfig, "utf8") : "";
+        const withHook = withPaigyStopHookToml(afterMcp, "codex");
+        if (withHook !== null) {
+          writeFileSync(codexConfig, withHook);
+          registered.push(`Paigy's turn-end reminder (${codexConfig})`);
+        }
       }
     } catch {
     }

package/dist/{chunk-MWHYYLCE.js → chunk-HGXXGOGG.js}

@@ -113,8 +113,13 @@ var UpdateGoalSchema = z3.object({
 }).strict();
 var UpdateGoalToolSchema = UpdateGoalSchema.omit({ operationId: true }).extend({ goalId: z3.string().uuid() }).strict();
 var ClaimGoalSchema = z3.object({ goalId: z3.string().uuid().optional() }).strict();
-var GetGoalSchema = z3.object({ goalId: z3.string().uuid() }).strict();
-var GET_GOAL_DESCRIPTION = "Read one Goal without claiming it: its outcome, state, revision, progress, blockers, the conversation on it (each question with its options and what was decided), and `next`, the one step to take. Foreign or sibling-owned Goals are not disclosed.";
+var GetGoalSchema = z3.object({
+  goalId: z3.string().uuid(),
+  /** Every entry in full. Without it the read carries the person's words, open questions and your
+   *  newest entry, and counts what it left out (`apps/api/src/goal/collapse.ts`). */
+  history: z3.boolean().optional()
+}).strict();
+var GET_GOAL_DESCRIPTION = "Read one Goal without claiming it: its outcome, state, revision, progress, blockers, the conversation on it (each question with its options and what was decided), `next`, the one step to take, and `more`, where to read further. The conversation carries everything the person said, every open question and your newest entry; your older entries are left out and counted \u2014 history: true reads every entry in full. Another account's Goals, and another agent's Goal that is not below one of yours, are not disclosed.";
 var UPDATE_GOAL_DESCRIPTION = `Update an owned Goal at an exact revision. State, ownership, dependencies, children, progress, title, and review acknowledgement are explicit; stale revisions are rejected. title is the work's name in one to five words, as a person would refer to it out loud (it is spoken on a call and heads every list); null clears it. reviewed: true acknowledges new evidence and closes the Deliveries addressed to you on that Goal, never over an open decision. dueAt (an ISO instant, or null) makes the Goal wait until then; when it passes you are woken for it \u2014 use it for a promise to follow up later. state: done means the work was accomplished, and it can be reopened: when the person says it is not done ("it's not working"), set state: active on that same Goal instead of starting a new one; its parent reopens with it. cancelled is final. Returns the Goal as get_goal reads it, at its new revision.`;
 var CLAIM_GOAL_DESCRIPTION = "Claim the oldest runnable or review-pending Goal you own, or pass goalId to claim that Goal. Another agent's Goal that has gone quiet for 3 days (check_replies lists them as stalledOthers) is taken over when you claim it, and becomes yours to finish or cancel. Returns the Goal as get_goal reads it, and creates or renews the execution lease.";
 var CHECK_REPLIES_DESCRIPTION = "What is waiting for you: your open Deliveries (a request the user started toward you, a handoff), one row each with its Goals, how many decisions are still open, and the newest words in brief; `assigned`, your Goals nobody has started yet, however they became yours (claim_goal({goalId}) starts one); and `review`, your Goals with something new on them \u2014 the user's answers and notes are Entries on the Goal, not Deliveries. A pure read with no arguments: nothing is consumed, acknowledged or claimed by reading it, so call it on startup, after a long wait, or whenever you want to know what is outstanding. To act on one, claim its Goal (claim_goal) or reread a Delivery in full with contact({deliveryId}). Once you have acted on what arrived, update_goal with reviewed: true clears the Goal from `review` and closes the Deliveries addressed to you on it.";
@@ -128,9 +133,10 @@ var AGENT_TOOLS = [
   { name: "update_goal", description: UPDATE_GOAL_DESCRIPTION, inputSchema: mcpInputSchema(UpdateGoalToolSchema) }
 ];
 var AGENT_TOOL_NAMES = AGENT_TOOLS.map((t) => t.name);
+var DONE_MESSAGE = "When the work is done, send one message through contact saying what is done and anything the person needs to do or check.";
 function serverInstructions(opts) {
   const calls = opts.waits ? "A Call holds one bounded window here; continue with contact({deliveryId}) to hold the next or reread that exact Delivery." : "A Call returns after one read; continue with contact({deliveryId}) to reread that exact Delivery.";
-  return `On startup and after a wake, call check_replies for the open Deliveries addressed to you, and claim_goal for your runnable or review-pending Goal and the conversation on it. get_goal rereads it without claiming. Every read ends in \`next\`, the one step to take. Notifications return immediately: keep working and collect answers through claim_goal/get_goal. ${calls} Evidence can repeat: reads do not acknowledge or hide it. Report progress and acknowledge review with update_goal, never as a contact. Never infer ringing from an open Call Delivery. Soft waiting and re-presentation are unsupported. Your user is remote. Always interact with the user through Paigy. For decisions, approvals, or questions, contact them with structured options. Never assume anyone is reading the terminal stdout.
+  return `On startup and after a wake, call check_replies for the open Deliveries addressed to you, and claim_goal for your runnable or review-pending Goal and the conversation on it. get_goal rereads it without claiming. Every read ends in \`next\`, the one step to take. Notifications return immediately: keep working and collect answers through claim_goal/get_goal. ${calls} Evidence can repeat: reads do not acknowledge or hide it. Report progress and acknowledge review with update_goal, never as a contact. ${DONE_MESSAGE} Never infer ringing from an open Call Delivery. Soft waiting and re-presentation are unsupported. Your user is remote. Always interact with the user through Paigy. For decisions, approvals, or questions, contact them with structured options. Never assume anyone is reading the terminal stdout.
 
 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.
@@ -558,7 +564,13 @@ var InboxItemSchema = z4.object({
      *  request Entry's author, as the same three facts the item's own `tokenId`/`name`/`voice`
      *  carry for the call's one agent, so the phone draws it with the same seed. Absent when the
      *  author is not an agent this account holds (unpaired since, or a person). */
-    agent: z4.object({ tokenId: z4.string(), name: z4.string(), voice: VoiceKeySchema.optional() }).optional()
+    agent: z4.object({ tokenId: z4.string(), name: z4.string(), voice: VoiceKeySchema.optional() }).optional(),
+    /** ITS OPTIONS, WHEN THERE IS SOMETHING TO SEE (owner, 2026-09-25: "Yes, add it"): the options
+     *  its need offers, exactly as its own card carries them, present only when one of them has a
+     *  preview (`html` or `image`). The call screen opens them from the agenda row, so a preview is
+     *  never re-sent as a second card to be seen mid-call. Words-only options are absent — the bot
+     *  says those, and the list stays small (an `html` is up to 16 KB). */
+    options: z4.array(OptionSchema).optional()
   })).optional(),
   visuals: z4.array(VisualSchema).optional(),
   /** The connected agent's name (the single pairing name — user-typed, or the
@@ -954,7 +966,19 @@ var QueueItemSchema = z4.object({
   /** When its owner last SAID something about it (`goals.last_progress_at`, written by every
    *  `update_goal` that changes `progress`). `updatedAt` moves for reasons nobody chose — a
    *  state recomputed, a review flag — so it cannot tell work in hand from work gone quiet. */
-  lastProgressAt: z4.string().nullable().optional()
+  lastProgressAt: z4.string().nullable().optional(),
+  /** THE GOAL'S NEWEST WORD, FROM EITHER SIDE (owner, 2026-09-27): the newest Entry on it, of any
+   *  kind — what the person added ("Add to this"), their reply, the agent's ask or its progress
+   *  note. A progress note is an Entry, so this is already the newer of the two: the person's note
+   *  shows the moment it is written, and the agent's reply or next note replaces it by being newer.
+   *  `said` is bounded to 280 characters server-side (a line, not the conversation). Null when the
+   *  Goal carries no readable Entry; optional, so hand-built queues need not spell it. */
+  latest: z4.object({
+    from: z4.enum(["person", "agent"]),
+    said: z4.string(),
+    at: z4.string(),
+    entryId: z4.string()
+  }).nullable().optional()
 });
 var COLD_AFTER_MS = 3 * 24 * 60 * 60 * 1e3;
 var NoteSourceSchema = z4.enum(["app", "call"]);
@@ -1130,6 +1154,104 @@ var NotificationFeedbackKindSchema = z4.enum([
   "other"
   // anything else — the note carries it.
 ]);
+var SlimOptionSchema = OptionSchema.omit({ html: true });
+var QuestionRowSchema = z4.object({
+  /** The card's id (`deliveryId:needId`, or `deliveryId:entryId` for an update), as the inbox mints it. */
+  id: z4.string(),
+  deliveryId: z4.string(),
+  entryId: z4.string(),
+  /** The decision it waits on; null for an update, which asks nothing. */
+  needId: z4.string().nullable(),
+  goalIds: z4.array(z4.string()),
+  /** The name of the work it is about, when the read could word it. */
+  goalTitle: z4.string().optional(),
+  tokenId: z4.string().optional(),
+  name: z4.string(),
+  title: z4.string(),
+  body: z4.string(),
+  select: z4.enum(["one", "many", "rank", "confirm", "text"]),
+  options: z4.array(SlimOptionSchema),
+  hasPreview: z4.boolean(),
+  blocking: z4.boolean(),
+  askedAt: z4.string().datetime(),
+  ring: InboxItemSchema.shape.ring,
+  onCall: z4.literal(true).optional(),
+  sealed: z4.boolean()
+});
+var WorkStateSchema = z4.enum(["ready", "active", "waiting", "done", "cancelled"]);
+var WorkRowSchema = z4.object({
+  id: z4.string(),
+  parentId: z4.string().nullable(),
+  title: z4.string(),
+  /** Straight off the Goal. */
+  state: WorkStateSchema,
+  owner: z4.string().nullable(),
+  revision: z4.number().int(),
+  /** Open questions on it, counted to 100. */
+  waiting: z4.number().int(),
+  /** Held by a gate on work that is not done. */
+  blocked: z4.boolean(),
+  lastProgressAt: z4.string().datetime().nullable(),
+  /** The line written for its newest progress note, else that note's first words. */
+  line: z4.string().nullable(),
+  /** Work directly under it, counted to 100; the list carries up to 12 of them. */
+  children: z4.number().int(),
+  createdAt: z4.string().datetime(),
+  updatedAt: z4.string().datetime(),
+  /** When anything at or under it last moved — the order the list is in. */
+  activeAt: z4.string().datetime(),
+  /** A sealed outcome has no title here; the work's page opens it. */
+  sealed: z4.boolean()
+});
+var ComputerRowSchema = ConnectionSummarySchema.omit({ activity: true });
+var AgentRowSchema = ComputerRowSchema.extend({
+  /** Open questions it is asking the person, over every open card; null when that read failed. */
+  asking: z4.number().int().nullable(),
+  oldestAskAt: z4.string().datetime().nullable(),
+  /** Up to three of the live Goals it holds, oldest first (the order it picks them up), and how
+   *  many in all among the account's 200 most recently active agent-held live Goals
+   *  (`agent_holds`); null when that read failed. */
+  holds: z4.array(z4.object({ id: z4.string(), title: z4.string() })).nullable(),
+  held: z4.number().int().nullable(),
+  /** The earliest instant any Goal it holds went quiet, by the one rule (`coldSince`); null
+   *  while none has, or when that read failed. */
+  cold: z4.string().datetime().nullable(),
+  /** The newest line of its working log, and when the harness saw it. */
+  line: z4.string().nullable(),
+  lineAt: z4.string().datetime().nullable()
+});
+var SnapshotSchema = z4.object({
+  /** The API's clock, taken before the first read: what a later delta will start from. */
+  at: z4.string().datetime(),
+  questions: z4.object({
+    /** The newest 30 open cards, questions before updates. */
+    items: z4.array(QuestionRowSchema),
+    /** Every open question, and apart from them every update, and what was put off. */
+    total: z4.number().int(),
+    updates: z4.number().int(),
+    putOff: z4.number().int()
+  }).nullable(),
+  agents: z4.object({
+    /** Up to 60, most recently seen first. */
+    items: z4.array(AgentRowSchema),
+    more: z4.boolean()
+  }).nullable(),
+  work: z4.object({
+    /** The 60 most recently active roots, each followed by up to 12 children; 240 rows at most. */
+    items: z4.array(WorkRowSchema),
+    /** How much work is behind each of the Work tab's four filters, each counted to 100, read with
+     *  the rows. `work_list` (20260928023533) owns the predicates: Live is `ready`, `active` or
+     *  `waiting`; Waiting on you is live work with an open question or an unmet gate; Not started
+     *  is `ready`; Done is `done` or `cancelled`. */
+    counts: z4.object({ live: z4.number().int(), waiting: z4.number().int(), notStarted: z4.number().int(), done: z4.number().int() })
+  }).nullable(),
+  you: z4.object({
+    settings: UserSettingsSchema,
+    callable: z4.boolean(),
+    /** Up to 20 paired computers; null when the roster read failed. */
+    computers: z4.array(ComputerRowSchema).nullable()
+  }).nullable()
+});
 
 // src/listening.ts
 import { chmodSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";

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

@@ -1,10 +1,12 @@
 import {
+  NameTakenError,
   isNetworkError,
   pollToken,
   requestCode,
   saveToken,
+  setIdentity,
   sleep
-} from "./chunk-V5AQASR7.js";
+} from "./chunk-VYWIPFEY.js";
 
 // src/identity.ts
 var CLIENT_LABELS = {
@@ -25,6 +27,21 @@ function suggestedAgentName(clientName) {
   if (!clientName) return void 0;
   return CLIENT_LABELS[clientName.toLowerCase()] ?? clientName.replace(/[-_]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
+async function identify(who, ask) {
+  let renamed = false;
+  if (ask.name || ask.voice) {
+    try {
+      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.`;
+      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.`;
+  return { name: who.name, voice: who.voice, message };
+}
 
 // src/pairing.ts
 async function resolvePairing(deviceCode, capMs, pollMs = 2e3) {
@@ -102,6 +119,7 @@ function clearPairing(deviceCode) {
 
 export {
   suggestedAgentName,
+  identify,
   resolvePairing,
   startPairing,
   joinBackgroundPair,

package/dist/{chunk-V5AQASR7.js → chunk-VYWIPFEY.js}

@@ -1581,8 +1581,13 @@ var UpdateGoalSchema = z3.object({
 }).strict();
 var UpdateGoalToolSchema = UpdateGoalSchema.omit({ operationId: true }).extend({ goalId: z3.string().uuid() }).strict();
 var ClaimGoalSchema = z3.object({ goalId: z3.string().uuid().optional() }).strict();
-var GetGoalSchema = z3.object({ goalId: z3.string().uuid() }).strict();
-var GET_GOAL_DESCRIPTION = "Read one Goal without claiming it: its outcome, state, revision, progress, blockers, the conversation on it (each question with its options and what was decided), and `next`, the one step to take. Foreign or sibling-owned Goals are not disclosed.";
+var GetGoalSchema = z3.object({
+  goalId: z3.string().uuid(),
+  /** Every entry in full. Without it the read carries the person's words, open questions and your
+   *  newest entry, and counts what it left out (`apps/api/src/goal/collapse.ts`). */
+  history: z3.boolean().optional()
+}).strict();
+var GET_GOAL_DESCRIPTION = "Read one Goal without claiming it: its outcome, state, revision, progress, blockers, the conversation on it (each question with its options and what was decided), `next`, the one step to take, and `more`, where to read further. The conversation carries everything the person said, every open question and your newest entry; your older entries are left out and counted \u2014 history: true reads every entry in full. Another account's Goals, and another agent's Goal that is not below one of yours, are not disclosed.";
 var UPDATE_GOAL_DESCRIPTION = `Update an owned Goal at an exact revision. State, ownership, dependencies, children, progress, title, and review acknowledgement are explicit; stale revisions are rejected. title is the work's name in one to five words, as a person would refer to it out loud (it is spoken on a call and heads every list); null clears it. reviewed: true acknowledges new evidence and closes the Deliveries addressed to you on that Goal, never over an open decision. dueAt (an ISO instant, or null) makes the Goal wait until then; when it passes you are woken for it \u2014 use it for a promise to follow up later. state: done means the work was accomplished, and it can be reopened: when the person says it is not done ("it's not working"), set state: active on that same Goal instead of starting a new one; its parent reopens with it. cancelled is final. Returns the Goal as get_goal reads it, at its new revision.`;
 var CLAIM_GOAL_DESCRIPTION = "Claim the oldest runnable or review-pending Goal you own, or pass goalId to claim that Goal. Another agent's Goal that has gone quiet for 3 days (check_replies lists them as stalledOthers) is taken over when you claim it, and becomes yours to finish or cancel. Returns the Goal as get_goal reads it, and creates or renews the execution lease.";
 var CHECK_REPLIES_DESCRIPTION = "What is waiting for you: your open Deliveries (a request the user started toward you, a handoff), one row each with its Goals, how many decisions are still open, and the newest words in brief; `assigned`, your Goals nobody has started yet, however they became yours (claim_goal({goalId}) starts one); and `review`, your Goals with something new on them \u2014 the user's answers and notes are Entries on the Goal, not Deliveries. A pure read with no arguments: nothing is consumed, acknowledged or claimed by reading it, so call it on startup, after a long wait, or whenever you want to know what is outstanding. To act on one, claim its Goal (claim_goal) or reread a Delivery in full with contact({deliveryId}). Once you have acted on what arrived, update_goal with reviewed: true clears the Goal from `review` and closes the Deliveries addressed to you on it.";
@@ -2016,7 +2021,13 @@ var InboxItemSchema = z4.object({
      *  request Entry's author, as the same three facts the item's own `tokenId`/`name`/`voice`
      *  carry for the call's one agent, so the phone draws it with the same seed. Absent when the
      *  author is not an agent this account holds (unpaired since, or a person). */
-    agent: z4.object({ tokenId: z4.string(), name: z4.string(), voice: VoiceKeySchema.optional() }).optional()
+    agent: z4.object({ tokenId: z4.string(), name: z4.string(), voice: VoiceKeySchema.optional() }).optional(),
+    /** ITS OPTIONS, WHEN THERE IS SOMETHING TO SEE (owner, 2026-09-25: "Yes, add it"): the options
+     *  its need offers, exactly as its own card carries them, present only when one of them has a
+     *  preview (`html` or `image`). The call screen opens them from the agenda row, so a preview is
+     *  never re-sent as a second card to be seen mid-call. Words-only options are absent — the bot
+     *  says those, and the list stays small (an `html` is up to 16 KB). */
+    options: z4.array(OptionSchema).optional()
   })).optional(),
   visuals: z4.array(VisualSchema).optional(),
   /** The connected agent's name (the single pairing name — user-typed, or the
@@ -2412,7 +2423,19 @@ var QueueItemSchema = z4.object({
   /** When its owner last SAID something about it (`goals.last_progress_at`, written by every
    *  `update_goal` that changes `progress`). `updatedAt` moves for reasons nobody chose — a
    *  state recomputed, a review flag — so it cannot tell work in hand from work gone quiet. */
-  lastProgressAt: z4.string().nullable().optional()
+  lastProgressAt: z4.string().nullable().optional(),
+  /** THE GOAL'S NEWEST WORD, FROM EITHER SIDE (owner, 2026-09-27): the newest Entry on it, of any
+   *  kind — what the person added ("Add to this"), their reply, the agent's ask or its progress
+   *  note. A progress note is an Entry, so this is already the newer of the two: the person's note
+   *  shows the moment it is written, and the agent's reply or next note replaces it by being newer.
+   *  `said` is bounded to 280 characters server-side (a line, not the conversation). Null when the
+   *  Goal carries no readable Entry; optional, so hand-built queues need not spell it. */
+  latest: z4.object({
+    from: z4.enum(["person", "agent"]),
+    said: z4.string(),
+    at: z4.string(),
+    entryId: z4.string()
+  }).nullable().optional()
 });
 var COLD_AFTER_MS = 3 * 24 * 60 * 60 * 1e3;
 var NoteSourceSchema = z4.enum(["app", "call"]);
@@ -2590,6 +2613,104 @@ var NotificationFeedbackKindSchema = z4.enum([
   "other"
   // anything else — the note carries it.
 ]);
+var SlimOptionSchema = OptionSchema.omit({ html: true });
+var QuestionRowSchema = z4.object({
+  /** The card's id (`deliveryId:needId`, or `deliveryId:entryId` for an update), as the inbox mints it. */
+  id: z4.string(),
+  deliveryId: z4.string(),
+  entryId: z4.string(),
+  /** The decision it waits on; null for an update, which asks nothing. */
+  needId: z4.string().nullable(),
+  goalIds: z4.array(z4.string()),
+  /** The name of the work it is about, when the read could word it. */
+  goalTitle: z4.string().optional(),
+  tokenId: z4.string().optional(),
+  name: z4.string(),
+  title: z4.string(),
+  body: z4.string(),
+  select: z4.enum(["one", "many", "rank", "confirm", "text"]),
+  options: z4.array(SlimOptionSchema),
+  hasPreview: z4.boolean(),
+  blocking: z4.boolean(),
+  askedAt: z4.string().datetime(),
+  ring: InboxItemSchema.shape.ring,
+  onCall: z4.literal(true).optional(),
+  sealed: z4.boolean()
+});
+var WorkStateSchema = z4.enum(["ready", "active", "waiting", "done", "cancelled"]);
+var WorkRowSchema = z4.object({
+  id: z4.string(),
+  parentId: z4.string().nullable(),
+  title: z4.string(),
+  /** Straight off the Goal. */
+  state: WorkStateSchema,
+  owner: z4.string().nullable(),
+  revision: z4.number().int(),
+  /** Open questions on it, counted to 100. */
+  waiting: z4.number().int(),
+  /** Held by a gate on work that is not done. */
+  blocked: z4.boolean(),
+  lastProgressAt: z4.string().datetime().nullable(),
+  /** The line written for its newest progress note, else that note's first words. */
+  line: z4.string().nullable(),
+  /** Work directly under it, counted to 100; the list carries up to 12 of them. */
+  children: z4.number().int(),
+  createdAt: z4.string().datetime(),
+  updatedAt: z4.string().datetime(),
+  /** When anything at or under it last moved — the order the list is in. */
+  activeAt: z4.string().datetime(),
+  /** A sealed outcome has no title here; the work's page opens it. */
+  sealed: z4.boolean()
+});
+var ComputerRowSchema = ConnectionSummarySchema.omit({ activity: true });
+var AgentRowSchema = ComputerRowSchema.extend({
+  /** Open questions it is asking the person, over every open card; null when that read failed. */
+  asking: z4.number().int().nullable(),
+  oldestAskAt: z4.string().datetime().nullable(),
+  /** Up to three of the live Goals it holds, oldest first (the order it picks them up), and how
+   *  many in all among the account's 200 most recently active agent-held live Goals
+   *  (`agent_holds`); null when that read failed. */
+  holds: z4.array(z4.object({ id: z4.string(), title: z4.string() })).nullable(),
+  held: z4.number().int().nullable(),
+  /** The earliest instant any Goal it holds went quiet, by the one rule (`coldSince`); null
+   *  while none has, or when that read failed. */
+  cold: z4.string().datetime().nullable(),
+  /** The newest line of its working log, and when the harness saw it. */
+  line: z4.string().nullable(),
+  lineAt: z4.string().datetime().nullable()
+});
+var SnapshotSchema = z4.object({
+  /** The API's clock, taken before the first read: what a later delta will start from. */
+  at: z4.string().datetime(),
+  questions: z4.object({
+    /** The newest 30 open cards, questions before updates. */
+    items: z4.array(QuestionRowSchema),
+    /** Every open question, and apart from them every update, and what was put off. */
+    total: z4.number().int(),
+    updates: z4.number().int(),
+    putOff: z4.number().int()
+  }).nullable(),
+  agents: z4.object({
+    /** Up to 60, most recently seen first. */
+    items: z4.array(AgentRowSchema),
+    more: z4.boolean()
+  }).nullable(),
+  work: z4.object({
+    /** The 60 most recently active roots, each followed by up to 12 children; 240 rows at most. */
+    items: z4.array(WorkRowSchema),
+    /** How much work is behind each of the Work tab's four filters, each counted to 100, read with
+     *  the rows. `work_list` (20260928023533) owns the predicates: Live is `ready`, `active` or
+     *  `waiting`; Waiting on you is live work with an open question or an unmet gate; Not started
+     *  is `ready`; Done is `done` or `cancelled`. */
+    counts: z4.object({ live: z4.number().int(), waiting: z4.number().int(), notStarted: z4.number().int(), done: z4.number().int() })
+  }).nullable(),
+  you: z4.object({
+    settings: UserSettingsSchema,
+    callable: z4.boolean(),
+    /** Up to 20 paired computers; null when the roster read failed. */
+    computers: z4.array(ComputerRowSchema).nullable()
+  }).nullable()
+});
 function sessionSlot(sessionId2) {
   const id = sessionId2 ?? sessionId();
   return `session:${id.slice(0, 8)}`;
@@ -2757,9 +2878,9 @@ async function claimGoal(goalId, opts = {}) {
   if (!res.ok) await fail("claim_goal", res);
   return await res.json();
 }
-async function getGoal(goalId, opts = {}) {
+async function getGoal(goalId, opts = {}, read = {}) {
   const token = authToken(opts.token) ?? "";
-  const res = ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/goals/${encodeURIComponent(goalId)}`, {
+  const res = ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/goals/${encodeURIComponent(goalId)}${read.history ? "?history=1" : ""}`, {
     method: "GET",
     headers: { authorization: `Bearer ${token}`, "x-paigy-model": "goal-entry-v1" }
   }));
@@ -2793,13 +2914,27 @@ async function whoAmI(opts = {}) {
     return null;
   }
 }
+var NameTakenError = class extends Error {
+  code = "agent_name_taken";
+};
 async function setIdentity(patch, opts = {}) {
   const res = ensureAuthed(await reach(`${BACKEND_URL}/api/identity`, {
     method: "PATCH",
     headers: { "content-type": "application/json", authorization: `Bearer ${authToken(opts.token)}` },
     body: JSON.stringify(patch)
   }));
-  if (!res.ok) throw new Error(`set_identity failed: ${res.status} ${await res.text()}`);
+  if (!res.ok) {
+    const text = await res.text();
+    const refusal = (() => {
+      try {
+        return JSON.parse(text);
+      } catch {
+        return null;
+      }
+    })();
+    if (res.status === 409 && refusal?.error === "agent_name_taken" && refusal.message) throw new NameTakenError(refusal.message);
+    throw new Error(`set_identity failed: ${res.status} ${text}`);
+  }
   return await res.json();
 }
 async function claimSessions(opts = {}) {
@@ -3008,38 +3143,53 @@ function decided(result) {
       return void 0;
   }
 }
+var handle = (entryId) => entryId.slice(0, 8);
 function conversation(e) {
   const answers = new Map((e.answers ?? []).map((a) => [a.decisionNeedId, a]));
+  const shown = new Set((e.entries ?? []).map((entry) => entry.entryId));
+  const repliedTo = new Set((e.entries ?? []).flatMap((entry) => entry.aboutId && shown.has(entry.aboutId) ? [entry.aboutId] : []));
   return (e.entries ?? []).map((entry) => {
     const sealed = !!entry.content && "sealed" in entry.content;
     const plain = entry.content && "plain" in entry.content ? entry.content.plain : null;
     const options = plain && typeof plain === "object" && Array.isArray(plain.options) ? plain.options.map((o) => o.label).filter((l) => typeof l === "string") : [];
     const need = (e.decisionNeeds ?? []).find((n) => n.requestEntryId === entry.entryId);
     const answer = need ? answers.get(need.decisionNeedId) : void 0;
-    const answered = answer ? decided(answer.result) : void 0;
+    const decision = answer ? decided(answer.result) : void 0;
     return compact({
-      id: entry.entryId,
+      id: repliedTo.has(entry.entryId) ? handle(entry.entryId) : void 0,
       from: who(entry.authorParticipant),
       at: at(entry.createdAt),
       said: sealed ? "[encrypted]" : entryWords(entry).trim(),
-      re: entry.aboutId ?? void 0,
+      re: entry.aboutId && shown.has(entry.aboutId) ? handle(entry.aboutId) : void 0,
       options,
-      decision: need ? compact({ id: need.decisionNeedId, state: need.state, answer: answered }) : void 0
+      decision: need ? compact({ state: need.state, answer: decision }) : void 0
     });
   });
 }
+function more(g) {
+  const earlier = g.earlier && g.earlier.omitted + g.earlier.shortened ? `${[g.earlier.omitted ? `${g.earlier.omitted} earlier entries left out` : "", g.earlier.shortened ? `${g.earlier.shortened} shortened to their headline` : ""].filter(Boolean).join(", ")}: get_goal({ goalId: "${g.goalId}", history: true }) reads every one in full.` : null;
+  return [
+    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()."
+  ].filter((line) => !!line);
+}
 function goalView(g) {
   if (!g.goalId) return compact({ state: g.state, next: g.message });
+  const lines2 = conversation(g);
+  const newest = [...lines2].reverse().find((l) => l.from !== "person");
   return compact({
     goalId: g.goalId,
     revision: g.revision,
     state: g.state,
     outcome: g.outcome,
-    progress: g.progress,
+    progress: g.progress && g.progress.trim() !== newest?.said ? g.progress : void 0,
     reviewPending: g.reviewPending || void 0,
     owner: g.ownerParticipant,
     parentGoalId: g.parentGoalId,
-    childGoalIds: g.childGoalIds,
+    // Every child is in the subtree below, with its goalId: listed again, it was said twice.
+    childGoalIds: g.subtree?.length ? void 0 : g.childGoalIds,
     // EVERYTHING BELOW, read through this Goal (umbrella reads): one line per Goal, indented by
     // depth, then each question with its answer — so an agent that asked through an umbrella
     // reads every answer in one call, whoever owns the child it landed on.
@@ -3051,8 +3201,9 @@ function goalView(g) {
     blockedBy: g.blockedDependencyGoalIds,
     dueAt: g.dueAt,
     leaseExpiresAt: g.leaseExpiresAt,
-    conversation: conversation(g),
-    next: g.message
+    conversation: lines2,
+    next: g.message,
+    more: more(g)
   });
 }
 function deliveryView(d) {
@@ -3089,6 +3240,10 @@ function repliesView(r) {
     // 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 } : {},
@@ -3098,11 +3253,13 @@ function repliesView(r) {
     // OTHER AGENTS' STALLED WORK (owner, 2026-09-23): any agent may take it over and close it.
     ...others.length ? { stalledOthers: others } : {},
     next: [
-      deliveries.length || review.length || assigned.length ? "Act on a Goal with claim_goal; reread one Delivery in full with contact({deliveryId})." : "Nothing is waiting.",
+      deliveries.length || r.claimable || review.length || assigned.length ? "Act on a Goal with claim_goal; reread one Delivery in full with contact({deliveryId})." : "Nothing is waiting.",
       ...assigned.length ? [`${assigned.length} of your Goals are assigned to you and not started (assigned): claim_goal({goalId}) to start one.`] : [],
       ...review.length ? [`${review.length} of your Goals have something new (review): read each with claim_goal or get_goal, then update_goal with reviewed: true.`] : [],
       ...stalled.length ? [`${stalled.length} of your Goals have had no progress for 3 days: update_goal each with progress, finish it, or cancel it.`] : [],
-      ...others.length ? [`${others.length} of other agents' Goals have gone quiet for 3 days: claim_goal({goalId}) takes one over, then finish or cancel it with update_goal.`] : []
+      ...others.length ? [`${others.length} of other agents' Goals have gone quiet for 3 days: claim_goal({goalId}) takes one over, then finish or cancel it with update_goal.`] : [],
+      // No name of its own (#2525): the API's ask, verbatim.
+      ...r.unnamed ? [r.unnamed] : []
     ].join(" ")
   };
 }
@@ -3126,8 +3283,8 @@ async function runTool(name, args, opts) {
       return goalView(await claimGoal(goalId, client));
     }
     case "get_goal": {
-      const { goalId } = GetGoalSchema.parse(input);
-      return goalView(await getGoal(goalId, client));
+      const { goalId, history } = GetGoalSchema.parse(input);
+      return goalView(await getGoal(goalId, client, { history }));
     }
     case "update_goal": {
       const { goalId, ...body } = UpdateGoalToolSchema.parse(input);
@@ -3352,6 +3509,7 @@ export {
   AWAIT_WINDOW_MS,
   hatch,
   whoAmI,
+  NameTakenError,
   setIdentity,
   claimSessions,
   heartbeat,

package/dist/{dist-PJLF3B27.js → dist-GJOOJ4FR.js}

@@ -6,6 +6,7 @@ import {
   BACKEND_URL,
   KEY_PATH,
   NETWORK_MSG,
+  NameTakenError,
   NotifyRequestSchema,
   PROTO,
   TOKEN_PATH,
@@ -52,7 +53,7 @@ import {
   updateGoal,
   updateSlot,
   whoAmI
-} from "./chunk-V5AQASR7.js";
+} from "./chunk-VYWIPFEY.js";
 export {
   AGENT_TOOLS,
   AGENT_TOOL_NAMES,
@@ -61,6 +62,7 @@ export {
   BACKEND_URL,
   KEY_PATH,
   NETWORK_MSG,
+  NameTakenError,
   NotifyRequestSchema,
   PROTO,
   TOKEN_PATH,

package/dist/enable.js

@@ -3,9 +3,9 @@ import {
   PAIGY_TOOL_IDS,
   enablePaigyTools,
   installSessionListening
-} from "./chunk-7VLZIOLF.js";
-import "./chunk-MWHYYLCE.js";
-import "./chunk-V5AQASR7.js";
+} from "./chunk-76ILN3YV.js";
+import "./chunk-HGXXGOGG.js";
+import "./chunk-VYWIPFEY.js";
 
 // src/enable.ts
 function main() {

package/dist/index.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 import {
   clearPairing,
+  identify,
   joinBackgroundPair,
   resolvePairing,
   startPairing,
   suggestedAgentName
-} from "./chunk-UIZLBPRG.js";
+} from "./chunk-TRMYDJ5H.js";
 import {
   ENABLE_COMMAND,
   OnboardSchema,
@@ -14,11 +15,11 @@ import {
   SERVER_INSTRUCTIONS,
   TOOLS,
   paigyToolsAllowlisted
-} from "./chunk-7VLZIOLF.js";
+} from "./chunk-76ILN3YV.js";
 import {
   decideListen,
   listenerAlive
-} from "./chunk-MWHYYLCE.js";
+} from "./chunk-HGXXGOGG.js";
 import {
   clearSurface,
   writeSurface
@@ -36,10 +37,9 @@ import {
   runTool,
   saveToken,
   sessionId,
-  setIdentity,
   slotName,
   whoAmI
-} from "./chunk-V5AQASR7.js";
+} from "./chunk-VYWIPFEY.js";
 
 // src/index.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -177,7 +177,7 @@ async function hatchUnderDevice(name, voice) {
     const minted = await hatch(name ?? suggestedAgentName2() ?? "Agent", voice ?? null);
     const dt = { ok: true, access_token: minted.token, name: minted.name, device: null };
     saveToken(dt);
-    return dt;
+    return minted.message ? { ...dt, message: minted.message } : dt;
   } catch (e) {
     return { why: "credential-rejected", detail: String(e?.message ?? e).slice(0, 200) };
   } finally {
@@ -191,7 +191,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. " + (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 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 }.`)
     );
     miss = dt;
   }
@@ -246,24 +246,16 @@ async function handleTool(request, signal) {
       const slot = agentName();
       const secret = readToken();
       if (secret) {
-        let who = await whoAmI().catch(() => null);
+        const who = await whoAmI().catch(() => null);
         if (who) {
-          let renamed = false;
-          if (name || voice) {
-            try {
-              who = await setIdentity({ ...name ? { name } : {}, ...voice ? { voice } : {} });
-              renamed = true;
-            } catch {
-            }
-          }
+          const me = await identify(who, { ...name ? { name } : {}, ...voice ? { voice } : {} });
           const allowlisted = paigyToolsAllowlisted(scope ?? "user");
-          const display = who?.name ?? slotName(slot) ?? slot;
           return {
             content: [{ type: "text", text: JSON.stringify({
               status: "ready",
               slot,
-              name: display,
-              voice: who?.voice ?? null,
+              name: me.name,
+              voice: me.voice,
               tools_allowlisted: allowlisted,
               ...allowlisted ? {} : {
                 enable_tool_ids: PAIGY_TOOL_IDS,
@@ -277,7 +269,7 @@ async function handleTool(request, signal) {
                 rename: "Call onboard again with { name } (and optionally { voice }) to change it.",
                 unpair: "Call the `unpair` tool to disconnect this agent from the account."
               },
-              message: renamed ? `Renamed \u2014 this agent is "${display}" now.` : `Already set up as "${display}". Ask the user if they want to rename it or unpair; otherwise carry on.`
+              message: me.message
             }) }]
           };
         }

package/dist/listen.js

@@ -3,7 +3,7 @@ import {
   entryWords,
   removeListenMark,
   writeListenMark
-} from "./chunk-MWHYYLCE.js";
+} from "./chunk-HGXXGOGG.js";
 import {
   agentName,
   checkReplies,
@@ -11,7 +11,7 @@ import {
   getGoal,
   slotName,
   subscribeWake
-} from "./chunk-V5AQASR7.js";
+} from "./chunk-VYWIPFEY.js";
 
 // src/listen.ts
 import { spawn } from "child_process";

package/dist/onboard.js

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

package/dist/slot.js

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

package/dist/stalled.js

@@ -4,26 +4,33 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
-function stopReply(stalled) {
+function agentFlag(argv) {
+  const inline = argv.find((arg) => arg.startsWith("--agent="));
+  if (inline) return inline.slice("--agent=".length) || null;
+  const at = argv.indexOf("--agent");
+  if (at === -1) return null;
+  return argv[at + 1] ?? null;
+}
+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` : "";
-  return {
-    decision: "block",
-    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, finish it, or cancel it.`;
+  return event === "AfterAgent" ? { decision: "block", reason, systemMessage: reason } : { decision: "block", reason };
 }
 async function main() {
   const input = JSON.parse(readFileSync(0, "utf8") || "{}");
   if (input.stop_hook_active) return;
   const session = input.session_id ?? "";
   if (session) process.env.PAIGY_SESSION_ID = session;
+  const slot = agentFlag(process.argv);
+  if (slot && !process.env.PAIGY_AGENT) process.env.PAIGY_AGENT = slot;
   const day = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const dir = join(homedir(), ".paigy", "stalled-reminded");
   const mark = join(dir, `${session || "session"}-${day}`);
   if (existsSync(mark)) return;
-  const { checkReplies } = await import("./dist-PJLF3B27.js");
-  const reply = stopReply((await checkReplies()).stalled ?? []);
+  const { checkReplies } = await import("./dist-GJOOJ4FR.js");
+  const reply = stopReply((await checkReplies()).stalled ?? [], input.hook_event_name ?? "Stop");
   if (!reply) return;
   mkdirSync(dir, { recursive: true });
   writeFileSync(mark, "");
@@ -31,5 +38,6 @@ async function main() {
 }
 if (process.argv[1] && /stalled(\.[jt]s)?$/.test(process.argv[1])) main().catch(() => void 0);
 export {
+  agentFlag,
   stopReply
 };

package/dist/statusline.js

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

package/package.json

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