pendingyou 0.34.1 → 0.35.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 0.35.0 (2026-10-09)
+
+- Claude Code hears a question handed to it within seconds. When you delegate a card to one of your Claude Code agents
+  (Delegate, or a card handed across), the wake mod no longer waits for its next look (every minute, or every 3
+  minutes after a quiet half hour): one session on the computer keeps a wait open with Pending You,
+  `pendingyou listen --handed --app claude-code`, which asks for handed questions alone and returns as soon as one
+  comes, and every session there looks at once. The session in the card's folder takes it, about 5 to 10 seconds after
+  you tap (the 5-second Undo hold included). The timer stays, as the fallback. Nothing to set up: it runs through the
+  hooks' shim `init` already wrote.
+- A session that can't tell its folder now leaves a question handed to a task in one for half a minute, not 5 minutes,
+  and looks again as that ends.
+- When sessions look together, only one tells it: each claims the question before reading it, and the last claim
+  stands.
+
+## 0.34.2 (2026-10-09)
+
+- Fixed: in bypassPermissions or dontAsk mode, a Claude Code dialog for a tool its agent had used before (a subagent's
+  second Bash) could get no card. Claude Code writes a prompted call to its transcript only once its dialog is
+  answered, so 20 seconds in the check for an unanswered call found the agent's earlier call of the same tool,
+  answered, and settled the prompt. Now only the prompt's own call counts: not in the transcript yet, it's still
+  waiting and its card goes up; the same command answered before the prompt was asked is an earlier call and doesn't
+  count; a call Claude Code denied by itself is written with its refusal at once, so it still gets no card. A
+  Notification picks the prompt it shows the same way, so it names the second call rather than putting up a card in
+  Claude Code's words.
+
 ## 0.34.1 (2026-10-09)
 
 - Fixed: a Claude Code permission prompt answered through the permission channel (`npx pendingyou claude`) could get

package/README.md

@@ -435,14 +435,16 @@ answers, once the 5-second window to undo is over:
   session in that folder that used Pending You most recently; never the one that asked, and never two. A sign-in that
   only hears (`--oauth`) hears every computer's, so it leaves one Pending You says went to another computer (by its
   name or its hostname); one that names no computer goes by the folder.
-- **Claude Code**: the wake mod looks for questions handed to the session's name (`list_pending`, every minute while
-  the session used Pending You in the last half hour, then every 3 minutes, for 12 hours), reads each with
+- **Claude Code**: within seconds since 0.35.0. One session on the computer keeps a wait open with Pending You for a
+  handed question (`listen --handed --app claude-code`, through the hooks' shim), and when one comes every session
+  there looks at once; otherwise the wake mod looks for questions handed to the session's name (`list_pending`, every
+  minute while the session used Pending You in the last half hour, then every 3 minutes, for 12 hours). It reads each with
   `get_request`, and starts a turn: “Pending You: your person handed you “Which AWS account for staging?” (req_…), a
   question from billing-webhooks (answer freely: your answer goes straight to billing-webhooks). Call get_request
   (requestId req_…, name “infra”) to read it and their note. If you know, answer_delegated with your answer and how you
   know; if not, hand_back with what you checked.” Among sessions by one name, the one working in the task's folder
   takes it (as `list_pending` gives it, `~/…` or a full path), one in another folder never does, and one that can't
-  tell its folder waits 5 minutes.
+  tell its folder waits half a minute (5 minutes before 0.35.0).
 - **Codex**: one listener for the app queues it into the thread it's for (`codex queue`, the same words).
 - **OpenCode and Pi**: the session's listener starts the turn through the plugin or extension; a session that used
   Pending You's card tools keeps listening for 12 hours, while the app is open.

package/dist/apps/codex-wake.js

@@ -330,7 +330,7 @@ export async function computerNames(io, origin, options) {
     }
     return names;
 }
-async function elsewhereFor(io, origin, app) {
+export async function elsewhereFor(io, origin, app) {
     if (!(await hearsOnly(io, origin, app)))
         return () => false;
     const names = await computerNames(io, origin, { tailscale: true });

package/dist/args.js

@@ -22,6 +22,7 @@ export class UsageError extends Error {
     name = 'UsageError';
 }
 const REQUEST_ID = /^req_[A-Za-z0-9-]{1,40}$/;
+const ISO_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,3})?Z$/;
 export function parseDuration(text) {
     const match = /^(\d+(?:\.\d+)?)(s|m|h)?$/.exec(text.trim());
     if (!match)
@@ -108,7 +109,7 @@ const FLAGS = {
     handoff: { origin: true, app: true },
     stopcheck: { origin: true, app: true },
     posted: { origin: true, app: true },
-    listen: { origin: true, app: true, thread: true, handed: false },
+    listen: { origin: true, app: true, thread: true, handed: false, since: true },
     permission: { origin: true, app: true },
     'permission-done': { origin: true, app: true },
     notify: { origin: true, app: true },
@@ -360,11 +361,16 @@ export function parseArgs(argv, env = {}) {
         case 'listen': {
             none();
             const thread = text('thread');
+            const since = text('since');
             if (flags.has('handed')) {
                 if (thread !== undefined)
                     throw new UsageError('Use --thread or --handed, not both.');
-                return { name: 'listen', origin, ...app(), handed: true };
+                if (since !== undefined && !ISO_TIME.test(since))
+                    throw new UsageError('--since needs a time, like: --since 2026-10-09T12:00:00.000Z');
+                return { name: 'listen', origin, ...app(), handed: true, ...(since ? { since } : {}) };
             }
+            if (since !== undefined)
+                throw new UsageError('--since goes with --handed.');
             if (thread === undefined || !THREAD.test(thread))
                 throw new UsageError('listen needs the thread it wakes, like: --thread 0199a1b2-…');
             return { name: 'listen', origin, ...app(), thread };

package/dist/handed-wait.js

@@ -0,0 +1,58 @@
+import { getJson, SignInNeeded } from "./api.js";
+import { elsewhereFor } from "./apps/codex-wake.js";
+import { delegatedOf } from "./format.js";
+export const WAIT_MS = 2 * 60_000;
+export const POLL_SECONDS = 25;
+const RETRY_MS = 5000;
+const after = (at, since) => !since || Date.parse(at) > Date.parse(since);
+export async function waitHanded(io, options) {
+    const said = await listenOnce(io, options);
+    io.out(`${JSON.stringify(said)}\n`);
+    return 0;
+}
+async function listenOnce(io, options) {
+    const { origin } = options;
+    let since = options.since;
+    const started = io.now();
+    const elsewhere = await elsewhereFor(io, origin, 'claude-code');
+    let failures = 0;
+    while (io.now() - started < WAIT_MS && !io.signal.aborted) {
+        const query = new URLSearchParams({
+            source: 'claude-code',
+            handed: '1',
+            limit: '20',
+            wait: String(POLL_SECONDS),
+        });
+        if (since)
+            query.set('since', since);
+        let requests;
+        try {
+            const { status, body } = await getJson(io, origin, `/mcp/cli/answers?${query}`, (POLL_SECONDS + 20) * 1000, io.signal, { app: 'claude-code' });
+            if (status !== 200)
+                throw new Error(`status ${status}`);
+            requests = Array.isArray(body.requests) ? body.requests : [];
+            failures = 0;
+        }
+        catch (error) {
+            if (error instanceof SignInNeeded)
+                return { error: 'signin' };
+            if (io.signal.aborted)
+                break;
+            if (++failures >= 2)
+                return { error: 'unavailable', ...(since ? { since } : {}) };
+            await io.sleep(RETRY_MS, io.signal);
+            continue;
+        }
+        const handed = requests.filter((heard) => delegatedOf(heard) !== null &&
+            heard.ready === true &&
+            typeof heard.changedAt === 'string' &&
+            after(heard.changedAt, since) &&
+            !elsewhere(heard));
+        for (const heard of requests)
+            if (typeof heard.changedAt === 'string' && after(heard.changedAt, since))
+                since = heard.changedAt;
+        if (handed.length)
+            return { handed: handed.map((heard) => heard.requestId), ...(since ? { since } : {}) };
+    }
+    return { handed: [], ...(since ? { since } : {}) };
+}

package/dist/main.js

@@ -9,6 +9,7 @@ import { channel } from "./channel.js";
 import { claudeWithChannel } from "./claude.js";
 import { ANSWER_DEADLINE_MARGIN_MS, readAnswerWait } from "./codex-answers.js";
 import { PlainError } from "./errors.js";
+import { waitHanded } from "./handed-wait.js";
 import { hold } from "./hold.js";
 import { init, status, uninstall } from "./init.js";
 import { machine } from "./machine-command.js";
@@ -78,8 +79,14 @@ async function run(io, command, hook = { fallback: '' }) {
             catch { }
             return 0;
         case 'listen':
-            if ('handed' in command)
+            if ('handed' in command) {
+                if (command.app === 'claude-code')
+                    return waitHanded(io, {
+                        origin: command.origin,
+                        ...(command.since ? { since: command.since } : {}),
+                    });
                 return listenHanded(io, { origin: command.origin, app: command.app ?? DEFAULT_APP });
+            }
             return listen(io, { ...command, app: command.app ?? DEFAULT_APP });
         case 'init':
             return init(io, command);

package/dist/permission.js

@@ -740,8 +740,7 @@ async function callState(calls, prompt) {
         const size = (await file.stat()).size;
         let position = size;
         let carry = Buffer.alloc(0);
-        const results = new Set();
-        let sameTool = null;
+        const results = new Map();
         let found = null;
         const read = (line) => {
             if (!line.includes('tool_'))
@@ -762,13 +761,16 @@ async function callState(calls, prompt) {
                     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;
+                    results.set(id, Date.parse(text(entry.timestamp)));
+                else if (block.type === 'tool_use' &&
+                    entry.type === 'assistant' &&
+                    found === null &&
+                    promptKey(text(block.name), block.input, prompt.agent) === prompt.key) {
+                    const answered = results.get(id);
+                    if (answered === undefined)
+                        found = 'waiting';
+                    else if (!(answered < prompt.at))
+                        found = 'answered';
                 }
             }
         };
@@ -788,11 +790,7 @@ async function callState(calls, prompt) {
         }
         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';
+        return found ?? 'waiting';
     }
     catch {
         return null;

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.34.1';
+export const VERSION = '0.35.0';

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

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

package/mod/hooks/register.js

@@ -1,7 +1,8 @@
 // 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, 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";
+import { argumentsOf, blockedNote, CLAIM_PREFIX, CLI_COPY, cardTool, checked, claimedElsewhere, claimHeld, claimLease, cliConfigOf, connectionOf, dueCards, emptyBook, failed, folderOf, graceEnds, 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, LISTEN_RUN_MS, LISTENER_KEY, learn, leaseFor, leaseHolder, listenArgv, listened, loadedNote, loadedPath, mayListen, momentOf, originOf, PRESENCE_EVERY_MS, PRESENCE_RUN_MS, presenceArgv, prompted, put, readBook, readClaim, readListener, readSetup, readSignal, readSince, readWait, resultObject, SETUP_AFTER_MS, SETUP_RETRY_MS, SETUP_SERVER, SETUP_TRIES, SIGNAL_KEY, settle, setUpOf, setupNeeded, setupPrompt, stateOf, statusText, TICK_MS, takesHanded, told, toTell, untold, wakeText, } from "./wake.js";
+const UNHEARD = { error: 'unavailable' };
 const RETRY_MS = 60_000;
 const live = {
     me: '',
@@ -29,6 +30,8 @@ const live = {
     herdr: null,
     herdrSaid: undefined,
     herdrTimer: null,
+    waiting: false,
+    signalSeen: 0,
 };
 const keyOf = (sessionId) => `session:${sessionId}`;
 function blockedServer() {
@@ -181,28 +184,41 @@ async function deliverHanded($) {
     }
     const cards = [];
     const claims = [];
+    const me = live.sessionId;
     for (const handed of listed) {
         const known = live.handedTold.get(handed.requestId);
         if (readSince(known, handed.updatedAt) || known === handed.updatedAt)
             continue;
-        if (!takesHanded(handed, live.folders, live.home, now))
+        if (!takesHanded(handed, live.folders, live.home, now)) {
+            const again = graceEnds(handed, live.folders);
+            if (again !== null && again > now)
+                live.handedAt = Math.min(live.handedAt, again);
             continue;
+        }
         const key = `${CLAIM_PREFIX}${handed.requestId}`;
-        if (readClaim(await $.store.get(key))?.moment === handed.updatedAt) {
+        if (claimedElsewhere(await $.store.get(key), handed.updatedAt, me)) {
             live.handedTold.set(handed.requestId, handed.updatedAt);
             continue;
         }
         const args = { requestId: handed.requestId, name };
         if (!(await allowed($, server, args)))
             continue;
+        await $.store.set(key, { moment: handed.updatedAt, at: now, by: me });
         let view = null;
         try {
             view = handedView(resultObject(await $.mcp.call(server, 'get_request', args)), handed, name);
         }
         catch { }
-        if (!view)
+        const claim = await $.store.get(key);
+        if (!view) {
+            if (claimHeld(claim, handed.updatedAt, me))
+                await $.store.delete(key);
+            continue;
+        }
+        if (!claimHeld(claim, handed.updatedAt, me)) {
+            live.handedTold.set(handed.requestId, handed.updatedAt);
             continue;
-        await $.store.set(key, { moment: handed.updatedAt, at: now });
+        }
         live.handedTold.set(handed.requestId, handed.updatedAt);
         claims.push(key);
         cards.push(view);
@@ -217,6 +233,55 @@ async function deliverHanded($) {
         live.handedAt = (await $.clock.now()) + RETRY_MS;
     });
 }
+async function listenHanded($) {
+    const presence = live.presence;
+    if (!presence || live.waiting || !live.sessionId)
+        return;
+    const now = await $.clock.now();
+    const me = live.sessionId;
+    const record = readListener(await $.store.get(LISTENER_KEY));
+    if (!mayListen(record, me, live.seenAt, now))
+        return;
+    const lease = leaseFor(record, me, now);
+    await $.store.set(LISTENER_KEY, lease);
+    if (readListener(await $.store.get(LISTENER_KEY))?.by !== me)
+        return;
+    const argv = listenArgv(presence.config, presence.origin, lease.since);
+    let run;
+    try {
+        run = $.process.run(argv, { timeoutMs: LISTEN_RUN_MS });
+    }
+    catch {
+        await $.store.set(LISTENER_KEY, listened(lease, readWait(''), now));
+        return;
+    }
+    live.waiting = true;
+    run
+        .then((ran) => (ran.exitCode === 0 ? readWait(ran.stdout) : UNHEARD), () => UNHEARD)
+        .then(async (heard) => {
+        const at = await $.clock.now();
+        const current = readListener(await $.store.get(LISTENER_KEY));
+        if (!current || current.by === me)
+            await $.store.set(LISTENER_KEY, listened(lease, heard, at));
+        if ('handed' in heard && heard.handed.length) {
+            await $.store.set(SIGNAL_KEY, { at });
+            live.signalSeen = at;
+            live.handedAt = 0;
+        }
+    })
+        .catch(() => { })
+        .finally(() => {
+        live.waiting = false;
+        soon($);
+    });
+}
+async function heedSignal($) {
+    const at = readSignal(await $.store.get(SIGNAL_KEY));
+    if (at <= live.signalSeen)
+        return;
+    live.signalSeen = at;
+    live.handedAt = 0;
+}
 async function prune($) {
     const now = await $.clock.now();
     for (const key of await $.store.keys()) {
@@ -298,6 +363,8 @@ async function tick($) {
         }
         for (const card of dueCards(live.book, now))
             await check($, card.requestId);
+        await listenHanded($).catch(() => { });
+        await heedSignal($).catch(() => { });
         if (!(await deliver($)))
             await deliverHanded($);
         showCards($);

package/mod/hooks/wake.js

@@ -592,7 +592,7 @@ export function claimLease(value, me, now) {
 export const HANDED_FAST_MS = 60_000;
 export const HANDED_SLOW_MS = 3 * 60_000;
 export const HANDED_FOR_MS = 12 * 60 * 60_000;
-export const HANDED_GRACE_MS = 5 * 60_000;
+export const HANDED_GRACE_MS = 30_000;
 export const CLAIM_PREFIX = 'handed:';
 export const HANDED_PREFIX = 'Pending You: your person handed you';
 export const HANDED_REPLY = 'on the question handed to you';
@@ -670,6 +670,12 @@ export function takesHanded(handed, folders, home, now) {
         return now - Date.parse(handed.updatedAt) >= HANDED_GRACE_MS;
     return inTaskFolder(folders, handed.cwd, home);
 }
+export function graceEnds(handed, folders) {
+    if (handed.byName || !handed.cwd || folders.length > 0)
+        return null;
+    const at = Date.parse(handed.updatedAt);
+    return Number.isFinite(at) ? at + HANDED_GRACE_MS : null;
+}
 export function folderOf(tool, input) {
     if (tool !== 'post_request')
         return undefined;
@@ -698,8 +704,86 @@ export function handedView(output, handed, name) {
 export function readClaim(value) {
     if (!isObject(value) || typeof value.moment !== 'string')
         return null;
-    return { moment: value.moment, at: count(value.at) ?? 0 };
+    const by = text(value.by, 200);
+    return { moment: value.moment, at: count(value.at) ?? 0, ...(by ? { by } : {}) };
+}
+export function claimedElsewhere(value, moment, me) {
+    const claim = readClaim(value);
+    return claim?.moment === moment && claim.by !== me;
+}
+export function claimHeld(value, moment, me) {
+    const claim = readClaim(value);
+    return claim?.moment === moment && claim.by === me;
+}
+export const LISTENER_KEY = 'handed-listener';
+export const SIGNAL_KEY = 'handed-signal';
+export const LISTEN_RUN_MS = 4 * 60_000;
+export const LISTENER_LEASE_MS = LISTEN_RUN_MS + 30_000;
+export const LISTENER_KEEP_MS = 15_000;
+export const LISTEN_RETRY_MS = 2 * 60_000;
+export const LISTEN_QUIET_MS = 30 * 60_000;
+const ISO_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,3})?Z$/;
+const isoOf = (value) => typeof value === 'string' && ISO_TIME.test(value) ? value : undefined;
+export function readListener(value) {
+    if (!isObject(value))
+        return null;
+    const by = text(value.by, 200);
+    const until = count(value.until);
+    if (!by || until === undefined)
+        return null;
+    const since = isoOf(value.since);
+    const quietUntil = count(value.quietUntil);
+    return { by, until, ...(since ? { since } : {}), ...(quietUntil ? { quietUntil } : {}) };
+}
+export function mayListen(record, me, seenAt, now) {
+    if (seenAt <= 0 || now - seenAt >= HANDED_FOR_MS)
+        return false;
+    if (record?.quietUntil && now < record.quietUntil)
+        return false;
+    return !record || record.by === me || now >= record.until;
+}
+export const leaseFor = (record, me, now) => ({
+    by: me,
+    until: now + LISTENER_LEASE_MS,
+    ...(record?.since ? { since: record.since } : {}),
+});
+export function readWait(stdout) {
+    const line = stdout.trim().split('\n').at(-1) ?? '';
+    const parsed = parseJson(line);
+    if (!isObject(parsed))
+        return { error: 'unknown' };
+    const since = isoOf(parsed.since);
+    if (parsed.error === 'signin' || parsed.error === 'unavailable')
+        return { error: parsed.error, ...(since ? { since } : {}) };
+    if (!Array.isArray(parsed.handed))
+        return { error: 'unknown' };
+    const handed = parsed.handed.filter((id) => typeof id === 'string' && REQUEST_ID.test(id));
+    return { handed, ...(since ? { since } : {}) };
+}
+export function listened(record, heard, now) {
+    const since = heard.since ?? record.since;
+    const quiet = 'error' in heard
+        ? now + (heard.error === 'unavailable' ? LISTEN_RETRY_MS : LISTEN_QUIET_MS)
+        : undefined;
+    return {
+        by: record.by,
+        until: now + LISTENER_KEEP_MS,
+        ...(since ? { since } : {}),
+        ...(quiet ? { quietUntil: quiet } : {}),
+    };
+}
+export function listenArgv(config, origin, since) {
+    return [
+        `${config}/bin/pendingyou-hook`,
+        'listen',
+        '--handed',
+        '--app',
+        'claude-code',
+        ...(since ? ['--since', since] : []),
+        ...(origin === PRODUCTION ? [] : ['--origin', origin]),
+    ];
 }
+export const readSignal = (value) => (isObject(value) ? (count(value.at) ?? 0) : 0);
 function cut(value, max) {
     const chars = [...value.replace(/\s+/g, ' ').trim()];
     return chars.length <= max

package/package.json

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