pendingyou 0.15.0 → 0.16.0

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## 0.16.0 (2026-10-05)
+
+- A word on one of your own cards that's neither an answer nor your person's (guide 2.32): `/mcp/cli/answers` marks it
+  `notice` (`{ kind, from }`), and the hold, the pickup, the hooks and `watch` say what it is instead of “they wrote
+  back”:
+  - `follow_up`: the helper that answered it for your person followed up afterwards (“shipped in #231”): “Pending You:
+    pending-you-chief followed up on req_…, which it answered for your person.”, the question, its words, then “Act on
+    it if it needs anything, then call ack_answer … to mark it heard.” On an answer you haven't picked up yet, its
+    words come with the answer (“Also: …”).
+  - `handed_over`: your person handed your open cards to another assistant: “Pending You: your person handed your open
+    cards to pending-you-chief, req_… among them.” and “Stop working on them: pending-you-chief answers them and
+    follows up. Call ack_answer … to say you’ve stopped.”
+  `watch` gives both as `message_ready`. A command line before 0.16.0 hears the same words as a message from them.
+- Claude Code's permission prompts get a card in bypassPermissions mode too: a dangerous request from a background
+  agent there waited minutes for an OK with no card. Claude Code still asks for a few things in that mode (a dangerous
+  `rm`, an ask rule, a safety check it can't verify), but the PermissionRequest hook skipped bypassPermissions and
+  dontAsk mode outright. It also runs for a call Claude Code then denies by itself, showing
+  nothing, so in those two modes it now writes the prompt down quietly, and its card goes up only once a dialog is on
+  screen. A new Notification hook says so: `pendingyou-hook notify --app claude-code`, with the matcher
+  `permission_prompt`, so Claude Code runs it only for a dialog that has waited about six seconds with nobody typing,
+  and never for its other notifications. A call denied without a dialog never gets a card: its PostToolUseFailure, the
+  same agent's next call, your next message or the end of the turn settles it. In the other modes a card still goes up
+  after 10 seconds, or as soon as the Notification comes.
+- A dialog no PermissionRequest hook ran for (a sandboxed command's network request; one a Claude Code ran none for)
+  gets a card from its Notification alone: “Claude Code is waiting for your OK”, with Claude Code's own words, redacted,
+  in its summary (“It says: “Claude needs your permission”.”). Whose dialog it was isn't known, so only a turn that ends
+  with no subagent running, or the session's end, takes it down.
+- A background agent's prompt says so: “Claude Code is waiting for your OK: pnpm lint && git push (a background
+  agent)”, and its summary names the agent's type (“A background agent (general-purpose) of Claude Code
+  (billing-webhooks), in ~/… on work-mbp, is waiting for your OK to run a command.”). It stays on the session's one card,
+  and only that agent's own calls settle it, not the session's or another agent's.
+- `init` adds the Notification hook at the end of Claude Code's Notification hooks, after any of your own, and says so
+  on a computer set up before (“Added a Notification hook to the permission-prompt hooks: …”); `status` marks the
+  Permission prompts line missing without it; `uninstall` and `--no-permission-cards` take it out with the others.
+  Codex is unchanged: it has no hook that says a dialog is on screen (its `notify` runs only when a turn completes).
+
 ## 0.15.0 (2026-10-05)
 
 - Presence: Pending You hears which of your agents' sessions are open right now. Each app tells it with its own

package/README.md

@@ -246,6 +246,14 @@ a key are blanked (`curl -H "Authorization: …" https://api.example.com/items?t
 shown safely (several lines, inline code like `node -e`, one that takes a secret) shows only as “Bash: node …”. No card
 for `claude -p` or the Agent SDK, where nobody sees a prompt.
 
+In bypassPermissions mode (`--dangerously-skip-permissions`) Claude Code still asks for a few things: a dangerous `rm`,
+an ask rule of yours, a safety check it can't verify. Since 0.16.0 those get a card too, once Claude Code says the
+dialog has waited a few seconds with nobody typing (its Notification hook, which `init` adds for permission dialogs
+only): a call it denies by itself, showing you nothing, never gets one. The same hook puts up a card for a dialog no
+other hook sees (a sandboxed command asking for the network), in Claude Code's own words, and in the other modes puts
+a card up as soon as Claude Code says so, without waiting the full 10 seconds. A background agent's prompt says so:
+“Claude Code is waiting for your OK: pnpm lint && git push (a background agent)”.
+
 It needs Claude Code 2.1.119 or later, signing in through this computer's sign-in (not `--oauth`), and isn't on
 Windows yet. Don't want it? `npx pendingyou init --no-permission-cards` (later runs keep it off; `--permission-cards`
 turns it back on). `npx pendingyou status` says which.

package/dist/apps/claude-code.js

@@ -199,8 +199,10 @@ export const claudeCode = {
 };
 function permissionLine(io, claude, manifest, helper, flag) {
     const label = 'Permission prompts:';
-    if (claude.permission)
+    if (claude.permission && claude.notify)
         return `  ok      ${label} a card when Claude Code waits for your OK`;
+    if (claude.permission)
+        return `  missing ${label} no card for a dialog in bypassPermissions mode, or one the other hooks don’t see; run npx pendingyou@latest init${flag}`;
     if (manifest?.permissionCards === false)
         return `          ${label} off, as you chose; for a card when Claude Code waits for your OK, run npx pendingyou init --permission-cards${flag}`;
     const blocker = claude.claude

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, isClosed } from "../format.js";
+import { clip, delegatedOf, isClosed, noticeOf } from "../format.js";
 import { chooseThread, goesBy, HANDED_FOR_MS, handedCard, handedMessage, namesAnotherComputer, } from "../handed.js";
 import { macName, tailscaleName } from "../remote.js";
 import { claimHanded, markHanded, momentOf, releaseHanded, wasHanded } from "../state.js";
@@ -310,6 +310,18 @@ function line(heard, card) {
         .replaceAll('”', '’')}” (${heard.requestId})`;
     const named = card.name ?? heard.sessionLabel;
     const get = `get_request (requestId ${heard.requestId}, ${named ? `name “${named}”` : 'your name'})`;
+    const notice = noticeOf(heard);
+    const from = notice ? clip(notice.from, 60).text : '';
+    if (notice?.kind === 'handed_over')
+        return [
+            `your person handed your open cards to ${from}, ${titled} among them`,
+            `stop working on them: ${from} answers them and follows up; ack_answer ${heard.requestId} with its version to say you’ve stopped`,
+        ];
+    if (notice?.kind === 'follow_up' && heard.status !== 'answered')
+        return [
+            `${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`,
+        ];
     switch (heard.status) {
         case 'expired':
             return [
@@ -339,7 +351,7 @@ export function wakeMessage(ready) {
     });
     if (lines.length === 0)
         return null;
-    const asked = lines.some(({ heard }) => heard.turn === 'agent' && heard.status !== 'expired');
+    const asked = lines.some(({ heard }) => heard.turn === 'agent' && heard.status !== 'expired' && !noticeOf(heard));
     const reopen = asked
         ? ' If they asked you something or you need more from them, reply_in_thread with reopen instead.'
         : '';

package/dist/args.js

@@ -63,6 +63,7 @@ const COMMANDS = new Set([
     'mcp',
     'permission',
     'permission-done',
+    'notify',
     'permission-card',
     'presence',
 ]);
@@ -88,6 +89,7 @@ const FLAGS = {
     listen: { origin: true, app: true, thread: true, handed: false },
     permission: { origin: true, app: true },
     'permission-done': { origin: true, app: true },
+    notify: { origin: true, app: true },
     'permission-card': { origin: true, session: true, worker: true },
     presence: {
         origin: true,
@@ -154,6 +156,7 @@ export const HOOK_COMMANDS = new Set([
     'posted',
     'permission',
     'permission-done',
+    'notify',
     'presence',
 ]);
 const THREAD = /^[A-Za-z0-9][A-Za-z0-9_-]{0,99}$/;
@@ -315,6 +318,7 @@ export function parseArgs(argv, env = {}) {
         }
         case 'permission':
         case 'permission-done':
+        case 'notify':
             none();
             return { name: first, origin, ...app() };
         case 'permission-card': {

package/dist/claude.js

@@ -26,6 +26,7 @@ export const PERMISSION_HOOKS = [
     { event: 'PostToolUse', sub: 'permission-done' },
     { event: 'PostToolUseFailure', sub: 'permission-done' },
     { event: 'SessionEnd', sub: 'permission-done', timeout: null },
+    { event: 'Notification', sub: 'notify', matcher: 'permission_prompt' },
 ];
 export const PERMISSION_CLAUDE = '2.1.119';
 export const PERMISSIONS = ['Bash(npx pendingyou hold:*)', `mcp__${MCP_NAME}`];
@@ -337,7 +338,11 @@ export async function installClaude(io, origin, options) {
     const permissionLines = wanted && !blocker
         ? Object.fromEntries(PERMISSION_HOOKS.map((spec) => [spec.event, options.hookLine(spec.sub)]))
         : null;
-    const merged = mergeSettings(await readSettings(io), commands, permissionLines);
+    const settings = await readSettings(io);
+    const had = hooksOf(settings, 'Claude Code’s settings');
+    const upgrade = Boolean(findHook(had, 'PermissionRequest', 'permission')) &&
+        !findHook(had, 'Notification', 'notify');
+    const merged = mergeSettings(settings, commands, permissionLines);
     report({
         ok: true,
         text: merged.hooksChanged
@@ -349,7 +354,9 @@ export async function installClaude(io, origin, options) {
         ok: true,
         text: permissionLines
             ? merged.permissionChanged
-                ? 'Added the permission-prompt hooks: when Claude Code waits for your OK and you don’t answer within a few seconds, a card says so (a push only after your hand-off wait), and it goes once you answer in Claude Code.'
+                ? upgrade
+                    ? 'Added a Notification hook to the permission-prompt hooks: a dialog in bypassPermissions mode gets a card too, and so does one the other hooks don’t see, once Claude Code says it has waited a few seconds.'
+                    : 'Added the permission-prompt hooks: when Claude Code waits for your OK and you don’t answer within a few seconds, a card says so (a push only after your hand-off wait), and it goes once you answer in Claude Code.'
                 : 'The permission-prompt hooks were already installed.'
             : !wanted
                 ? `${merged.permissionChanged ? 'Took out the permission-prompt hooks' : 'Left out the permission-prompt hooks'}, as you asked: no card when Claude Code waits for your OK. To turn them on: npx pendingyou init --permission-cards${flag}`
@@ -470,6 +477,7 @@ export async function claudeState(io) {
     const skill = (await readText(skillPath(io))) !== null;
     let ours = (_event) => undefined;
     let permission = false;
+    let notify = false;
     const mod = { loads: false, dirs: [], present: false, plugin: false };
     const loads = claude ? claudeVersion(claude) : null;
     mod.loads = loads !== null && loadsMods(loads);
@@ -482,6 +490,7 @@ export async function claudeState(io) {
         const all = objectAt(settings, 'hooks') ?? {};
         ours = (event) => findHook(all, event, HOOKS[event]);
         permission = Boolean(findHook(all, 'PermissionRequest', 'permission'));
+        notify = Boolean(findHook(all, 'Notification', 'notify'));
     }
     catch { }
     const start = ours('SessionStart');
@@ -496,6 +505,7 @@ export async function claudeState(io) {
         hooks: Boolean(start && ours('UserPromptSubmit')),
         stopcheck: Boolean(ours('Stop')),
         permission,
+        notify,
         presence: Boolean(ours('SessionEnd')),
         form: form ? { ...form, runs: await hookRuns(form), shim } : null,
         mod,

package/dist/format.js

@@ -1,3 +1,12 @@
+export function noticeOf(heard) {
+    const given = heard.notice;
+    if (typeof given !== 'object' || given === null)
+        return null;
+    const { kind, from } = given;
+    if ((kind !== 'follow_up' && kind !== 'handed_over') || typeof from !== 'string')
+        return null;
+    return { kind, from };
+}
 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.';
@@ -81,11 +90,37 @@ function describeHanded(heard, delegated) {
         ...(note?.cut ? [`(Cut short: get_request ${id} has all of it.)`] : []),
     ];
 }
+function describeNotice(heard, notice) {
+    const id = heard.requestId;
+    const from = clip(notice.from, MAX_NAME).text;
+    const ack = `ack_answer with requestId ${id}, name ${named(heard)} and expectedVersion ${heard.version}`;
+    if (notice.kind === 'handed_over')
+        return [
+            `Pending You: your person handed your open cards to ${from}, ${id} among them.`,
+            `Stop working on them: ${from} answers them and follows up. Call ${ack} to say you’ve stopped.`,
+        ];
+    let cut = false;
+    const wrote = heard.messages.map((message) => {
+        const said = quoted(message.body, MAX_MESSAGE);
+        cut ||= said.cut;
+        return said.line;
+    });
+    return [
+        `Pending You: ${from} followed up on ${id}, which it answered for your person.`,
+        `Question: ${clip(heard.title, MAX_TITLE).text}`,
+        ...wrote,
+        `Act on it if it needs anything, then call ${ack} to mark it heard.`,
+        ...(cut ? [`(Cut short: get_request ${id} has all of it.)`] : []),
+    ];
+}
 export function describe(heard, again) {
     const id = heard.requestId;
     const delegated = delegatedOf(heard);
     if (delegated)
         return describeHanded(heard, delegated);
+    const notice = noticeOf(heard);
+    if (notice && heard.status !== 'answered')
+        return describeNotice(heard, notice);
     const question = `Question: ${clip(heard.title, MAX_TITLE).text}`;
     let cut = false;
     const wrote = heard.messages.map((message) => {
@@ -111,7 +146,7 @@ export function describe(heard, again) {
                 lines.push(`Pending You: ${id} is answered.`, question, `Answer: ${answer.text}`);
             }
             if (wrote.length)
-                lines.push(`They also wrote: ${wrote.join(' ')}`);
+                lines.push(`${noticeOf(heard) ? 'Also' : 'They also wrote'}: ${wrote.join(' ')}`);
             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

@@ -46,7 +46,8 @@ async function run(io, command, hook = { fallback: '' }) {
         case 'posted':
             return posted(io, { origin: command.origin, app: command.app ?? DEFAULT_APP });
         case 'permission':
-        case 'permission-done': {
+        case 'permission-done':
+        case 'notify': {
             const app = command.app ?? DEFAULT_APP;
             if (!isPromptApp(app))
                 return 0;

package/dist/permission.js

@@ -13,6 +13,10 @@ 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)';
+const QUIET_MODES = new Set(['bypassPermissions', 'dontAsk']);
+export const NOTICE_MS = 4000;
+const BATCH_MS = 1000;
 export const PROMPT_APPS = ['claude-code', 'codex'];
 const CLAUDE = 'claude-code';
 export const isPromptApp = (app) => PROMPT_APPS.includes(app);
@@ -47,9 +51,10 @@ function canonical(value) {
     return JSON.stringify(value) ?? 'null';
 }
 const ANSWERED_IN_INPUT = new Set(['AskUserQuestion', 'ExitPlanMode']);
-export function promptKey(tool, input) {
+export function promptKey(tool, input, agent) {
     const what = ANSWERED_IN_INPUT.has(tool) ? '' : canonical(input ?? {});
-    return createHash('sha256').update(`${tool}\n${what}`).digest('hex').slice(0, 32);
+    const whose = agent ? `${agent}\n` : '';
+    return createHash('sha256').update(`${whose}${tool}\n${what}`).digest('hex').slice(0, 32);
 }
 const text = (value) => (typeof value === 'string' ? value : '');
 function commandText(value) {
@@ -134,6 +139,20 @@ 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}`;
+const noticeWords = (message) => redactText(text(message), 120);
+function noticeOf(message, now) {
+    return {
+        key: promptKey('Notification', { message }),
+        title: cut(WAITING, TITLE_MAX),
+        what: message || 'a dialog in Claude Code',
+        doing: '',
+        ...(message ? { reason: message } : {}),
+        notice: true,
+        shown: now,
+        at: now,
+    };
+}
 async function load(io, session) {
     const file = await readJson(pathOf(io, session)).catch(() => null);
     if (!isObject(file) || !Array.isArray(file.prompts) || typeof file.origin !== 'string')
@@ -152,6 +171,7 @@ 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;
 function claim(state, now) {
     if (alive(state, now))
         return null;
@@ -169,10 +189,19 @@ function startWorker(io, origin, session, worker) {
         ...(origin === DEFAULT_ORIGIN ? [] : ['--origin', origin]),
     ]);
 }
-const sessionOf = (input) => {
-    const id = text(input.session_id);
-    return SESSION.test(id) ? id : null;
-};
+const SUBAGENT_TRANSCRIPT = /^(.*)([/\\])([A-Za-z0-9][A-Za-z0-9_-]{0,99})[/\\]subagents[/\\][^/\\]+\.jsonl$/;
+function whereOf(input) {
+    const transcript = text(input.transcript_path);
+    const parent = text(input.agent_id) ? SUBAGENT_TRANSCRIPT.exec(transcript) : null;
+    if (parent) {
+        const [, folder = '', slash = '/', session = ''] = parent;
+        return { session, transcript: `${folder}${slash}${session}.jsonl` };
+    }
+    const session = text(input.session_id);
+    return SESSION.test(session) ? { session, transcript } : null;
+}
+const agentOf = (input) => text(input.agent_id).slice(0, 100);
+const agentTypeOf = (input) => cut(text(input.agent_type).replace(/[^\w.:-]/g, ''), 40);
 const keyInput = (app, input) => {
     if (app !== 'codex' || !isObject(input) || !('description' in input))
         return input;
@@ -185,59 +214,76 @@ function reasonOf(app, input) {
     const reason = redactText(text(input.description).replace(/\s+/g, ' ').trim(), 120);
     return reason || null;
 }
+const wentOn = (agent, now) => (prompt) => Boolean(prompt.quiet) && (prompt.agent ?? '') === agent && prompt.at <= now - BATCH_MS;
 async function asked(io, origin, input, app) {
     if (io.platform === 'win32')
         return;
-    if (app === 'claude-code') {
-        if (/^sdk-/.test(io.env.CLAUDE_CODE_ENTRYPOINT ?? ''))
-            return;
-        if (input.permission_mode === 'dontAsk' || input.permission_mode === 'bypassPermissions')
-            return;
-    }
-    const session = sessionOf(input);
+    if (app === 'claude-code' && /^sdk-/.test(io.env.CLAUDE_CODE_ENTRYPOINT ?? ''))
+        return;
+    const where = whereOf(input);
     const tool = text(input.tool_name);
-    if (!session || !tool)
+    if (!where || !tool)
         return;
     if ((await readCredential(io, origin, app))?.kind !== 'connection')
         return;
     const now = io.now();
-    const agent = text(input.agent_id);
+    const agent = agentOf(input);
+    const subagent = app === 'claude-code' ? agent : '';
+    const agentType = subagent ? agentTypeOf(input) : '';
+    const quiet = app === 'claude-code' && QUIET_MODES.has(text(input.permission_mode));
+    const words = promptWords(tool, isObject(input.tool_input) ? input.tool_input : {}, io.home, app);
     const prompt = {
-        key: promptKey(tool, keyInput(app, input.tool_input)),
+        key: promptKey(tool, keyInput(app, input.tool_input), subagent || undefined),
         ...(app === 'codex' ? { tool: tool.slice(0, 100) } : {}),
         ...(reasonOf(app, input.tool_input)
             ? { reason: reasonOf(app, input.tool_input) }
             : {}),
-        ...promptWords(tool, isObject(input.tool_input) ? input.tool_input : {}, io.home, app),
-        ...(agent ? { agent: agent.slice(0, 100) } : {}),
+        ...words,
+        ...(subagent ? { title: fromAgent(words.title) } : {}),
+        ...(agent ? { agent } : {}),
+        ...(agentType ? { agentType } : {}),
+        ...(quiet ? { quiet: true } : {}),
         at: now,
     };
     const cwd = text(input.cwd) || io.cwd;
-    const transcript = text(input.transcript_path);
     const link = app === 'claude-code' ? sessionLink(io.env) : null;
     let worker = null;
-    await change(io, session, (state) => {
-        const next = state ?? { version: 1, origin, session, cwd, prompts: [], at: now };
+    await change(io, where.session, (state) => {
+        const next = state ?? {
+            version: 1,
+            origin,
+            session: where.session,
+            cwd,
+            prompts: [],
+            at: now,
+        };
         next.origin = origin;
         if (app === 'claude-code')
             delete next.app;
         else
             next.app = app;
-        next.cwd = cwd;
-        if (transcript)
-            next.transcript = transcript;
+        if (!state || !subagent)
+            next.cwd = cwd;
+        if (where.transcript && (!subagent || !next.transcript))
+            next.transcript = where.transcript;
         if (link)
             next.link = link;
+        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;
-        worker = claim(next, now);
+        if (!quiet || (dropped && next.card))
+            worker = claim(next, now);
         return next;
     });
     if (worker)
-        startWorker(io, origin, session, worker);
+        startWorker(io, origin, where.session, worker);
 }
 async function settle(io, session, which, how) {
     const before = await load(io, session);
@@ -256,8 +302,8 @@ async function settle(io, session, which, how) {
         state.prompts = left;
         state.settled = how;
         state.at = now;
-        if (!state.card && left.length === 0)
-            return alive(state, now) ? state : null;
+        if (!state.card && !left.some(seen))
+            return left.length > 0 || alive(state, now) ? state : null;
         worker = claim(state, now);
         return state;
     });
@@ -265,16 +311,18 @@ async function settle(io, session, which, how) {
         startWorker(io, origin, session, worker);
 }
 async function ran(io, input, app) {
-    const session = sessionOf(input);
+    const where = whereOf(input);
     const tool = text(input.tool_name);
-    if (!session || !tool)
+    if (!where || !tool)
         return;
-    const key = promptKey(tool, keyInput(app, input.tool_input));
-    const before = await load(io, session);
+    const agent = agentOf(input);
+    const key = promptKey(tool, keyInput(app, input.tool_input), app === 'claude-code' ? agent || undefined : undefined);
+    const before = await load(io, where.session);
     if (!before?.prompts.length)
         return;
     const exact = before.prompts.some((prompt) => prompt.key === key);
-    await settle(io, session, exact || app !== 'codex' ? (prompt) => prompt.key === key : (prompt) => prompt.tool === tool, 'answered');
+    const movedOn = wentOn(agent, io.now());
+    await settle(io, where.session, (prompt) => prompt.key === key || (app === 'codex' ? !exact && prompt.tool === tool : movedOn(prompt)), 'answered');
 }
 export async function endPrompts(io, session) {
     try {
@@ -288,7 +336,7 @@ export async function settlePrompts(io, input) {
         if (!input.session || !SESSION.test(input.session))
             return;
         const subagentsDone = input.event === 'stop' && !input.subagents;
-        await settle(io, input.session, (prompt) => !prompt.agent || subagentsDone, 'answered');
+        await settle(io, input.session, (prompt) => (!prompt.agent && !prompt.notice) || subagentsDone, 'answered');
     }
     catch { }
 }
@@ -299,6 +347,64 @@ export function subagentsRunning(input) {
         task.type === 'subagent' &&
         !['completed', 'failed', 'killed', 'cancelled', 'stopped'].includes(text(task.status)));
 }
+function noticeMsOf(env) {
+    const given = Number(env.PENDINGYOU_PERMISSION_NOTICE_MS);
+    return Number.isInteger(given) && given >= 0 ? given : NOTICE_MS;
+}
+async function notified(io, origin, input) {
+    if (io.platform === 'win32')
+        return;
+    if (/^sdk-/.test(io.env.CLAUDE_CODE_ENTRYPOINT ?? ''))
+        return;
+    if (input.notification_type !== 'permission_prompt')
+        return;
+    const where = whereOf(input);
+    if (!where)
+        return;
+    if ((await readCredential(io, origin, CLAUDE))?.kind !== 'connection')
+        return;
+    const now = io.now();
+    const before = now - noticeMsOf(io.env);
+    const message = noticeWords(input.message);
+    const cwd = text(input.cwd) || io.cwd;
+    const link = sessionLink(io.env);
+    let worker = null;
+    await change(io, where.session, (state) => {
+        const next = state ?? {
+            version: 1,
+            origin,
+            session: where.session,
+            cwd,
+            prompts: [],
+            at: now,
+        };
+        next.origin = origin;
+        delete next.app;
+        next.cwd = cwd;
+        if (where.transcript)
+            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);
+        if (shows) {
+            shows.shown = now;
+            delete shows.failed;
+        }
+        else if (next.prompts.some((prompt) => prompt.shown !== undefined)) {
+            return state;
+        }
+        else
+            next.prompts = [...next.prompts, noticeOf(message, now)].slice(-MAX_PROMPTS);
+        delete next.settled;
+        next.at = now;
+        worker = claim(next, now);
+        return next;
+    });
+    if (worker)
+        startWorker(io, origin, where.session, worker);
+}
 export async function permissionHook(io, options) {
     const app = options.app ?? CLAUDE;
     try {
@@ -313,10 +419,14 @@ export async function permissionHook(io, options) {
             case 'PostToolUseFailure':
                 await ran(io, input, app);
                 break;
+            case 'Notification':
+                if (app === CLAUDE)
+                    await notified(io, options.origin, input);
+                break;
             case 'SessionEnd': {
-                const session = sessionOf(input);
-                if (session)
-                    await settle(io, session, () => true, 'ended');
+                const where = whereOf(input);
+                if (where)
+                    await settle(io, where.session, () => true, 'ended');
                 break;
             }
         }
@@ -324,22 +434,24 @@ 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 shownOf = (prompts) => (prompts.filter((prompt) => !prompt.notice).at(-1) ?? prompts.at(-1));
 export function planFor(state, now, grace) {
-    if (state.prompts.length === 0)
+    const prompts = state.prompts.filter(seen);
+    if (prompts.length === 0)
         return state.card ? { kind: 'cancel' } : { kind: 'done' };
-    const newest = state.prompts.at(-1);
     if (state.card) {
+        const newest = shownOf(prompts);
         if (state.card.key === newest.key)
             return { kind: 'done' };
-        const due = newest.at + grace - now;
+        const due = dueOf(newest, grace) - now;
         return due > 0 ? { kind: 'wait', ms: due } : { kind: 'update', prompt: newest };
     }
-    const live = state.prompts.filter((prompt) => !prompt.failed);
-    const oldest = live[0];
-    if (!oldest)
+    const live = prompts.filter((prompt) => !prompt.failed);
+    if (live.length === 0)
         return { kind: 'done' };
-    const due = oldest.at + grace - now;
-    return due > 0 ? { kind: 'wait', ms: due } : { kind: 'post', prompt: live.at(-1) };
+    const due = Math.min(...live.map((prompt) => dueOf(prompt, grace))) - now;
+    return due > 0 ? { kind: 'wait', ms: due } : { kind: 'post', prompt: shownOf(live) };
 }
 function graceOf(env) {
     const given = Number(env.PENDINGYOU_PERMISSION_GRACE_MS);
@@ -470,14 +582,25 @@ async function areaFor(io, client, state, name) {
         throw new McpFailure(-32000, 'Pending You made no area.');
     return areaId;
 }
+const byAgent = (state, prompt) => appOf(state) === 'claude-code' && Boolean(prompt.agent);
+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 : '';
+    return `${cut(`Now waiting for your OK: ${prompt.what}`, 120 - [...agent].length)}${agent}`;
+}
 function cardWords(io, state, prompt, name, machine) {
     const app = appOf(state);
     const who = name === defaultName(app) ? APP_NAMES[app] : `${APP_NAMES[app]} (${name})`;
     const waiting = prompt.doing === 'to answer its question'
         ? 'is waiting for your answer to its question'
-        : `is waiting for your OK ${prompt.doing}`;
+        : `is waiting for your OK${prompt.doing ? ` ${prompt.doing}` : ''}`;
     const why = prompt.reason ? ` It says: “${prompt.reason}”.` : '';
-    const summary = cut(`${who} in ${tilde(io, state.cwd)} on ${machine} ${waiting}.${why} It goes on once you answer it there.`, 400);
+    const where = `in ${tilde(io, state.cwd)} on ${machine}`;
+    const asker = byAgent(state, prompt)
+        ? `A background agent${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 place = `${APP_NAMES[app]} on ${machine}`;
     const linked = state.link ? `${place}, ${state.link}` : place;
     return {
@@ -548,9 +671,7 @@ async function update(io, client, state, prompt, worker) {
         requestId: card.requestId,
         name: card.name,
         expectedVersion,
-        changeNote: cut(prompt.doing === 'to answer its question'
-            ? `Now waiting for your answer: ${prompt.what}`
-            : `Now waiting for your OK: ${prompt.what}`, 120),
+        changeNote: changeNoteOf(state, prompt),
         title: prompt.title,
         summary: words.summary,
         action: words.action,

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.15.0';
+export const VERSION = '0.16.0';

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

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

package/mod/hooks/wake.js

@@ -346,6 +346,11 @@ function line(card) {
                 `your person answered ${titled(card)}`,
                 `call ${get}, act on their words, then ack_answer with its version and a one-line outcome`,
             ];
+        case 'delegated':
+            return [
+                `there’s word on ${titled(card)}, which your person handed to another assistant`,
+                `call ${get} and do what its helper.next says`,
+            ];
         default:
             return [
                 `your person wrote to you on ${titled(card)}`,
@@ -355,7 +360,9 @@ function line(card) {
 }
 const capital = (sentence) => sentence.charAt(0).toUpperCase() + sentence.slice(1);
 export function wakeText(cards) {
-    const asked = cards.some((card) => card.state?.turn === 'agent' && !isClosed(card.state.status));
+    const asked = cards.some((card) => card.state?.turn === 'agent' &&
+        !isClosed(card.state.status) &&
+        card.state.status !== 'delegated');
     const reopen = asked
         ? ' If they asked you something or you need more from them, reply_in_thread with reopen instead.'
         : '';

package/package.json

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