pendingyou 0.36.0 → 0.36.1

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 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/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/version.js

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

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.36.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.",
   "keywords": [
     "pendingyou",