pendingyou 0.36.0 → 0.37.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 0.37.0 (2026-10-22)
+
+- A step your agent hands you now goes on a card (guide 2.55). When its last message gives you a step to do now (“Go:
+  approve it now”, “you can merge it now”, “now open the run link”, “go ahead and approve it”) and no card from that
+  turn has it, the check at the end of its turn asks it once to put it on a card, even while an older card of its waits
+  on you. A card from the turn has it when it holds the message’s link, or, without one, two of its words. Not a step
+  now: the agent's own act (“I'll go ahead and merge it now”), a question whether it should, an offer (“whenever you
+  like”), a look (“now open … to see it”), what a page or a step says, or a heading such as “Open now:”. Patterns
+  only, on your computer; it asks Pending You nothing. Run `npx pendingyou@latest init` to switch: the hooks don’t
+  change, so Codex keeps trusting them.
+
+## 0.36.1 (2026-10-20)
+
+- Fixed: when you replied on an answer card, the Claude Code session that posted the answer wasn't woken: the wake mod
+  didn't know `post_answer`, so your reply reached it only with your next message, or at the next session start. Now
+  the mod follows a session's answers as it does its questions, and your reply starts a turn even while the session
+  sits idle. Got it, reading the answer in the chat, a newer answer replacing it, or the agent withdrawing it wakes
+  nothing, and the mod forgets the answer (after one more look when you mark it Got it, since you can take that back
+  for a few seconds).
+- An answer asks you nothing, so it's no longer counted as waiting on you: not in “2 waiting on you” under Claude
+  Code's prompt, and not on Herdr's badges for Claude Code, Codex, OpenCode or Pi.
+- A reply on an answer wakes Codex, OpenCode and Pi in the same words as Claude Code: “Pending You: your person replied
+  to your answer “…” (req_…).”, then to read it with get_request, act on it and ack_answer, or post_answer with
+  follows for a long one.
+
 ## 0.36.0 (2026-10-19)
 
 - Your agents' answers to your questions land in Pending You too (guide 2.54). When you ask an agent something and

package/README.md

@@ -214,6 +214,19 @@ beside a recap still goes on a card. And anything else for you, in a message tha
 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.37.0 a step it hands you to do now goes on a card, whatever card is open (guide 2.55). An agent that ends a
+card at a step that waits for it ("on my go, open the link") and then gives the go only in its chat leaves you to find
+it there. So when the last message hands you a step now ("Go: approve it now", "you can merge it now", "now open the
+run link", "go ahead and approve it", "Your turn: …"), a card call from that turn has to carry it: one that holds the
+message's link, or, without one, two of its words. Otherwise the agent is asked once (about 49 tokens): *Your last
+message hands them a step now, and no card from this turn has it: put it on a card (follows: the card they answered;
+one still waiting: update_request it), or say it doesn’t need one.* A card about something else, a recap of open cards
+and the message's word that it's on a card don't count: the card waiting on you is the one whose step said "on my go".
+Not a step now: the agent's own act ("I'll go ahead and merge it now"), a question whether it should ("Merge and deploy
+now?"), an offer ("whenever you like"), a look ("now open … to see it"), news ("you can now run the tests yourself"),
+what a page or a step says, a heading or label ("Open now:", "Open questions: …"), or anything in code or quotes. It
+costs no request.
+
 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

package/dist/apps/codex-wake.js

@@ -181,6 +181,7 @@ export async function posted(io, options) {
                     const urgency = isUrgency(args.urgency) ? args.urgency : before?.urgency;
                     const blocking = typeof args.blocking === 'boolean' ? args.blocking : before?.blocking;
                     const askedFirst = call === 'post_request' ? askedIn(args) : before?.askedFirst;
+                    const answer = call === 'post_answer' || before?.kind === 'answer';
                     waiting.cards[requestId] = {
                         ...(name ? { name } : {}),
                         ...(title ? { title } : {}),
@@ -188,6 +189,7 @@ export async function posted(io, options) {
                         ...(urgency ? { urgency } : {}),
                         ...(blocking ? { blocking } : {}),
                         ...(askedFirst ? { askedFirst } : {}),
+                        ...(answer ? { kind: 'answer' } : {}),
                     };
                 }
             }
@@ -251,7 +253,9 @@ export async function reportThreads(io, app, options) {
         if (here.length === 0 && options.closed)
             return await clearHerdr(io, options.at, pane);
         const newest = [...here].sort((a, b) => b.at - a.at)[0];
-        const cards = here.flatMap((thread) => Object.entries(thread.cards).map(([requestId, card]) => ({
+        const cards = here.flatMap((thread) => Object.entries(thread.cards)
+            .filter(([, card]) => card.kind !== 'answer')
+            .map(([requestId, card]) => ({
             requestId,
             ...(typeof card.title === 'string' ? { title: card.title } : {}),
             ...(isUrgency(card.urgency) ? { urgency: card.urgency } : {}),
@@ -418,6 +422,13 @@ function line(heard, card) {
             `${from} followed up on ${titled}, which it answered for your person`,
             `call ${get} to read it, act on it if it needs anything, then ack_answer with its version to mark it heard`,
         ];
+    if (heard.kind === 'answer')
+        return heard.status === 'resolved' || heard.status === 'cancelled' || heard.status === 'expired'
+            ? null
+            : [
+                `your person replied to your answer ${titled}`,
+                `call ${get}, act on their words, then ack_answer with its version and a one-line outcome (it reaches them as your reply), or post_answer with follows: its requestId for a long one`,
+            ];
     switch (heard.status) {
         case 'expired':
             return [

package/dist/confirm.js

@@ -10,7 +10,7 @@ const FILLER = /^(?:\s|[,:]|back\b|me\b|it\b|to me\b|with\b|exactly\b|precisely\
 const ELSEWHERE = /\b(?:in|into|at|on)\s+(?:your|a|the|that|their)\s+(?:terminal|shell|browser|console|prompt|form|field|dialog|email|inbox|page|app|site|website|portal|dashboard)\b|\bin\s+(?:Terminal|iTerm)\b|\bwhen\s+(?:prompted|asked|it\s+asks)\b|\bat\s+the\s+prompt\b|https?:\/\/(?!claude\.ai\/code\/)/iu;
 const THIS_CHAT = /\bin\s+(?:this|our)\s+(?:chat|conversation|session)\b/iu;
 const OFFER = /\b(?:any\s?time|whenever|at\s+any\s+(?:point|time)|if\s+you\s+change\s+your\s+mind|if\s+(?:anything|something)\s+(?:looks|seems|goes))\b/iu;
-const DESCRIBED = /\b(?:says?|said|reads?|ends?\s+with|starts?\s+with|shows?|prints?|displays?|asks?|prompts?|tells?\s+\w+|text|message|copy|label|button|template)\s*[:,]?$/iu;
+export const DESCRIBED = /\b(?:says?|said|reads?|ends?\s+with|starts?\s+with|shows?|prints?|displays?|asks?|prompts?|tells?\s+\w+|text|message|copy|label|button|template)\s*[:,]?$/iu;
 const COMMAND_LIKE = /^\s*(?:[!/]|\$\s|(?:cd|npm|npx|pnpm|yarn|bun|git|gh|curl|wget|brew|node|python3?|pip|docker|ssh|scp|sudo|claude|codex|wrangler)\s)/u;
 const QUOTED = /“([^“”\n]{1,160})”|"([^"\n]{1,160})"|`([^`\n]{1,160})`|‘([^‘’\n]{1,160})’|(?<![\p{L}\p{N}])'([^'\n]{1,160})'(?![\p{L}\p{N}])/gu;
 export function proseOf(text) {
@@ -36,7 +36,7 @@ export function proseOf(text) {
     }
     return kept.join('\n');
 }
-function marked(text) {
+export function marked(text) {
     const quotes = [];
     const out = text.replace(QUOTED, (...groups) => {
         const inner = groups.slice(1, 6).find((group) => typeof group === 'string');
@@ -128,7 +128,7 @@ const COMMON = new Set([
     'this',
     'that',
 ]);
-const wordsOf = (text) => text.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
+export const wordsOf = (text) => text.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
 export const telling = (words) => words === null ? [] : [...new Set(wordsOf(words).filter((word) => !COMMON.has(word)))];
 export function cardFits(text, words, where) {
     const wanted = telling(words);

package/dist/step-now.js

@@ -0,0 +1,133 @@
+import { DESCRIBED, marked, proseOf, wordsOf } from "./confirm.js";
+const NOW_VERB = String.raw `(?:approve|open(?!\s+(?:to|for|now)\b)|press|click|tap|run|paste|merge|publish|deploy|release|restart|confirm|authori[sz]e|accept|allow|(?:sign|log)\s+in)`;
+const GATE_VERB = String.raw `(?:approve|merge|publish|deploy|release|confirm|authori[sz]e|accept|allow|(?:sign|log)\s+in)`;
+const LEAD = String.raw `(?:(?:ok(?:ay)?|alright|all\s+right|right|so|please|just)[,!]?\s+)*`;
+const NOT_THAT = String.raw `(?!\s+(?:that|on)\b)`;
+const NOT_FOR = String.raw `(?<!\bfor\s+)`;
+export const STEP_NOW = new RegExp([
+    String.raw `^${LEAD}go(?:\s+ahead)?(?:\s+now)?\s*(?:[:!—–]|-\s)`,
+    String.raw `^${LEAD}(?:it(?:['’]s|\s+is)\s+)?your\s+turn\s*[:!—–]`,
+    String.raw `\b(?:that|this|here)(?:['’]s|\s+is)\s+(?:your|the)\s+go\b(?!-)`,
+    String.raw `(?:^${LEAD}|[:;—–]\s*|\byou\s+can\s+)go\s+ahead\s+and\s+${NOW_VERB}\b`,
+    String.raw `(?:^${LEAD}|[:;,—–]\s*|\b(?:and|so|then)\s+)now[,:]?\s+(?:please\s+)?${NOW_VERB}\b`,
+    String.raw `^(?![^\n]*\?\s*$)${LEAD}${NOW_VERB}\b[^.!?\n:]{0,80}?${NOT_FOR}\bnow\b${NOT_THAT}`,
+    String.raw `\b(?:you\s+can|can\s+you|could\s+you)\s+(?:go\s+ahead\s+and\s+)?${GATE_VERB}\b[^.!?\n]{0,60}?${NOT_FOR}\bnow\b${NOT_THAT}`,
+    String.raw `\byou\s+can\s+now\s+${GATE_VERB}\b`,
+].join('|'), 'iu');
+const STEP_NOW_EACH = new RegExp(STEP_NOW.source, 'giu');
+export const NOT_NOW = /\b(?:any\s?time|whenever|at\s+any\s+(?:point|time)|if\s+you\s+(?:want|like|prefer|['’]d\s+like)|when\s+you\s+get\s+a\s+(?:chance|minute)|no\s+rush|or\s+later|to\s+(?:see|look|check|try|test|compare))\b/iu;
+export const STEP_NOW_REASON = 'Your last message hands them a step now, and no card from this turn has it: put it on a card (follows: the card they answered; one still waiting: update_request it), or say it doesn’t need one.';
+const SENTENCE_END = /(?<=[.!?])\s+|\n+/u;
+const MARK = /⟦(\d+)⟧/gu;
+const LINK = /\bhttps?:\/\/[^\s<>"'`“”‘’⟦⟧]+/giu;
+const LINK_END = /[.,;:!?)]+$/u;
+const LINK_GOES_ON = /[\p{L}\p{N}_-]/u;
+const CARD_PAGE = /\/app\/r\/req_/iu;
+const STEP_COMMON = new Set([
+    'go',
+    'ahead',
+    'now',
+    'you',
+    'your',
+    'yours',
+    'can',
+    'could',
+    'please',
+    'just',
+    'ok',
+    'okay',
+    'alright',
+    'all',
+    'right',
+    'so',
+    'then',
+    'still',
+    'card',
+    'cards',
+    'done',
+    'step',
+    'steps',
+    'turn',
+    'it',
+    'its',
+    's',
+    't',
+    'll',
+    're',
+    've',
+    'd',
+    'm',
+    'i',
+    'me',
+    'my',
+    'we',
+    'our',
+    'the',
+    'a',
+    'an',
+    'and',
+    'or',
+    'to',
+    'of',
+    'on',
+    'in',
+    'at',
+    'for',
+    'with',
+    'from',
+    'by',
+    'is',
+    'are',
+    'be',
+    'this',
+    'that',
+    'here',
+    'there',
+]);
+function handsOver(sentence) {
+    if (NOT_NOW.test(sentence))
+        return false;
+    for (const found of sentence.matchAll(STEP_NOW_EACH))
+        if (!DESCRIBED.test(sentence.slice(0, found.index).trimEnd()))
+            return true;
+    return false;
+}
+function linksIn(said) {
+    const links = (said.match(LINK) ?? [])
+        .map((link) => link.replace(LINK_END, '').replace(/\/$/u, '').toLowerCase())
+        .filter((link) => !CARD_PAGE.test(link));
+    return [...new Set(links)];
+}
+export function stepsNow(text) {
+    const { text: prose, quotes } = marked(proseOf(text));
+    const steps = [];
+    for (const each of prose.split(SENTENCE_END)) {
+        const sentence = each.trim();
+        if (!sentence || !handsOver(sentence))
+            continue;
+        const said = sentence.replace(MARK, (_, index) => quotes[Number(index)] ?? '');
+        steps.push({
+            text: said,
+            links: linksIn(said),
+            words: [
+                ...new Set(wordsOf(said.replace(LINK, ' ')).filter((word) => !STEP_COMMON.has(word))),
+            ],
+        });
+    }
+    return steps;
+}
+function holds(said, link) {
+    for (let at = said.indexOf(link); at !== -1; at = said.indexOf(link, at + 1))
+        if (!LINK_GOES_ON.test(said.charAt(at + link.length)))
+            return true;
+    return false;
+}
+export function carriesStep(card, step) {
+    if (step.links.length) {
+        const said = card.toLowerCase();
+        return step.links.every((link) => holds(said, link));
+    }
+    const has = new Set(wordsOf(card));
+    const shared = step.words.filter((word) => has.has(word)).length;
+    return shared >= Math.min(2, step.words.length);
+}

package/dist/stopcheck.js

@@ -9,6 +9,7 @@ import { readCredential } from "./credentials.js";
 import { isHandedWake } from "./format.js";
 import { isPermissionCard, isPromptApp, sessionName, settlePrompts, subagentsRunning, } from "./permission.js";
 import { askerParams, folderForms } from "./pickup.js";
+import { carriesStep, STEP_NOW_REASON, stepsNow } from "./step-now.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.';
@@ -448,6 +449,9 @@ export async function stopcheck(io, options) {
                 return 0;
             return block(confirmReason(ask.words, sessionLink(io.env), APP_NAMES[app]));
         }
+        const loose = stepsNow(text).filter((step) => !turn.cards.some((card) => carriesStep(card, step)));
+        if (loose.length && !saysNoCard(text))
+            return block(STEP_NOW_REASON);
         if (turn.posted || saysPosted(text) || saysNoCard(text))
             return 0;
         if (turn.asked && isAnswer(text) && (await seesAnswers(io, app)))

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.36.0';
+export const VERSION = '0.37.0';

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

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

package/mod/hooks/register.js

@@ -534,7 +534,8 @@ async function answerHold($, e) {
     if ((await check($, requestId)) !== 'ok')
         return null;
     showCards($);
-    return { result: { stdout: holdReply(requestId), stderr: '', interrupted: false } };
+    const answer = live.book.cards[requestId]?.kind === 'answer';
+    return { result: { stdout: holdReply(requestId, answer), stderr: '', interrupted: false } };
 }
 export function register(on) {
     on('session.start', async ($, e, next) => {
@@ -564,7 +565,7 @@ export function register(on) {
         return next(e);
     });
     on('tool.call', {
-        tool: /^mcp__.+__(post_request|get_request|update_request|reply_in_thread|ack_answer|cancel_request|whoami|list_pending|answer_delegated|hand_back)$/,
+        tool: /^mcp__.+__(post_request|post_answer|get_request|update_request|reply_in_thread|ack_answer|cancel_request|whoami|list_pending|answer_delegated|hand_back)$/,
     }, async ($, e, next) => {
         const result = await next(e);
         try {

package/mod/hooks/wake.js

@@ -21,6 +21,7 @@ const URGENCIES = new Set(['now', 'today', 'whenever']);
 const isUrgency = (value) => typeof value === 'string' && URGENCIES.has(value);
 const READS = new Set([
     'post_request',
+    'post_answer',
     'get_request',
     'update_request',
     'reply_in_thread',
@@ -32,6 +33,7 @@ const READS = new Set([
     'hand_back',
 ]);
 export const HANDED_READS = new Set(['get_request', 'answer_delegated', 'hand_back']);
+const POSTS = new Set(['post_request', 'post_answer']);
 export const APPROVED_DRAFT_NOTICE = 'The approved words are in get_request’s answer.approvedDrafts: send them exactly.';
 const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 const parseJson = (text) => {
@@ -99,7 +101,7 @@ export function resultObject(result) {
 }
 export function nameOf(tool, input) {
     const name = text(input.name, 120);
-    if (name || tool !== 'post_request')
+    if (name || !POSTS.has(tool))
         return name;
     const session = typeof input.session === 'string' ? parseJson(input.session) : input.session;
     return isObject(session) ? text(session.label, 120) : undefined;
@@ -111,6 +113,7 @@ export function argumentsOf(call) {
 export const isClosed = (status) => CLOSED.has(status);
 export const isReady = (state) => state.turn === 'agent' || isClosed(state.status);
 export const isWaitingOnYou = (state) => state.turn === 'you' && OPEN.has(state.status);
+const waitsOnYou = (card) => card.kind !== 'answer' && card.state !== undefined && isWaitingOnYou(card.state);
 export const momentOf = (state) => `${state.status}/${state.turn}/${state.version}/${state.cursor}`;
 export function stateOf(output) {
     const status = text(output.status, 40);
@@ -157,6 +160,7 @@ export function readBook(value) {
             ...(isUrgency(card.urgency) ? { urgency: card.urgency } : {}),
             ...(card.blocking === true ? { blocking: true } : {}),
             ...(card.askedFirst === true ? { askedFirst: true } : {}),
+            ...(card.kind === 'answer' ? { kind: 'answer' } : {}),
             ...(state ? { state } : {}),
             ...(typeof card.told === 'string' ? { told: card.told } : {}),
             ...(typeof card.seen === 'string' ? { seen: card.seen } : {}),
@@ -220,12 +224,14 @@ function tracked(book, facts, now) {
     const card = book.cards[facts.requestId];
     const name = facts.name ?? card?.name;
     const title = facts.title ?? card?.title;
+    const kind = facts.kind ?? card?.kind;
     return put(book, {
         requestId: facts.requestId,
         server: facts.server,
         ...(name ? { name } : {}),
         ...(title ? { title } : {}),
         ...(facts.pressing ?? pressingOfCard(card)),
+        ...(kind ? { kind } : {}),
         learnedAt: card?.learnedAt ?? now,
         changedAt: now,
         state: facts.state,
@@ -269,6 +275,22 @@ export function learn(book, call, now) {
             }, now);
             return tool === 'post_request' ? followedUp(posted, requestIdOf(input.follows), now) : posted;
         }
+        case 'post_answer': {
+            const status = text(output.status, 40);
+            if (!status || !OPEN.has(status) || version === undefined)
+                return next;
+            const title = text(input.title, 400);
+            const posted = tracked(next, {
+                requestId,
+                server,
+                ...(name ? { name } : {}),
+                ...(title ? { title: clip(title) } : {}),
+                pressing: {},
+                kind: 'answer',
+                state: { status, turn: 'you', version, cursor: card?.state?.cursor ?? '' },
+            }, now);
+            return followedUp(posted, requestIdOf(input.follows), now);
+        }
         case 'reply_in_thread': {
             const reopen = isObject(input.reopen) ? input.reopen : null;
             if (version === undefined || (!reopen && output.turn !== 'you'))
@@ -304,7 +326,9 @@ export function learn(book, call, now) {
         case 'ack_answer':
             return output.status === 'resolved' ? drop(next, requestId) : next;
         case 'cancel_request':
-            return output.status === 'cancelled' ? drop(next, requestId) : next;
+            return output.status === 'cancelled' || output.status === 'resolved'
+                ? drop(next, requestId)
+                : next;
         default:
             return next;
     }
@@ -332,15 +356,22 @@ export function failed(card, now, blocked) {
         nextAt: now + Math.min(MAX_BACKOFF_MS, FAST_MS * 2 ** (failures - 1)),
     };
 }
+export const ANSWER_UNDO_MS = 20_000;
+const mayComeBack = (card) => card.kind === 'answer' &&
+    card.state?.status === 'resolved' &&
+    !(card.checkedAt !== undefined && card.checkedAt - card.changedAt >= ANSWER_UNDO_MS);
 export function dueCards(book, now) {
     return Object.values(book.cards)
-        .filter((card) => !(card.state && isClosed(card.state.status)) && (card.nextAt ?? 0) <= now)
+        .filter((card) => !(card.state && isClosed(card.state.status) && !mayComeBack(card)) &&
+        (card.nextAt ?? 0) <= now)
         .sort((a, b) => (a.nextAt ?? 0) - (b.nextAt ?? 0));
 }
 export function needsTelling(card) {
     const state = card.state;
     if (!state || !isReady(state))
         return false;
+    if (card.kind === 'answer' && isClosed(state.status))
+        return false;
     if (state.status === 'resolved')
         return false;
     const moment = momentOf(state);
@@ -377,7 +408,7 @@ export function untold(book, before) {
 export function settle(book, now) {
     let next = book;
     for (const card of Object.values(book.cards)) {
-        const done = card.state && isClosed(card.state.status) && !needsTelling(card);
+        const done = card.state && isClosed(card.state.status) && !needsTelling(card) && !mayComeBack(card);
         if (done || now - Math.max(card.learnedAt, card.changedAt) > KEEP_MS)
             next = drop(next, card.requestId);
     }
@@ -389,6 +420,11 @@ const named = (card) => (card.name ? `name “${card.name}”` : 'your name');
 function line(card) {
     const state = card.state;
     const get = `get_request (requestId ${card.requestId}, ${named(card)})`;
+    if (card.kind === 'answer')
+        return [
+            `your person replied to your answer ${titled(card)}`,
+            `call ${get}, act on their words, then ack_answer with its version and a one-line outcome (it reaches them as your reply), or post_answer with follows: its requestId for a long one`,
+        ];
     switch (state.status) {
         case 'expired':
             return [
@@ -449,7 +485,7 @@ export function wakeText(cards) {
 export function statusText(book, blocked) {
     if (blocked)
         return `to hear answers here, allow mcp__${blocked} in /permissions`;
-    const waiting = Object.values(book.cards).filter((card) => card.state && isWaitingOnYou(card.state)).length;
+    const waiting = Object.values(book.cards).filter(waitsOnYou).length;
     return waiting ? `${waiting} waiting on you` : undefined;
 }
 export const blockedNote = (server) => `Pending You can’t wake this session when your person answers: Claude Code doesn’t let it check your cards yet. Ask them to allow mcp__${server} in /permissions (Allow, user settings). Until then, check get_request at breakpoints.`;
@@ -572,7 +608,7 @@ export function holdOf(command) {
     }
     return held ? requestId : null;
 }
-export const holdReply = (requestId) => `Pending You: no hold is needed in this session. It’s woken when your person answers ${requestId}, writes to you on it, or its fallback runs, even while it’s idle. Nothing is running in the background and there’s nothing to wait on: keep working, or end your turn.`;
+export const holdReply = (requestId, answer = false) => `Pending You: no hold is needed in this session. It’s woken when your person ${answer ? `replies to your answer ${requestId}` : `answers ${requestId}, writes to you on it, or its fallback runs`}, even while it’s idle. Nothing is running in the background and there’s nothing to wait on: keep working, or end your turn.`;
 function leaseOf(value) {
     const match = /^(\S+) (\d+)$/.exec(value ?? '');
     return match ? { holder: match[1], until: Number(match[2]) } : null;
@@ -677,7 +713,7 @@ export function graceEnds(handed, folders) {
     return Number.isFinite(at) ? at + HANDED_GRACE_MS : null;
 }
 export function folderOf(tool, input) {
-    if (tool !== 'post_request')
+    if (!POSTS.has(tool))
         return undefined;
     const session = typeof input.session === 'string' ? parseJson(input.session) : input.session;
     return isObject(session) ? text(session.cwd, 1000) : undefined;
@@ -919,7 +955,7 @@ export function inHerdr(on, bin, pane) {
 }
 export function herdrCards(book) {
     return Object.values(book.cards)
-        .filter((card) => card.state && isWaitingOnYou(card.state))
+        .filter(waitsOnYou)
         .sort((a, b) => (a.requestId < b.requestId ? -1 : a.requestId > b.requestId ? 1 : 0))
         .map((card) => ({
         requestId: card.requestId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pendingyou",
-  "version": "0.36.0",
+  "version": "0.37.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.",
   "keywords": [
     "pendingyou",