pendingyou 0.23.0 → 0.26.0

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## 0.26.0 (2026-10-07)
+
+- A session that sat idle past its sign-in's 15-minute access token hears its answers again. The next message's
+  hand-off started the background refresh, waited 1.2 seconds for it and gave up, often just before it landed, so an
+  answered card went unannounced. Now the hand-off and the session start's pickup wait for an expired token until 0.9
+  seconds before their 3-second deadline, leaving room to ask for answers; a token with seconds left still waits 1.2.
+- Never silent: when the hand-off or the session start's pickup can't check for answers (Pending You unreachable, a
+  server error, or the sign-in still being refreshed), they add “Pending You couldn't check for answers just now: call
+  list_pending before you go on.” instead of only the plain reminder.
+
+## 0.25.0 (2026-10-06)
+
+- An answer reaches only the session that asked. The hooks asked Pending You for their folder's answers and open
+  cards, and got every card asked from that folder, or from any folder above it, whoever asked: two sessions in one
+  folder each heard the other's answers and were told to ack them, the next-message line listed the other's cards as
+  "Your open cards here", and a card asked from a folder above another session's reached it on any computer. Now each
+  hook says who its session is: the cards it posted (Claude Code's from its own transcript, with whether that's all of
+  them; Codex's, OpenCode's and Pi's from what their hooks remember), the name it goes by, and this computer's names.
+  Pending You hands it a card it posted (whatever name it asked under, the app's own included), else one asked under
+  its name; only a session that can say neither falls back to its folder, that exact folder on this computer, and
+  never for a card asked under another agent's name. The Stop check's look at open cards asks the same way. Needs
+  Pending You's matching release; until then the hooks hear as before.
+
+## 0.24.0 (2026-10-06)
+
+- When your person approves a card that carried a draft, or picks a reply option that sends (`sends`), the hold, the
+  hooks' hand-off and the wake mods (Claude Code's and Codex's) add one line: “The approved words are in
+  get_request’s answer.approvedDrafts: send them exactly.” Pending You's `get_request` now gives those exact words with
+  the answer (and every answer the card's title), so an agent that starts fresh, or a smaller model, sends what was
+  approved instead of hunting for it or rewriting it. Needs Pending You's matching release; with an older one nothing
+  changes.
+
 ## 0.23.0 (2026-10-06)
 
 - The Claude Code wake mod survives upgrades. `init` now copies it to `~/.config/pendingyou/mod`, a folder that stays

package/dist/api.js

@@ -5,6 +5,8 @@ import { OAuthError, refresh } from "./oauth.js";
 const EARLY_MS = 60_000;
 export const SOON_MS = 5 * 60_000;
 export const REFRESH_WAIT_MS = 1200;
+export const HOOK_DEADLINE_MS = 3000;
+export const ANSWERS_ROOM_MS = 900;
 const USABLE_MS = 10_000;
 export class SignInNeeded extends Error {
     name = 'SignInNeeded';
@@ -72,7 +74,7 @@ export async function refreshInBackground(io, origin, force, app = DEFAULT_APP)
     await refreshStored(io, origin, stored, { force, earlyMs: SOON_MS }, app);
     return true;
 }
-async function hookToken(io, origin, force, signal, app) {
+async function hookToken(io, origin, force, signal, app, expiredWaitMs) {
     const stored = await readCredential(io, origin, app);
     if (!stored)
         throw new SignInNeeded(false);
@@ -83,7 +85,8 @@ async function hookToken(io, origin, force, signal, app) {
         io.background(refreshArgs(origin, app, force));
     if (!force && left > USABLE_MS)
         return stored.accessToken;
-    const until = io.now() + REFRESH_WAIT_MS;
+    const wait = !force && left <= 0 && expiredWaitMs !== undefined ? expiredWaitMs : REFRESH_WAIT_MS;
+    const until = io.now() + wait;
     while (io.now() < until && !signal?.aborted) {
         await io.sleep(50, signal);
         const current = await readCredential(io, origin, app);
@@ -133,6 +136,7 @@ export function getJson(io, origin, path, timeoutMs, signal, options = {}) {
 export function sendJson(io, origin, path, body, timeoutMs, options = {}) {
     return callJson(io, origin, path, { body }, timeoutMs, undefined, options);
 }
+export const expiredWait = (uptime) => Math.max(0, HOOK_DEADLINE_MS - ANSWERS_ROOM_MS - uptime);
 async function callJson(io, origin, path, send, timeoutMs, signal, options = {}) {
     const app = options.app ?? DEFAULT_APP;
     for (let attempt = 0;; attempt++) {
@@ -140,7 +144,7 @@ async function callJson(io, origin, path, send, timeoutMs, signal, options = {})
         try {
             token =
                 options.hook && io.background
-                    ? await hookToken(io, origin, attempt > 0, signal, app)
+                    ? await hookToken(io, origin, attempt > 0, signal, app, options.patient && io.uptime ? expiredWait(io.uptime()) : undefined)
                     : await freshToken(io, origin, attempt > 0, app);
         }
         catch (error) {

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, handledOf, isClosed, noticeOf } from "../format.js";
+import { APPROVED_DRAFT_NOTICE, approvesDraft, 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";
@@ -280,6 +280,12 @@ export async function threadNames(io, app, thread) {
         return [];
     return (await load(io, app).catch(() => null))?.threads[thread]?.names ?? [];
 }
+export async function threadCards(io, app, thread) {
+    if (!thread)
+        return [];
+    const cards = (await load(io, app).catch(() => null))?.threads[thread]?.cards ?? {};
+    return Object.keys(cards).filter((id) => REQUEST_ID.test(id));
+}
 export async function markHandedTurn(io, turn, app) {
     const now = io.now();
     await change(io, app, (state) => {
@@ -411,7 +417,7 @@ function line(heard, card) {
                 ];
             return [
                 `your person answered ${titled}`,
-                `call ${get}, act on their words, then ack_answer with its version and a one-line outcome`,
+                `call ${get}, act on their words, then ack_answer with its version and a one-line outcome${approvesDraft(heard) ? `. ${APPROVED_DRAFT_NOTICE.slice(0, -1)}` : ''}`,
             ];
         default:
             return [

package/dist/format.js

@@ -12,6 +12,8 @@ export function handledOf(heard) {
     return given === 'self' || given === 'leave' ? given : null;
 }
 const HANDLED_SAID = { self: 'I’ll do it myself', leave: 'Leave it' };
+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';
 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.';
@@ -170,6 +172,8 @@ export function describe(heard, again) {
             }
             if (wrote.length)
                 lines.push(`${noticeOf(heard) ? 'Also' : 'They also wrote'}: ${wrote.join(' ')}`);
+            if (approvesDraft(heard))
+                lines.push(APPROVED_DRAFT_NOTICE);
             lines.push(`Act on it, then call ack_answer with requestId ${id}, name ${named(heard)}, expectedVersion ${heard.version} and a one-line outcome.`);
             break;
         }

package/dist/main.js

@@ -1,4 +1,4 @@
-import { refreshInBackground, SignInNeeded, Unavailable } from "./api.js";
+import { HOOK_DEADLINE_MS, refreshInBackground, SignInNeeded, Unavailable } from "./api.js";
 import { listen, listenHanded, posted } from "./apps/codex-wake.js";
 import { DEFAULT_APP } from "./apps/ids.js";
 import { appModule } from "./apps/registry.js";
@@ -101,7 +101,7 @@ async function run(io, command, hook = { fallback: '' }) {
             return (await import("./app-login.js")).appCommand(io, command);
     }
 }
-export const HOOK_DEADLINE_MS = 3000;
+export { HOOK_DEADLINE_MS };
 async function runHook(io, command) {
     const hook = { fallback: '' };
     const controller = new AbortController();

package/dist/permission.js

@@ -526,6 +526,95 @@ export async function sessionName(path) {
         await file.close().catch(() => { });
     }
 }
+const POST_TOOL = /^mcp__.*pendingyou.*__post_request$/i;
+const POSTED_ID = /"requestId"\s*:\s*"(req_[A-Za-z0-9-]{1,40})"/;
+export const POSTED_MAX = 50;
+function resultText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content.map((block) => (isObject(block) ? text(block.text) : '')).join('\n');
+}
+export async function sessionPosted(path) {
+    if (!path)
+        return null;
+    let file;
+    try {
+        file = await open(path, 'r');
+    }
+    catch (error) {
+        return error?.code === 'ENOENT' ? { posted: [], whole: true } : null;
+    }
+    try {
+        const size = (await file.stat()).size;
+        let position = size;
+        let carry = Buffer.alloc(0);
+        const results = new Map();
+        const posted = [];
+        let more = false;
+        const read = (line) => {
+            const asResult = line.includes('tool_result') && line.includes('req_');
+            const asCall = line.includes('post_request');
+            if (!asResult && !asCall)
+                return;
+            let entry;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                return;
+            }
+            if (!isObject(entry) || entry.isSidechain === true)
+                return;
+            const message = isObject(entry.message) ? entry.message : {};
+            const blocks = Array.isArray(message.content) ? message.content : [];
+            for (const block of [...blocks].reverse()) {
+                if (!isObject(block))
+                    continue;
+                if (entry.type === 'user' && block.type === 'tool_result' && block.is_error !== true) {
+                    const id = POSTED_ID.exec(resultText(block.content))?.[1];
+                    if (id && text(block.tool_use_id))
+                        results.set(text(block.tool_use_id), id);
+                }
+                else if (entry.type === 'assistant' &&
+                    block.type === 'tool_use' &&
+                    POST_TOOL.test(text(block.name))) {
+                    const id = results.get(text(block.id));
+                    if (!id || posted.includes(id))
+                        continue;
+                    if (posted.length < POSTED_MAX)
+                        posted.push(id);
+                    else
+                        more = true;
+                }
+            }
+        };
+        while (position > 0 && size - position < TRANSCRIPT_CAP) {
+            const length = Math.min(64 * 1024, position);
+            position -= length;
+            const chunk = Buffer.alloc(length);
+            await file.read(chunk, 0, length, position);
+            let buffer = Buffer.concat([chunk, carry]);
+            let newline = buffer.lastIndexOf(10);
+            while (newline !== -1) {
+                read(buffer.subarray(newline + 1).toString('utf8'));
+                buffer = buffer.subarray(0, newline);
+                newline = buffer.lastIndexOf(10);
+            }
+            carry = buffer;
+        }
+        if (position === 0)
+            read(carry.toString('utf8'));
+        return { posted, whole: position === 0 && !more };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await file.close().catch(() => { });
+    }
+}
 export function remoteOf(url) {
     const plain = url
         .trim()

package/dist/pickup.js

@@ -1,7 +1,7 @@
-import { getJson, SignInNeeded } from "./api.js";
-import { computerNames, hearsOnly, keepListening, markHandedTurn, sessionFor, threadNames, touchThread, } from "./apps/codex-wake.js";
+import { getJson, SignInNeeded, Unavailable } from "./api.js";
+import { computerNames, hearsOnly, keepListening, markHandedTurn, sessionFor, threadCards, threadNames, touchThread, } from "./apps/codex-wake.js";
 import { APP_NAMES, DEFAULT_APP } from "./apps/ids.js";
-import { readCredential } from "./credentials.js";
+import { connectionMachine, readCredential } from "./credentials.js";
 import { environmentWarning } from "./environment.js";
 import { configDir, readJson } from "./files.js";
 import { clip, delegatedOf, describe, HANDED_PREFIX, isHandedWake, } from "./format.js";
@@ -9,7 +9,7 @@ import { goesBy, HANDED_GRACE_MS, namesAnotherComputer } from "./handed.js";
 import { herdrTarget, reportCommand } from "./herdr.js";
 import { holdCommand } from "./hold.js";
 import { unwokenLine } from "./loaded.js";
-import { isPermissionCard, isPromptApp, sessionName, settlePrompts } from "./permission.js";
+import { isPermissionCard, isPromptApp, POSTED_MAX, sessionName, sessionPosted, settlePrompts, } from "./permission.js";
 import { announce, keepPresent, readSaid } from "./presence.js";
 import { setupReminder } from "./setup.js";
 import { claimHanded, markHanded, momentOf, releaseHanded, wasHanded } from "./state.js";
@@ -17,6 +17,7 @@ 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 UNCHECKED = "Pending You couldn't check for answers just now: call list_pending before you go on.";
 export const OPEN_SHOWN = 3;
 export const OPEN_TITLE = 50;
 export const OPEN_NAME = 24;
@@ -110,6 +111,30 @@ export function folderForms(cwd, home) {
         forms.push(`~${cwd.slice(base.length)}`);
     return forms;
 }
+export async function askerParams(io, origin, app, session) {
+    let name = session.name ?? undefined;
+    let posted = [];
+    let own = false;
+    if (app === DEFAULT_APP) {
+        const record = await sessionPosted(session.transcript ?? undefined);
+        if (record) {
+            posted = record.posted;
+            own = record.whole;
+        }
+    }
+    else if (session.id) {
+        name ??= (await threadNames(io, app, session.id).catch(() => [])).at(-1);
+        posted = (await threadCards(io, app, session.id).catch(() => [])).slice(0, POSTED_MAX);
+    }
+    const machine = await connectionMachine(io, origin, app).catch(() => null);
+    const machines = [...new Set([io.host, machine].filter((each) => Boolean(each)))];
+    return [
+        ...(name ? [['name', name]] : []),
+        ...posted.map((id) => ['posted', id]),
+        ...(own ? [['own', '1']] : []),
+        ...machines.slice(0, 4).map((each) => ['machine', each]),
+    ];
+}
 export async function pickup(io, options, hook = { fallback: '' }) {
     const { origin, mode } = options;
     const app = options.app ?? DEFAULT_APP;
@@ -168,10 +193,15 @@ export async function pickup(io, options, hook = { fallback: '' }) {
             ['limit', String(ANSWERS_ASKED)],
             ...(mode === 'handoff' ? [['open', String(OPEN_SHOWN)]] : []),
             ['source', app],
-            ...(named ? [['name', named]] : []),
+            ...(await askerParams(io, origin, app, {
+                id: input.session,
+                transcript: input.transcript,
+                name: named ?? null,
+            })),
         ]);
         const { status, body } = await getJson(io, origin, `/mcp/cli/answers?${query}`, TIME_BOX_MS[mode], io.signal, {
             hook: true,
+            patient: true,
             app,
         });
         if (status !== 200)
@@ -264,6 +294,8 @@ export async function pickup(io, options, hook = { fallback: '' }) {
             io.out(`Pending You: this computer’s pendingyou sign-in has ended, so answers can’t wake ${APP_NAMES[app]}. Ask your person to run \`npx pendingyou login${app === DEFAULT_APP ? '' : ` --app ${app}`}\`.\n`);
         if (error instanceof SignInNeeded)
             line = null;
+        if (error instanceof Unavailable)
+            line = [line, UNCHECKED].filter(Boolean).join('\n');
         return 0;
     }
     finally {

package/dist/stopcheck.js

@@ -5,8 +5,8 @@ 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 { isPermissionCard, isPromptApp, settlePrompts, subagentsRunning } from "./permission.js";
-import { folderForms } from "./pickup.js";
+import { isPermissionCard, isPromptApp, sessionName, settlePrompts, subagentsRunning, } from "./permission.js";
+import { askerParams, 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.';
@@ -275,13 +275,15 @@ function opencodeTurn(input) {
     const text = final.join('\n').trim();
     return text ? { text, posted, cards, handed } : null;
 }
-async function openTitles(io, origin, cwd, app) {
+async function openTitles(io, origin, cwd, app, session) {
     try {
+        const name = app === 'claude-code' ? await sessionName(session.transcript ?? undefined) : undefined;
         const query = new URLSearchParams([
             ...folderForms(cwd, io.home).map((form) => ['cwd', form]),
             ['limit', '0'],
             ['open', String(OPEN_CARDS)],
             ['source', app],
+            ...(await askerParams(io, origin, app, { ...session, name: name ?? null })),
         ]);
         const { status, body } = await getJson(io, origin, `/mcp/cli/answers?${query}`, OPEN_TIME_BOX_MS, io.signal, { hook: true, app });
         const requests = status === 200 ? body.open?.requests : undefined;
@@ -366,11 +368,17 @@ export async function stopcheck(io, options) {
             return asksToTypeHere(text) || itemsForPerson(text) ? block(DELEGATED_REASON) : 0;
         }
         const cwd = typeof input.cwd === 'string' && input.cwd ? input.cwd : io.cwd;
+        const session = {
+            id: typeof input.session_id === 'string' && input.session_id ? input.session_id : null,
+            transcript: typeof input.transcript_path === 'string' && input.transcript_path
+                ? input.transcript_path
+                : null,
+        };
         const ask = asksToTypeHere(text);
         if (ask) {
             if (saysNoCard(text) || turn.cards.some((card) => cardFits(card, ask.words, 'posted')))
                 return 0;
-            const open = await openTitles(io, options.origin, cwd, app);
+            const open = await openTitles(io, options.origin, cwd, app, session);
             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]));
@@ -378,7 +386,7 @@ export async function stopcheck(io, options) {
         if (turn.posted || saysPosted(text) || saysNoCard(text) || !itemsOutsideRecaps(text))
             return 0;
         if (mentionsCards(text)) {
-            const open = await openTitles(io, options.origin, cwd, app);
+            const open = await openTitles(io, options.origin, cwd, app, session);
             if (open === null || open.some((title) => !isPermissionCard(title)))
                 return 0;
         }

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.23.0';
+export const VERSION = '0.26.0';

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

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

package/mod/hooks/wake.js

@@ -31,6 +31,7 @@ const READS = new Set([
     'hand_back',
 ]);
 export const HANDED_READS = new Set(['get_request', 'answer_delegated', 'hand_back']);
+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) => {
     try {
@@ -118,12 +119,16 @@ export function stateOf(output) {
         return null;
     const given = isObject(output.answer) ? output.answer.handled : output.handled;
     const handled = given === 'self' || given === 'leave' ? given : undefined;
+    const approvedDraft = isObject(output.answer)
+        ? Array.isArray(output.answer.approvedDrafts) && output.answer.approvedDrafts.length > 0
+        : output.approvedDraft === true;
     return {
         status,
         turn,
         version,
         cursor: typeof output.cursor === 'string' ? output.cursor : '',
         ...(handled ? { handled } : {}),
+        ...(approvedDraft ? { approvedDraft: true } : {}),
     };
 }
 export const emptyBook = (now = 0) => ({ v: 1, updatedAt: now, cards: {} });
@@ -395,7 +400,7 @@ function line(card) {
                 ];
             return [
                 `your person answered ${titled(card)}`,
-                `call ${get}, act on their words, then ack_answer with its version and a one-line outcome`,
+                `call ${get}, act on their words, then ack_answer with its version and a one-line outcome${state.approvedDraft ? `. ${APPROVED_DRAFT_NOTICE.slice(0, -1)}` : ''}`,
             ];
         case 'delegated':
             return [

package/package.json

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