pendingyou 0.32.1 → 0.32.3

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.32.3 (2026-10-09)
+
+- Claude Code's and Codex's permission prompts get their cards. The worker posted each card without `context`, which
+  Pending You's `post_request` requires, so every post was refused, retried, and given up without a word: a prompt
+  left waiting in the terminal never reached the queue. The card now carries a `context` with only what it already
+  says (the prompt, as its title says it, and the session's link). The tests' pretend Pending You checks every
+  `post_request` and `update_request` with Pending You's own input schemas, so a card the server would refuse fails
+  them.
+
+## 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

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 {
@@ -707,6 +835,16 @@ function cardWords(io, state, prompt, name, machine) {
         },
     };
 }
+function contextOf(state, prompt) {
+    const app = appOf(state);
+    return {
+        background: `${APP_NAMES[app]} asked in its terminal; this card stands in for that dialog.`,
+        trace: [{ state: 'paused', text: prompt.title }],
+        filesTouched: [],
+        tried: [],
+        links: state.link ? [{ label: `The ${APP_NAMES[app]} session`, url: state.link }] : [],
+    };
+}
 async function record(io, session, worker, edit) {
     let ours = false;
     await change(io, session, (state) => {
@@ -731,6 +869,7 @@ async function post(io, client, state, prompt, worker) {
         kind: 'action',
         title: prompt.title,
         ...cardWords(io, state, prompt, name, machine),
+        context: contextOf(state, prompt),
         blocking: false,
         urgency: 'now',
         askedFirst: { where: 'terminal', askedAt: new Date(prompt.at).toISOString() },
@@ -817,6 +956,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 +1028,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.1';
+export const VERSION = '0.32.3';

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

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

package/package.json

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