pendingyou 0.32.0 → 0.32.2

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.32.2 (2026-10-08)
+
+- A Claude Code dialog in bypassPermissions or dontAsk mode always gets its card. A subagent's `rm -rf $S/*` met Claude
+  Code's “Dangerous rm operation” check and its dialog waited an hour with no card: its prompt was written down, but
+  its card waited for a Notification hook that never named it (one comes per dialog, it doesn't say which agent's, and
+  with several subagents at work it could mean another's prompt). Now the session's worker also looks at every such
+  prompt after 20 seconds: if the asking agent's transcript has no result for that call yet, its dialog is on screen
+  and the card goes up; if it has one (a call Claude Code denied by itself), it's settled with no card. A Notification
+  names the newest prompt whose call is still unanswered, and a card it makes due goes up within a second. A
+  subagent's card says “A subagent (general-purpose) of Claude Code … needs your permission to run a command”, its
+  title ends “(a subagent)”, and it goes once the person answers in Claude Code.
+
+## 0.32.1 (2026-10-08)
+
+- The Claude Code wake mod never announces a card that's already picked up. It checks cards while a turn runs but tells
+  only once the session is idle, and it told what it had read then: a card the agent picked up in that turn (by posting
+  the next card with `follows`, or with `ack_answer`) was announced minutes later as “your person answered …”. It now
+  reads each card again just before telling it, unless it read it in the last 10 seconds; never tells a card picked up,
+  whichever way; and takes the card a new card follows as heard. A card withdrawn under the agent is still told once.
+
 ## 0.32.0 (2026-10-08)
 
 - Follow-ups are new cards that follow the one before (threads, guide 2.48). The Codex wake and the Claude Code wake mod

package/dist/permission.js

@@ -1,6 +1,6 @@
 import { createHash, randomBytes } from 'node:crypto';
 import { open, readdir, rm, stat } from 'node:fs/promises';
-import { basename, join } from 'node:path';
+import { basename, dirname, join } from 'node:path';
 import { threadNames } from "./apps/codex-wake.js";
 import { APP_NAMES } from "./apps/ids.js";
 import { DEFAULT_ORIGIN } from "./args.js";
@@ -13,8 +13,9 @@ import { machineOf } from "./remote.js";
 export const GRACE_MS = 10_000;
 export const TITLE_MAX = 90;
 export const WAITING = 'Claude Code is waiting for your OK';
-export const BACKGROUND_AGENT = ' (a background agent)';
+export const SUBAGENT = ' (a subagent)';
 const QUIET_MODES = new Set(['bypassPermissions', 'dontAsk']);
+export const QUIET_GRACE_MS = 20_000;
 export const NOTICE_MS = 4000;
 const BATCH_MS = 1000;
 export const PROMPT_APPS = ['claude-code', 'codex'];
@@ -28,7 +29,7 @@ export const DEFAULT_NAME = 'Claude Code';
 const defaultName = (app) => APP_NAMES[app];
 const LEASE_STALE_MS = 120_000;
 const WORKER_MS = 60 * 60_000;
-const NAP_MS = 20_000;
+const NAP_MS = 1000;
 const CALL_MS = 15_000;
 const BACKOFF_MS = [2000, 5000, 10_000, 20_000];
 const MAX_PROMPTS = 20;
@@ -139,7 +140,7 @@ export function promptWords(tool, input, home, app = CLAUDE) {
     }
     return said(toolName(tool), `to use ${toolName(tool)}`);
 }
-export const fromAgent = (title) => `${cut(title, TITLE_MAX - [...BACKGROUND_AGENT].length)}${BACKGROUND_AGENT}`;
+export const fromAgent = (title) => `${cut(title, TITLE_MAX - [...SUBAGENT].length)}${SUBAGENT}`;
 const noticeWords = (message) => redactText(text(message), 120);
 function noticeOf(message, now) {
     return {
@@ -171,7 +172,8 @@ async function change(io, session, edit) {
     });
 }
 const alive = (state, now) => Boolean(state.worker && now - state.worker.at < LEASE_STALE_MS);
-const seen = (prompt) => !prompt.quiet || prompt.shown !== undefined;
+const seen = (prompt) => !prompt.quiet || prompt.shown !== undefined || prompt.waited !== undefined;
+const unchecked = (prompt) => !seen(prompt) && !prompt.notice;
 function claim(state, now) {
     if (alive(state, now))
         return null;
@@ -234,7 +236,7 @@ async function asked(io, origin, input, app) {
     const words = promptWords(tool, isObject(input.tool_input) ? input.tool_input : {}, io.home, app);
     const prompt = {
         key: promptKey(tool, keyInput(app, input.tool_input), subagent || undefined),
-        ...(app === 'codex' ? { tool: tool.slice(0, 100) } : {}),
+        tool: tool.slice(0, 100),
         ...(reasonOf(app, input.tool_input)
             ? { reason: reasonOf(app, input.tool_input) }
             : {}),
@@ -271,15 +273,13 @@ async function asked(io, origin, input, app) {
         const kept = app === 'claude-code'
             ? next.prompts.filter((each) => !wentOn(agent, now)(each))
             : next.prompts;
-        const dropped = kept.length < next.prompts.length;
         next.prompts = kept;
         if (!next.prompts.some((each) => each.key === prompt.key))
             next.prompts.push(prompt);
         next.prompts = next.prompts.slice(-MAX_PROMPTS);
         delete next.settled;
         next.at = now;
-        if (!quiet || (dropped && next.card))
-            worker = claim(next, now);
+        worker = claim(next, now);
         return next;
     });
     if (worker)
@@ -302,8 +302,8 @@ async function settle(io, session, which, how) {
         state.prompts = left;
         state.settled = how;
         state.at = now;
-        if (!state.card && !left.some(seen))
-            return left.length > 0 || alive(state, now) ? state : null;
+        if (!state.card && left.length === 0)
+            return alive(state, now) ? state : null;
         worker = claim(state, now);
         return state;
     });
@@ -368,6 +368,16 @@ async function notified(io, origin, input) {
     const message = noticeWords(input.message);
     const cwd = text(input.cwd) || io.cwd;
     const link = sessionLink(io.env);
+    const known = await load(io, where.session);
+    let picked = null;
+    for (const prompt of (known?.prompts ?? []).slice().reverse()) {
+        if (prompt.shown !== undefined || prompt.notice || prompt.at > before)
+            continue;
+        if (await stillAsked(known, prompt)) {
+            picked = promptId(prompt);
+            break;
+        }
+    }
     let worker = null;
     await change(io, where.session, (state) => {
         const next = state ?? {
@@ -385,9 +395,9 @@ async function notified(io, origin, input) {
             next.transcript = where.transcript;
         if (link)
             next.link = link;
-        const shows = next.prompts
-            .filter((prompt) => prompt.shown === undefined && !prompt.notice && prompt.at <= before)
-            .at(-1);
+        const shows = picked
+            ? next.prompts.find((prompt) => prompt.shown === undefined && promptId(prompt) === picked)
+            : undefined;
         if (shows) {
             shows.shown = now;
             delete shows.failed;
@@ -434,9 +444,23 @@ export async function permissionHook(io, options) {
     catch { }
     return 0;
 }
-const dueOf = (prompt, grace) => Math.min(prompt.quiet ? Number.POSITIVE_INFINITY : prompt.at + grace, prompt.shown ?? Number.POSITIVE_INFINITY);
+const dueOf = (prompt, grace) => Math.min(prompt.quiet ? (prompt.waited ?? Number.POSITIVE_INFINITY) : prompt.at + grace, prompt.shown ?? Number.POSITIVE_INFINITY);
 const shownOf = (prompts) => (prompts.filter((prompt) => !prompt.notice).at(-1) ?? prompts.at(-1));
-export function planFor(state, now, grace) {
+export function planFor(state, now, grace, quietGrace = QUIET_GRACE_MS) {
+    const plan = cardPlan(state, now, grace);
+    const pending = state.prompts.filter(unchecked);
+    if (pending.length === 0)
+        return plan;
+    const check = Math.min(...pending.map((prompt) => prompt.at + quietGrace)) - now;
+    if (check <= 0)
+        return { kind: 'check' };
+    if (plan.kind === 'done')
+        return { kind: 'wait', ms: check };
+    if (plan.kind === 'wait')
+        return { kind: 'wait', ms: Math.min(plan.ms, check) };
+    return plan;
+}
+function cardPlan(state, now, grace) {
     const prompts = state.prompts.filter(seen);
     if (prompts.length === 0)
         return state.card ? { kind: 'cancel' } : { kind: 'done' };
@@ -615,6 +639,104 @@ export async function sessionPosted(path) {
         await file.close().catch(() => { });
     }
 }
+const AGENT_ID = /^[A-Za-z0-9_-]{1,100}$/;
+function callsOf(state, prompt) {
+    const transcript = state.transcript;
+    if (!transcript)
+        return [];
+    const agent = prompt.agent;
+    if (!agent)
+        return [{ path: transcript, mine: (entry) => entry.isSidechain !== true }];
+    if (!AGENT_ID.test(agent))
+        return [];
+    const folder = join(dirname(transcript), basename(transcript, '.jsonl'));
+    return [
+        { path: join(folder, 'subagents', `agent-${agent}.jsonl`), mine: () => true },
+        { path: transcript, mine: (entry) => entry.isSidechain === true && entry.agentId === agent },
+    ];
+}
+async function callState(calls, prompt) {
+    let file;
+    try {
+        file = await open(calls.path, 'r');
+    }
+    catch {
+        return null;
+    }
+    try {
+        const size = (await file.stat()).size;
+        let position = size;
+        let carry = Buffer.alloc(0);
+        const results = new Set();
+        let sameTool = null;
+        let found = null;
+        const read = (line) => {
+            if (!line.includes('tool_'))
+                return;
+            let entry;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                return;
+            }
+            if (!isObject(entry) || !calls.mine(entry))
+                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;
+                const id = text(block.tool_use_id) || text(block.id);
+                if (block.type === 'tool_result' && id)
+                    results.add(id);
+                else if (block.type === 'tool_use' && entry.type === 'assistant' && found === null) {
+                    const tool = text(block.name);
+                    if (promptKey(tool, block.input, prompt.agent) === prompt.key)
+                        found = results.has(id) ? 'answered' : 'waiting';
+                    else if (sameTool === null && prompt.tool && tool === prompt.tool)
+                        sameTool = id;
+                }
+            }
+        };
+        while (found === null && 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 (found === null && newline !== -1) {
+                read(buffer.subarray(newline + 1).toString('utf8'));
+                buffer = buffer.subarray(0, newline);
+                newline = buffer.lastIndexOf(10);
+            }
+            carry = buffer;
+        }
+        if (found === null && position === 0)
+            read(carry.toString('utf8'));
+        if (found !== null)
+            return found;
+        if (sameTool !== null)
+            return results.has(sameTool) ? 'answered' : 'waiting';
+        return 'waiting';
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await file.close().catch(() => { });
+    }
+}
+async function stillAsked(state, prompt) {
+    for (const calls of callsOf(state, prompt)) {
+        const found = await callState(calls, prompt);
+        if (found)
+            return found === 'waiting';
+    }
+    return true;
+}
+const promptId = (prompt) => `${prompt.key}:${prompt.at}`;
 export function remoteOf(url) {
     const plain = url
         .trim()
@@ -675,7 +797,7 @@ const byAgent = (state, prompt) => appOf(state) === 'claude-code' && Boolean(pro
 function changeNoteOf(state, prompt) {
     if (prompt.doing === 'to answer its question')
         return cut(`Now waiting for your answer: ${prompt.what}`, 120);
-    const agent = byAgent(state, prompt) ? BACKGROUND_AGENT : '';
+    const agent = byAgent(state, prompt) ? SUBAGENT : '';
     return `${cut(`Now waiting for your OK: ${prompt.what}`, 120 - [...agent].length)}${agent}`;
 }
 function cardWords(io, state, prompt, name, machine) {
@@ -686,10 +808,16 @@ function cardWords(io, state, prompt, name, machine) {
         : `is waiting for your OK${prompt.doing ? ` ${prompt.doing}` : ''}`;
     const why = prompt.reason ? ` It says: “${prompt.reason}”.` : '';
     const where = `in ${tilde(io, state.cwd)} on ${machine}`;
-    const asker = byAgent(state, prompt)
-        ? `A background agent${prompt.agentType ? ` (${prompt.agentType})` : ''} of ${who}, ${where},`
+    const subagent = byAgent(state, prompt);
+    const asker = subagent
+        ? `A subagent${prompt.agentType ? ` (${prompt.agentType})` : ''} of ${who}, ${where},`
         : `${who} ${where}`;
-    const summary = cut(`${asker} ${waiting}.${why} It goes on once you answer it there.`, 400);
+    const needs = !subagent
+        ? waiting
+        : prompt.doing === 'to answer its question'
+            ? 'needs your answer to its question'
+            : `needs your permission${prompt.doing ? ` ${prompt.doing}` : ''}`;
+    const summary = cut(`${asker} ${needs}.${why} It goes on once you answer it there.`, 400);
     const place = `${APP_NAMES[app]} on ${machine}`;
     const linked = state.link ? `${place}, ${state.link}` : place;
     return {
@@ -817,6 +945,24 @@ async function withdraw(io, client, card, state, how) {
                 .catch(() => { });
     }
 }
+async function check(io, state, worker) {
+    const now = io.now();
+    const due = state.prompts.filter((prompt) => unchecked(prompt) && prompt.at + QUIET_GRACE_MS <= now);
+    const waiting = new Map();
+    for (const prompt of due)
+        waiting.set(promptId(prompt), await stillAsked(state, prompt));
+    await record(io, state.session, worker, (state) => {
+        const left = state.prompts.filter((prompt) => waiting.get(promptId(prompt)) !== false);
+        if (left.length < state.prompts.length) {
+            state.prompts = left;
+            state.settled = 'answered';
+            state.at = now;
+        }
+        for (const prompt of left)
+            if (unchecked(prompt) && waiting.get(promptId(prompt)))
+                prompt.waited = now;
+    });
+}
 const renew = (io, session, worker) => record(io, session, worker, () => { });
 async function letGo(io, session, worker, grace) {
     let done = true;
@@ -871,6 +1017,10 @@ export async function permissionWorker(io, options) {
                 await io.sleep(Math.min(plan.ms, NAP_MS), io.signal);
                 continue;
             }
+            if (plan.kind === 'check') {
+                await check(io, state, worker);
+                continue;
+            }
             try {
                 client ??= await mcpClient(io, state.origin, appOf(state), CALL_MS);
                 if (plan.kind === 'post')

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.32.0';
+export const VERSION = '0.32.2';

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

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

package/mod/hooks/register.js

@@ -1,7 +1,7 @@
 // Generated from packages/claude-plugin/src/wake/register.ts in recordplane/pendingyou: edit that, then run
 // `pnpm --filter @pendingyou/claude-plugin generate`.
 
-import { argumentsOf, blockedNote, CLAIM_PREFIX, CLI_COPY, cardTool, checked, claimLease, cliConfigOf, connectionOf, dueCards, emptyBook, failed, folderOf, HANDED_FAST_MS, HANDED_READS, HERDR_EVERY_MS, HERDR_RUN_MS, handedDue, handedNext, handedOf, handedText, handedView, herdrArgv, herdrPayload, holdOf, holdReply, inHerdr, isRefusal, isStale, isWaitingOnYou, KEEP_MS, learn, leaseHolder, loadedNote, loadedPath, momentOf, originOf, PRESENCE_EVERY_MS, PRESENCE_RUN_MS, presenceArgv, prompted, put, readBook, readClaim, readSetup, readSince, resultObject, SETUP_AFTER_MS, SETUP_RETRY_MS, SETUP_SERVER, SETUP_TRIES, settle, setUpOf, setupNeeded, setupPrompt, stateOf, statusText, TICK_MS, takesHanded, told, toTell, untold, wakeText, } from "./wake.js";
+import { argumentsOf, blockedNote, CLAIM_PREFIX, CLI_COPY, cardTool, checked, claimLease, cliConfigOf, connectionOf, dueCards, emptyBook, failed, folderOf, HANDED_FAST_MS, HANDED_READS, HERDR_EVERY_MS, HERDR_RUN_MS, handedDue, handedNext, handedOf, handedText, handedView, herdrArgv, herdrPayload, holdOf, holdReply, inHerdr, isFresh, isRefusal, isStale, isWaitingOnYou, KEEP_MS, learn, leaseHolder, loadedNote, loadedPath, momentOf, originOf, PRESENCE_EVERY_MS, PRESENCE_RUN_MS, presenceArgv, prompted, put, readBook, readClaim, readSetup, readSince, resultObject, SETUP_AFTER_MS, SETUP_RETRY_MS, SETUP_SERVER, SETUP_TRIES, settle, setUpOf, setupNeeded, setupPrompt, stateOf, statusText, TICK_MS, takesHanded, told, toTell, untold, wakeText, } from "./wake.js";
 const RETRY_MS = 60_000;
 const live = {
     me: '',
@@ -141,11 +141,20 @@ async function check($, requestId) {
 async function deliver($) {
     if (live.busy)
         return false;
-    const cards = toTell(live.book);
-    if (cards.length === 0 || (await $.clock.now()) < live.quietUntil)
+    if (toTell(live.book).length === 0 || (await $.clock.now()) < live.quietUntil)
         return false;
     if (!(await claim($)))
         return false;
+    const before = await $.clock.now();
+    for (const card of toTell(live.book))
+        if (!isFresh(card, before))
+            await check($, card.requestId);
+    if (live.busy)
+        return false;
+    const now = await $.clock.now();
+    const cards = toTell(live.book).filter((card) => isFresh(card, now));
+    if (cards.length === 0)
+        return false;
     live.book = told(live.book, cards);
     await save($);
     $.prompt.submit({ text: wakeText(cards) }).catch(async () => {

package/mod/hooks/wake.js

@@ -8,6 +8,7 @@ export const RECENT_MS = 30 * 60_000;
 export const MAX_BACKOFF_MS = 15 * 60_000;
 export const HINT_FLOOR_MS = 5000;
 export const BLOCKED_MS = 60_000;
+export const FRESH_MS = 10_000;
 export const KEEP_MS = 7 * 24 * 60 * 60_000;
 export const MAX_CARDS = 50;
 export const LEASE_MS = 60_000;
@@ -231,6 +232,13 @@ function tracked(book, facts, now) {
         nextAt: now + FAST_MS,
     });
 }
+function followedUp(book, follows, now) {
+    const card = follows ? book.cards[follows] : undefined;
+    if (!card)
+        return book;
+    const heard = card.state && isReady(card.state) ? { seen: momentOf(card.state) } : {};
+    return put(book, { ...card, ...heard, nextAt: now });
+}
 export function learn(book, call, now) {
     const { server, tool, input, output } = call;
     if (!output)
@@ -251,7 +259,7 @@ export function learn(book, call, now) {
             if (!status || !OPEN.has(status) || version === undefined)
                 return next;
             const title = text(input.title, 400);
-            return tracked(next, {
+            const posted = tracked(next, {
                 requestId,
                 server,
                 ...(name ? { name } : {}),
@@ -259,6 +267,7 @@ export function learn(book, call, now) {
                 pressing: pressingFrom(tool, input, card),
                 state: { status, turn: 'you', version, cursor: card?.state?.cursor ?? '' },
             }, now);
+            return tool === 'post_request' ? followedUp(posted, requestIdOf(input.follows), now) : posted;
         }
         case 'reply_in_thread': {
             const reopen = isObject(input.reopen) ? input.reopen : null;
@@ -311,7 +320,7 @@ export function checked(card, output, now) {
     if (!isReady(state) && pollAfter !== undefined && pollAfter * 1000 < wait)
         wait = Math.max(HINT_FLOOR_MS, pollAfter * 1000 + 1000);
     const { failures: _failures, ...rest } = card;
-    return { ...rest, state, changedAt, nextAt: now + wait };
+    return { ...rest, state, changedAt, nextAt: now + wait, checkedAt: now };
 }
 export function failed(card, now, blocked) {
     if (blocked)
@@ -332,13 +341,16 @@ export function needsTelling(card) {
     const state = card.state;
     if (!state || !isReady(state))
         return false;
+    if (state.status === 'resolved')
+        return false;
     const moment = momentOf(state);
     if (moment === card.told || moment === card.seen)
         return false;
-    if ((state.status === 'resolved' || state.status === 'cancelled') && (card.told || card.seen))
+    if (state.status === 'cancelled' && (card.told || card.seen))
         return false;
     return true;
 }
+export const isFresh = (card, now) => card.checkedAt !== undefined && now - card.checkedAt <= FRESH_MS;
 export const toTell = (book) => Object.values(book.cards)
     .filter(needsTelling)
     .sort((a, b) => a.changedAt - b.changedAt);
@@ -385,8 +397,6 @@ function line(card) {
             ];
         case 'cancelled':
             return [`${titled(card)} was withdrawn`, 'nothing to do'];
-        case 'resolved':
-            return [`${titled(card)} is already handled`, 'nothing to do'];
         case 'answered':
             if (state.handled === 'self')
                 return [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pendingyou",
-  "version": "0.32.0",
+  "version": "0.32.2",
   "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",