pendingyou 0.18.0 → 0.20.0

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## 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
+  last message had something for you and the turn posted no card, so a closing line like “Two cards are waiting on
+  you: CLI 0.18.0 (publish it) and the Herdr check (does the amber title show in the sidebar?).” was asked to go on,
+  and Claude Code showed each of those as a “Stop hook error”. Now:
+  - A recap counts as posted, for what it says: a sentence that says its cards wait on you (“Two cards are waiting on
+    you: …”, “the card is still open for your answer”, “both cards are in your queue”, “… (both cards).”), or a heading
+    that does, or names your cards (“**Cards waiting for you:**”, “Your open cards:”), with the list under it.
+    Anything else in the message for you is checked as before, so a new ask beside a recap still goes on a card. Cards
+    that aren't said to wait on you (“the two cards line up”, “add a credit card”) are no recap.
+  - So does a card said to be coming, or one an item already is: “a card is coming”, “there'll be a card”, “I'll
+    create a card”, “that one is already a card”, as “I'll send you a card” and “it's on a card” already did.
+  - Anything else for you, in a message that talks about cards (not a credit card, a SIM card or a card number), is
+    taken as a recap while this folder has a card waiting on you: one request (this folder's open cards, the one the
+    next-message hook makes), made only for such a message and given up after 1.5 seconds. None open: the agent is
+    asked to go on, as before. A permission prompt's card doesn't count. When Pending You can't say (offline, slow, an
+    older server), the turn ends.
+  - Everything else is as before: an ask to type something here, a question handed to the agent, once a turn at most,
+    quiet when not signed in, silent on any error, the 3-second deadline. Codex's, OpenCode's and Pi's Stop checks do
+    the same, each asking for its own app's cards.
+- Hooks run the copy `init` installed: run `npx pendingyou@latest init` once to switch.
+
 ## 0.18.0 (2026-10-05)
 
 - Presence says which terminal: in a Herdr pane (`HERDR_ENV=1` with `HERDR_BIN_PATH` and `HERDR_PANE_ID`), every

package/README.md

@@ -205,6 +205,13 @@ can", "waiting on you" and the like; or a list under a heading like "Your part",
 you" or "Left for you". It lets the turn end when the message says nothing needs a card ("No card needed.", "Nothing
 needs your attention.", "There's nothing waiting on you.").
 
+Since 0.19.0 it also lets the turn end on a recap of cards already waiting on you. A sentence that says its cards wait
+on you ("Two cards are waiting on you: …", "… (both cards).") covers what it asks, and so does a heading that does
+("Cards waiting for you:") over its list; anything else for you in the message is checked as before, so a new ask
+beside a recap still goes on a card. And anything else for you, in a message that talks about cards, is taken as a
+recap while this folder has a card waiting on you: only such a message costs a request (this folder's open cards,
+given up after 1.5 seconds), and when Pending You can't say, the turn ends.
+
 Since 0.9.0 it also catches a message asking you to type or reply something in Claude Code's own chat ("Reply “yes,
 erase disk12” here", "To confirm, type `yes`", "Confirm here"). Some steps an agent takes only on your own words in
 its conversation, never on a card answer; that's fine, but then a card has to send you there. Unless a card posted in
@@ -342,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/stopcheck.js

@@ -5,17 +5,35 @@ import { APP_NAMES, DEFAULT_APP } from "./apps/ids.js";
 import { asksToTypeHere, cardFits, confirmReason, sessionLink } from "./confirm.js";
 import { readCredential } from "./credentials.js";
 import { isHandedWake } from "./format.js";
-import { isPromptApp, settlePrompts, subagentsRunning } from "./permission.js";
+import { isPermissionCard, isPromptApp, settlePrompts, subagentsRunning } from "./permission.js";
 import { folderForms } from "./pickup.js";
 export const READ_CAP = 4 * 1024 * 1024;
 const CHUNK = 64 * 1024;
 export const STOP_REASON = 'Items for your person are in chat but not in Pending You: post them as cards (ask in both places), or say they don’t need one.';
 export const DELEGATED_REASON = 'Your person handed you that question to answer, not to ask them back: answer_delegated if you know, or hand_back with what you checked, unless you already did. Never post it as a card of your own.';
 const POSTING_TOOL = /^mcp__.+__(post_request|update_request|reply_in_thread|answer_delegated|hand_back)$/;
-const OPEN_TIME_BOX_MS = 1500;
+export const OPEN_TIME_BOX_MS = 1500;
 const OPEN_CARDS = 5;
 const CARD_TEXT = 20_000;
-const SAYS_POSTED = /\b(posted|put|added|raised|filed)\b[^.\n]{0,60}\b(cards?|pending ?you)\b|\bon (a|the|its|their|your|that|this) cards?\b|\b(in|to|through|via|on) pending ?you\b|\bpending ?you cards?\b|\b(i|we|you)(?:(?:'|’)ll| will)\s+(?:\w+\s+)?(post|send|put|add|raise|file|get|see|find)\b[^.\n]{0,40}\bcards?\b/i;
+const SAYS_POSTED = new RegExp([
+    String.raw `\b(posted|put|added|raised|filed)\b[^.\n]{0,60}\b(cards?|pending ?you)\b`,
+    String.raw `\bon (a|the|its|their|your|that|this) cards?\b`,
+    String.raw `\b(in|to|through|via|on) pending ?you\b`,
+    String.raw `\bpending ?you cards?\b`,
+    String.raw `\b(i|we|you)(?:(?:'|’)ll| will)\s+(?:\w+\s+)?(post|send|put|add|raise|file|get|see|find|make|create|open)\b[^.\n]{0,40}\bcards?\b`,
+    String.raw `\balready (?:a |on (?:a )?)?cards?\b`,
+    String.raw `\bcards? (?:is|are|will be) (?:coming|on (?:its|their|the) way)\b(?! (?:together|along))`,
+    String.raw `\bcards? (?:will|to) follow\b`,
+    String.raw `\bthere(?:(?:'|’)ll| will) be (?:a |another |one )?cards?\b`,
+].join('|'), 'i');
+const RECAP = new RegExp([
+    String.raw `\bcards?\b[^.!?\n]{0,40}?\b(?:(?:waiting|pending|open|parked|queued|left)\b[^.!?\n]{0,20}?\b(?:on|for)\s+your?|in\s+your\s+queue)\b`,
+    String.raw `\b(?:waiting|pending|parked)\s+(?:on|for)\s+you\b[^.!?\n]{0,30}?\b(?:as|in)\s+(?:(?:a|two|both|three|its|their|the|separate)\s+)?cards?\b`,
+    String.raw `\((?:(?:both|all|two|three|each)\s+)?(?:(?:are|is|on|as)\s+)?(?:a\s+|(?:its|their)\s+own\s+)?cards?(?:\s+(?:already|too))?\)`,
+].join('|'), 'i');
+const CARDS_HEADING = /\b(?:your|open|pending|waiting)\s+(?:(?:open|pending|waiting)\s+)?cards\b/i;
+const SENTENCE_END = /(?<=[.!?])\s+/;
+const OTHER_CARDS = /\b(?:credit|debit|payment|gift|sim|sd|business|graphics|video|sound|network|memory|smart)\s+cards?\b|\bcards?\s+(?:numbers?|readers?|details|holders?)\b/gi;
 const STEPS_FOR_THEM = /\b(you(?:'|’)ll need to|you will need to|you(?:'|’)ll have to|you will have to|your (?:next )?steps?\b|can you|could you|would you mind|please (?:run|confirm|approve|check|add|set|sign|create|open|paste|reply|send|choose|pick|decide|let me know)|in your terminal|only you can|(?<!\b(?:no|nothing|none|not)\b[^.,;:!?\n]{0,40})waiting (?:on|for) you|(?<!\bif (?:it|he|she|they|that|this|anything|something|someone|anyone|one) )needs? you to|over to you|parked for you|when you(?:'|’)re ready|up to you|your call\b|is yours\b|say the word|let me know (?:which|whether)|tell me (?:which|whether)|needs? your (?:ok|okay|approval|decision|sign-?off|go-ahead))/i;
 const SAYS_NO_CARD = /\bno (?:new |more |further )?cards? (?:is |are )?(?:needed|necessary|required)\b|\b(?:doesn(?:'|’)t|don(?:'|’)t|does not|do not|won(?:'|’)t|will not) need (?:a |any )?(?:new )?cards?\b|\bnothing (?:here |else |more |now )?(?:needs|requires) your (?:attention|input|action|answer)\b|\b(?:nothing|no cards?)\b[^.,;:!?\n]{0,40}\b(?:waiting|pending) (?:on|for) you\b/i;
 const FOR_THEM_HEADING = /\b(your part|your steps?|your to-?dos?|your turn|your call|for you|waiting on you|left for you|parked for you|needs you|over to you|what you need to do|you(?:'|’)ll need)\b/i;
@@ -47,8 +65,7 @@ function headingOf(line) {
         return null;
     return /^\s*#/.test(line) || bare.endsWith(':') || /^\s*\*\*.+\*\*\s*$/.test(line) ? bare : null;
 }
-export function itemsForPerson(text) {
-    const plain = plainText(text);
+function itemsIn(plain) {
     const lines = plain.split('\n');
     for (let index = 0; index < lines.length; index++) {
         const heading = headingOf(lines[index]);
@@ -65,8 +82,50 @@ export function itemsForPerson(text) {
             return 'question';
     return null;
 }
+export function itemsForPerson(text) {
+    return itemsIn(plainText(text));
+}
+function listEnd(lines, index) {
+    let end = index;
+    for (let next = index + 1; next < lines.length; next++) {
+        const line = lines[next];
+        if (!line.trim()) {
+            if (end === index && next - index >= 3)
+                return index;
+        }
+        else if (LIST_ITEM.test(line) || (end > index && /^\s/.test(line)))
+            end = next;
+        else
+            break;
+    }
+    return end;
+}
+function withoutRecaps(plain) {
+    const lines = plain.split('\n');
+    const kept = [];
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        const heading = headingOf(line);
+        if (heading && (RECAP.test(heading) || CARDS_HEADING.test(heading))) {
+            const end = listEnd(lines, index);
+            if (end > index) {
+                index = end;
+                continue;
+            }
+        }
+        kept.push(line
+            .split(SENTENCE_END)
+            .filter((sentence) => !RECAP.test(sentence))
+            .join(' '));
+    }
+    return kept.join('\n');
+}
+export function itemsOutsideRecaps(text) {
+    return itemsIn(withoutRecaps(plainText(text)));
+}
 export const saysPosted = (text) => SAYS_POSTED.test(plainText(text));
 export const saysNoCard = (text) => SAYS_NO_CARD.test(plainText(text));
+export const mentionsCards = (text) => /\bcards?\b/i.test(plainText(text).replace(OTHER_CARDS, ''));
 function wordsIn(value, max = CARD_TEXT) {
     const found = [];
     let left = max;
@@ -306,18 +365,23 @@ export async function stopcheck(io, options) {
                 return 0;
             return asksToTypeHere(text) || itemsForPerson(text) ? block(DELEGATED_REASON) : 0;
         }
+        const cwd = typeof input.cwd === 'string' && input.cwd ? input.cwd : io.cwd;
         const ask = asksToTypeHere(text);
         if (ask) {
             if (saysNoCard(text) || turn.cards.some((card) => cardFits(card, ask.words, 'posted')))
                 return 0;
-            const cwd = typeof input.cwd === 'string' && input.cwd ? input.cwd : io.cwd;
             const open = await openTitles(io, options.origin, cwd, app);
             if (open ? open.some((title) => cardFits(title, ask.words, 'open')) : saysPosted(text))
                 return 0;
             return block(confirmReason(ask.words, sessionLink(io.env), APP_NAMES[app]));
         }
-        if (turn.posted || saysPosted(text) || saysNoCard(text) || !itemsForPerson(text))
+        if (turn.posted || saysPosted(text) || saysNoCard(text) || !itemsOutsideRecaps(text))
             return 0;
+        if (mentionsCards(text)) {
+            const open = await openTitles(io, options.origin, cwd, app);
+            if (open === null || open.some((title) => !isPermissionCard(title)))
+                return 0;
+        }
         return block(STOP_REASON);
     }
     catch {

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.18.0';
+export const VERSION = '0.20.0';

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

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