pendingyou 0.19.0 → 0.20.1

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 0.20.1 (2026-10-06)
+
+- An older answer is no longer hidden behind newer ones. The session-start and next-message hooks asked for a folder's
+  five newest answers and left out the ones already handed over, so a session with five newer answers it hadn't
+  acknowledged yet never heard an older one, even on the person's own message (seen 2026-10-06: two answers waited
+  over an hour). They now ask for 20 and hand over the newest five not handed over yet; the rest come with the next
+  message.
+- The wake mod (guide 2.33.1) makes room in a session's list of 50 cards with the answers its agent already heard,
+  never a card still waiting on you while there's one of those: a session that ran many agents lost its oldest open
+  cards, and their answers were never told.
+
+## 0.20.0 (2026-10-06)
+
+- “I’ll handle it”: a card you ended yourself in Pending You says so, and tells the agent to stand down. An answer can
+  now carry `handled`: `self` (you'll do it yourself) or `leave` (nobody does it), with or without your note, and its
+  words in `said` (“I’ll do it myself”, “Leave it”, then the note). Wherever the command line hands an answer over
+  (`hold`, the session-start and next-message hooks, the wake mod in Claude Code, and the listeners that wake Codex,
+  OpenCode and Pi), it says which instead of “Act on it”:
+  - `self`: don't act on it, don't draft or send anything for it, and don't follow up.
+  - `leave`: nobody does it, so an email or a task gets no reply and no follow-up, and nothing is archived or deleted
+    unless the person's rules say so.
+  - Either way: if the note asks for one thing, do just that; then `ack_answer` with an outcome like “Left to you”, and
+    never post it again. No “reply_in_thread with reopen” hint for these.
+  `watch` passes `handled` on with the rest of the request. An answer without it, from an older Pending You, reads as
+  before.
+- Hooks run the copy `init` installed: run `npx pendingyou@latest init` once to switch.
+
 ## 0.19.0 (2026-10-06)
 
 - The Stop check lets a turn end on a recap of cards already waiting on you. It asked the agent to go on whenever its

package/README.md

@@ -349,6 +349,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.
+
 **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
 allowed and the server has connected). When it isn't, it starts one turn once the session is idle: “Finish setting up

package/dist/apps/codex-wake.js

@@ -5,7 +5,7 @@ import { getJson, SignInNeeded, Unavailable } from "../api.js";
 import { DEFAULT_ORIGIN } from "../args.js";
 import { connectionMachine, readCredential } from "../credentials.js";
 import { configDir, readJson, withLock, writeWhole } from "../files.js";
-import { clip, delegatedOf, isClosed, noticeOf } from "../format.js";
+import { clip, delegatedOf, handledOf, isClosed, noticeOf } from "../format.js";
 import { chooseThread, goesBy, HANDED_FOR_MS, handedCard, handedMessage, namesAnotherComputer, } from "../handed.js";
 import { clearHerdr, herdrTarget, isUrgency, PANE_ID, reportCommand, writeHerdr, } from "../herdr.js";
 import { macName, tailscaleName } from "../remote.js";
@@ -399,6 +399,16 @@ function line(heard, card) {
         case 'resolved':
             return null;
         case 'answered':
+            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”`,
+                ];
+            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”`,
+                ];
             return [
                 `your person answered ${titled}`,
                 `call ${get}, act on their words, then ack_answer with its version and a one-line outcome`,
@@ -418,7 +428,7 @@ export function wakeMessage(ready) {
     });
     if (lines.length === 0)
         return null;
-    const asked = lines.some(({ heard }) => heard.turn === 'agent' && heard.status !== 'expired' && !noticeOf(heard));
+    const asked = lines.some(({ heard }) => heard.turn === 'agent' && heard.status !== 'expired' && !noticeOf(heard) && !handledOf(heard));
     const reopen = asked
         ? ' If they asked you something or you need more from them, reply_in_thread with reopen instead.'
         : '';

package/dist/format.js

@@ -7,6 +7,11 @@ export function noticeOf(heard) {
         return null;
     return { kind, from };
 }
+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' };
 export const HANDED_PREFIX = 'Pending You: your person handed you';
 export const HANDED_REPLY = 'on the question handed to you';
 export const HANDED_TALK_TODO = 'If you know now, answer_delegated with your answer and how you know; if you need more, reply_in_thread to “asker”; if it’s your person’s to decide, reply_in_thread with escalate true; if not, hand_back with what you checked.';
@@ -113,6 +118,14 @@ function describeNotice(heard, notice) {
         ...(cut ? [`(Cut short: get_request ${id} has all of it.)`] : []),
     ];
 }
+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' : '';
+    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.`;
+}
 export function describe(heard, again) {
     const id = heard.requestId;
     const delegated = delegatedOf(heard);
@@ -131,6 +144,16 @@ export function describe(heard, again) {
     const lines = [];
     switch (heard.status) {
         case 'answered': {
+            const handled = handledOf(heard);
+            if (handled) {
+                const answer = clip(heard.said ?? HANDLED_SAID[handled], 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}`);
+                if (wrote.length)
+                    lines.push(`They also wrote: ${wrote.join(' ')}`);
+                lines.push(standDown(heard, handled));
+                break;
+            }
             if (heard.answers?.length) {
                 lines.push(`Pending You: ${id} is answered, all ${heard.answers.length} questions.`, question);
                 for (const [index, each] of heard.answers.entries()) {

package/dist/pickup.js

@@ -13,6 +13,8 @@ import { announce, keepPresent } from "./presence.js";
 import { setupReminder } from "./setup.js";
 import { claimHanded, markHanded, momentOf, releaseHanded, wasHanded } from "./state.js";
 const TIME_BOX_MS = { pickup: 2500, handoff: 2000 };
+export const ANSWERS_ASKED = 20;
+export const ANSWERS_SHOWN = 5;
 export const REMINDER = 'Pending You: anything you need from your person also goes on a card.';
 export const OPEN_SHOWN = 3;
 export const OPEN_TITLE = 50;
@@ -152,7 +154,7 @@ export async function pickup(io, options, hook = { fallback: '' }) {
             await keepListening(io, origin, input.session);
         const query = new URLSearchParams([
             ...folderForms(cwd, io.home).map((form) => ['cwd', form]),
-            ['limit', '5'],
+            ['limit', String(ANSWERS_ASKED)],
             ...(mode === 'handoff' ? [['open', String(OPEN_SHOWN)]] : []),
             ['source', app],
         ]);
@@ -203,8 +205,10 @@ export async function pickup(io, options, hook = { fallback: '' }) {
             const delegated = delegatedOf(heard);
             if (await wasHanded(io, origin, heard.requestId, momentOf(heard)))
                 continue;
-            if (!delegated)
-                fresh.push(heard);
+            if (!delegated) {
+                if (fresh.length < ANSWERS_SHOWN)
+                    fresh.push(heard);
+            }
             else if (woke?.includes(`(${heard.requestId})`))
                 told.push(heard);
             else if (await takesHanded(io, context, heard, delegated))

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.19.0';
+export const VERSION = '0.20.1';

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

@@ -1,7 +1,7 @@
 {
   "name": "pendingyou-wake",
   "displayName": "Pending You",
-  "version": "2.32.0",
+  "version": "2.33.1",
   "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.32.0; send changes there.
+Generated from recordplane/pendingyou (packages/claude-plugin/src/wake) with Pending You’s guide 2.33.1; send changes there.

package/mod/hooks/wake.js

@@ -116,7 +116,15 @@ export function stateOf(output) {
     const version = count(output.version);
     if (!status || !turn || version === undefined)
         return null;
-    return { status, turn, version, cursor: typeof output.cursor === 'string' ? output.cursor : '' };
+    const given = isObject(output.answer) ? output.answer.handled : output.handled;
+    const handled = given === 'self' || given === 'leave' ? given : undefined;
+    return {
+        status,
+        turn,
+        version,
+        cursor: typeof output.cursor === 'string' ? output.cursor : '',
+        ...(handled ? { handled } : {}),
+    };
 }
 export const emptyBook = (now = 0) => ({ v: 1, updatedAt: now, cards: {} });
 export function readBook(value) {
@@ -160,12 +168,19 @@ export function readBook(value) {
         cards,
     };
 }
+const listening = (card) => {
+    const state = card.state;
+    if (!state || isWaitingOnYou(state))
+        return true;
+    const moment = momentOf(state);
+    return moment !== card.told && moment !== card.seen;
+};
 export function put(book, card) {
     const cards = { ...book.cards, [card.requestId]: card };
     const all = Object.values(cards);
     if (all.length > MAX_CARDS)
         for (const old of all
-            .sort((a, b) => a.changedAt - b.changedAt)
+            .sort((a, b) => Number(listening(a)) - Number(listening(b)) || a.changedAt - b.changedAt)
             .slice(0, all.length - MAX_CARDS))
             delete cards[old.requestId];
     return { ...book, cards };
@@ -368,6 +383,16 @@ function line(card) {
         case 'resolved':
             return [`${titled(card)} is already handled`, 'nothing to do'];
         case 'answered':
+            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”`,
+                ];
+            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”`,
+                ];
             return [
                 `your person answered ${titled(card)}`,
                 `call ${get}, act on their words, then ack_answer with its version and a one-line outcome`,
@@ -388,7 +413,8 @@ const capital = (sentence) => sentence.charAt(0).toUpperCase() + sentence.slice(
 export function wakeText(cards) {
     const asked = cards.some((card) => card.state?.turn === 'agent' &&
         !isClosed(card.state.status) &&
-        card.state.status !== 'delegated');
+        card.state.status !== 'delegated' &&
+        !card.state.handled);
     const reopen = asked
         ? ' If they asked you something or you need more from them, reply_in_thread with reopen instead.'
         : '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pendingyou",
-  "version": "0.19.0",
+  "version": "0.20.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",