pendingyou 0.32.1 → 0.32.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # 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

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.1';
+export const VERSION = '0.32.2';

package/package.json

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