pendingyou 0.30.0 → 0.31.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.31.1 (2026-10-08)
+
+- Your words on a card that's closed reach its assistant. "Write to …" (threads) writes on a thread's newest card even
+  after its assistant picked it up, withdrew it or ran its fallback. `hold`, the hooks and the wake now say "Pending
+  You: your person wrote to you on req_… after it closed.", quote your words, and tell the assistant to act on them,
+  then ack_answer with a one-line outcome (or reply_in_thread if you asked it something). Before, they said the card
+  was already handled and there was nothing to do. Servers that don't send `wrote` are heard as before.
+
+## 0.31.0 (2026-10-08)
+
+- “I’ll handle it” has one meaning (guide 2.45): the person will handle it themselves. `hold`, the hooks, the wake mod
+  and the Codex wake say so in Pending You's own words, “The person will handle this themselves. Close it out: take no
+  action on it, leave things as they are (an email stays in their inbox, untouched), and don’t follow up or ask
+  again.”, then to ack_answer with an outcome like “Left to you”. The app no longer offers “Leave it”; a server since
+  guide 2.45 sends an older one as the same. `leave` now means only a to-do's Skip: “your person won’t do it”, don't do
+  it for them or follow up, and pick it up with an outcome like “Skipped”. Older command lines still stand down on
+  both.
+
 ## 0.30.0 (2026-10-07)
 
 - This computer's own sign-ins (the connections `init` made for Claude Code, Codex, OpenCode and Pi) now last while

package/README.md

@@ -378,10 +378,11 @@ next message brings any answer with it too.
 When you're at the terminal, Claude Code asks you there and puts the same question in Pending You at once; the
 first answer wins. If you answer in the terminal, it withdraws the card and the hold ends by itself.
 
-**When you'll handle it yourself (0.20.0).** A card you end with “I’ll handle it” in Pending You (“I’ll do it myself”,
-or “Leave it”) reaches the agent the same ways, saying which: instead of acting on it, it's told to stand down (nothing
-done, drafted, sent or followed up for it; with “Leave it”, an email or a task gets no reply), to pick it up with
-`ack_answer` and an outcome like “Left to you”, and never to post it again.
+**When you'll handle it yourself (0.20.0; one meaning in 0.31.0).** A card you end with “I’ll handle it” in Pending
+You reaches the agent the same ways, in these words: “The person will handle this themselves. Close it out: take no
+action on it, leave things as they are (an email stays in their inbox, untouched), and don’t follow up or ask again.”
+Then it picks it up with `ack_answer` and an outcome like “Left to you”, and never posts it again. A to-do you Skip
+says you won't do it: the agent doesn't do it for you or follow up, and picks it up with an outcome like “Skipped”.
 
 **Finishing setup by itself (0.11.0).** In `init`'s copy of the mod, a few seconds after a session you're at opens
 (never `claude -p`), it asks Pending You whether Claude Code is set up here (`whoami`, once Pending You's tools are

package/dist/apps/codex-wake.js

@@ -414,12 +414,12 @@ function line(heard, card) {
             if (handledOf(heard) === 'self')
                 return [
                     `your person will handle ${titled} themselves`,
-                    `call ${get} to read it, don’t act on it, then ack_answer with its version and an outcome like “Left to you”`,
+                    `call ${get} to read it, then close it out: take no action on it, leave things as they are and don’t follow up; ack_answer with its version and an outcome like “Left to you”`,
                 ];
             if (handledOf(heard) === 'leave')
                 return [
-                    `your person said to leave ${titled}`,
-                    `call ${get} to read it, do nothing for it (no reply, no follow-up), then ack_answer with its version and an outcome like “Left it”`,
+                    `your person won’t do ${titled}`,
+                    `call ${get} to read it, then close it out: don’t do it for them and don’t follow up; ack_answer with its version and an outcome like “Skipped”`,
                 ];
             return [
                 `your person answered ${titled}`,

package/dist/format.js

@@ -12,7 +12,12 @@ export function handledOf(heard) {
     const given = heard.handled;
     return given === 'self' || given === 'leave' ? given : null;
 }
-const HANDLED_SAID = { self: 'I’ll do it myself', leave: 'Leave it' };
+const HANDLED_SAID = {
+    self: ['I’ll handle it', 'I’ll do it myself'],
+    leave: ['I won’t do it', 'Leave it'],
+};
+export const HANDLED_MEANS = 'The person will handle this themselves. Close it out: take no action on it, leave things as they are (an email stays in their inbox, untouched), and don’t follow up or ask again.';
+export const SKIPPED_MEANS = 'The person won’t do this to-do. Close it out: don’t do it for them, leave things as they are, and don’t follow up or ask again.';
 export const APPROVED_DRAFT_NOTICE = 'The approved words are in get_request’s answer.approvedDrafts: send them exactly.';
 export const approvesDraft = (heard) => heard.approvedDraft === true;
 export const HANDED_PREFIX = 'Pending You: your person handed you';
@@ -140,11 +145,12 @@ function describeNotice(heard, notice) {
 }
 function standDown(heard, handled) {
     const ack = `ack_answer with requestId ${heard.requestId}, name ${named(heard)}, expectedVersion ${heard.version}`;
-    const noted = Boolean(heard.said?.trim() && heard.said.trim() !== HANDLED_SAID[handled]);
-    const note = noted ? '; if their note asks you for one thing, do just that' : '';
+    const said = heard.said?.trim();
+    const noted = Boolean(said && !HANDLED_SAID[handled].includes(said));
+    const note = noted ? ' If their note asks you for one thing, do just that.' : '';
     return handled === 'self'
-        ? `Stand down: don’t act on it, don’t draft or send anything for it, and don’t follow up${note}. Then call ${ack} and an outcome like “Left to you”. Never post it again.`
-        : `Stand down: nobody does it, so an email or a task gets no reply and no follow-up, and nothing is archived or deleted unless their rules say so${note}. Then call ${ack} and an outcome like “Left it”. Never post it again.`;
+        ? `${HANDLED_MEANS}${note} Then call ${ack} and an outcome like “Left to you”. Never post it again.`
+        : `${SKIPPED_MEANS}${note} Then call ${ack} and an outcome like “Skipped”. Never post it again.`;
 }
 export function describe(heard, again) {
     const id = heard.requestId;
@@ -162,13 +168,19 @@ export function describe(heard, again) {
         return line;
     });
     const lines = [];
+    if (heard.wrote && heard.status !== 'answered' && isClosed(heard)) {
+        lines.push(`Pending You: your person wrote to you on ${id} after it closed.`, question, `They wrote: ${wrote.join(' ') || '(call get_request to read it)'}`, `Act on it, then call ack_answer with requestId ${id}, name ${named(heard)}, expectedVersion ${heard.version} and a one-line outcome (reply_in_thread instead if they asked you something).`);
+        if (cut)
+            lines.push(`(Cut short: get_request ${id} has all of it.)`);
+        return lines;
+    }
     switch (heard.status) {
         case 'answered': {
             const handled = handledOf(heard);
             if (handled) {
-                const answer = clip(heard.said ?? HANDLED_SAID[handled], MAX_ANSWER);
+                const answer = clip(heard.said ?? HANDLED_SAID[handled][0] ?? '', MAX_ANSWER);
                 cut ||= answer.cut;
-                lines.push(`Pending You: ${id} is answered: ${handled === 'self' ? 'your person will do it themselves' : 'your person said to leave it'}.`, question, `Answer: ${answer.text}`);
+                lines.push(`Pending You: ${id} is answered: ${handled === 'self' ? 'your person will handle it themselves' : 'your person won’t do it'}.`, question, `Answer: ${answer.text}`);
                 if (wrote.length)
                     lines.push(`They also wrote: ${wrote.join(' ')}`);
                 lines.push(standDown(heard, handled));

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.30.0';
+export const VERSION = '0.31.1';

package/mod/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "pendingyou-wake",
   "displayName": "Pending You",
-  "version": "2.44.1",
+  "version": "2.46.0",
   "description": "Wakes Claude Code when your person answers a Pending You card it posted, even while it sits idle. Installed by `npx pendingyou init`.",
   "author": {
     "name": "RecordPlane",

package/mod/README.md

@@ -4,4 +4,4 @@ The pendingyou command line’s copy of the Pending You plugin’s wake mod, for
 
 In each session it learns the cards the session posts to Pending You, checks them through the session’s own Pending You connection, and starts a turn when your person answers, writes back or a fallback comes due, or hands the session a question from another of their assistants (CLI 0.14.0), even while it sits idle. It answers `npx pendingyou hold` itself, so nothing waits in the background, and shows “2 waiting on you” under the prompt, after the plugin’s name. With the Pending You plugin installed too, only one copy acts.
 
-Generated from recordplane/pendingyou (packages/claude-plugin/src/wake) with Pending You’s guide 2.44.1; send changes there.
+Generated from recordplane/pendingyou (packages/claude-plugin/src/wake) with Pending You’s guide 2.46.0; send changes there.

package/mod/hooks/wake.js

@@ -391,12 +391,12 @@ function line(card) {
             if (state.handled === 'self')
                 return [
                     `your person will handle ${titled(card)} themselves`,
-                    `call ${get} to read it, don’t act on it, then ack_answer with its version and an outcome like “Left to you”`,
+                    `call ${get} to read it, then close it out: take no action on it, leave things as they are and don’t follow up; ack_answer with its version and an outcome like “Left to you”`,
                 ];
             if (state.handled === 'leave')
                 return [
-                    `your person said to leave ${titled(card)}`,
-                    `call ${get} to read it, do nothing for it (no reply, no follow-up), then ack_answer with its version and an outcome like “Left it”`,
+                    `your person won’t do ${titled(card)}`,
+                    `call ${get} to read it, then close it out: don’t do it for them and don’t follow up; ack_answer with its version and an outcome like “Skipped”`,
                 ];
             return [
                 `your person answered ${titled(card)}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pendingyou",
-  "version": "0.30.0",
+  "version": "0.31.1",
   "description": "Pending You for your coding agents: one command sets up Claude Code, Codex, OpenCode and Pi to ask you through Pending You and hear your answers, even while they sit idle.",
   "license": "Apache-2.0",
   "homepage": "https://www.pendingyou.com",