pendingyou 0.4.0 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 0.6.0
+
+- Fixed: a hook could run past Claude Code's 10 seconds (`UserPromptSubmit hook … timed out after 10s — output
+  discarded`), mostly when the sign-in needed refreshing, which no time limit covered. Every hook (`pickup`,
+  `handoff`, `stopcheck`) now stops 3 seconds after it starts, printing only its plain fallback (the hand-off's
+  one-line reminder; nothing from the others, so the Stop check lets the turn end) and exiting 0. Requests give up
+  sooner too: 2.5 seconds for `pickup` (was 5), 2 for `handoff` with answers (was 2.5), 1.5 for open cards.
+- A hook never refreshes the sign-in itself. Cut off halfway, a refresh can end the sign-in, so when the access token
+  runs out within 5 minutes a hook starts `pendingyou refresh` in the background, detached, which finishes under the
+  credentials lock however the hook ends (one at a time: none starts while another holds the lock). The hook goes on
+  with the token it has; one that has run out waits up to 1.2 seconds for the new one, then falls back.
+- A refresh now gives up within 20 seconds in all (it could take 35), inside the lock's 30, so a slow one is never
+  taken over while it's still running.
+- The Stop check no longer asks Claude Code to go on over "There's nothing waiting on you" or "no cards from me
+  waiting on you" (a negation before "waiting on you"), or "say if it needs you to download it" (what another agent
+  will say, if it ever does). A message that says nothing needs a card ("No card needed.", "Nothing needs your
+  attention.", "doesn't need a card") is taken at its word, as the Stop reason offers.
+
+## 0.5.0
+
+- A card with several questions (guide 2.6) prints each answer on its own line when `hold` ends (and when a hook
+  hands the answer over): `1. Pay Kaiser’s invoice 09/30 for $1,200? (pay): Approved`, numbered in the card's order,
+  with the question's id as `answer.answers` has it. A question your person split out into a card of its own is named
+  with its new request id: hear its answer there.
+- When an answer is ready, the line telling Claude Code to call `ack_answer` (or `reply_in_thread`) now names the
+  session too (`name “billing-webhooks”`): since guide 2.5 the sessions sharing a computer's sign-in each act only on
+  their own cards, and pass their name to do so.
+- The next-message hook's open-cards line names the session that asked each card (`(req_…, by dns-setup)`, from
+  servers on guide 2.5, cut to 24 characters) and says to cancel only one of yours, with `answeredHere` and your name.
+
 ## 0.4.0
 
 - The next-message hook's reminder now names this folder's open cards still waiting on you, so a question you answer

package/README.md

@@ -20,7 +20,9 @@ Run it once on each computer. It:
 Your other settings are kept as they are. `npx pendingyou uninstall` removes exactly what `init` added.
 
 The hooks never get in your way: if anything goes wrong (no network, not signed in, a bad option), they print nothing
-and let your message through. Running `init` again updates them in place, and adds any a newer version brings.
+and let your message through. Each one stops within 3 seconds whatever happens, with at most its one-line reminder, and
+never refreshes the sign-in itself: when that's due, it starts the refresh in the background, which finishes on its
+own. Running `init` again updates them in place, and adds any a newer version brings.
 
 ## Nothing left only in chat
 
@@ -42,7 +44,8 @@ The check is pattern matching on your computer: no model, no network. It reads o
 transcript (at most 4 MB) and skips code blocks and quotes. It counts as for you: a question to you (a sentence ending
 in "?" with "you" or "your"); "you'll need to", "your step", "can you", "please run", "in your terminal", "only you
 can", "waiting on you" and the like; or a list under a heading like "Your part", "Your steps", "For you", "Waiting on
-you" or "Left for you".
+you" or "Left for you". It lets the turn end when the message says nothing needs a card ("No card needed.", "Nothing
+needs your attention.", "There's nothing waiting on you.").
 
 **On 0.2.0 with another origin?** Its hooks blocked every message (`There's no "--origin" command`). Run
 `npx pendingyou@latest init --origin <url>` again to repair them; see [CHANGELOG.md](CHANGELOG.md).

package/dist/api.js

@@ -1,9 +1,25 @@
 // Calls to Pending You with the command line's sign-in: a fresh access token (refreshed under the credentials lock,
 // so a hold and a hook never spend the same refresh token), one retry after a 401, and plain errors.
-import { readCredential, updateCredential } from "./credentials.js";
+//
+// Hooks never refresh in their own process. A hook has a hard deadline (main.ts), and a refresh cut off halfway can
+// end the sign-in: the server rotates the refresh token as it answers, and keeps exactly one earlier token valid
+// (@cloudflare/workers-oauth-provider's previousRefreshTokenId). A refresh abandoned before its answer arrives is
+// harmless on its own (the stored token is that earlier one, and still works), but if the server finishes it after a
+// later refresh has stored a newer token, that newer token stops working and the next refresh gets invalid_grant. So
+// a hook that needs a new token starts `pendingyou refresh` detached (background), which runs to the end under the
+// lock whatever happens to the hook, and waits for it only briefly; until it lands the hook uses the token it has, or
+// gives up and prints its plain fallback.
+import { credentialsPath, readCredential, updateCredential, } from "./credentials.js";
+import { isLocked } from "./files.js";
 import { OAuthError, refresh } from "./oauth.js";
 /** Refresh this long before the access token runs out. */
 const EARLY_MS = 60_000;
+/** A hook starts a background refresh this long before the access token runs out, and goes on with the old one. */
+export const SOON_MS = 5 * 60_000;
+/** How long a hook waits for a background refresh when it has no working token. */
+export const REFRESH_WAIT_MS = 1200;
+/** An access token with less than this left isn't worth sending. */
+const USABLE_MS = 10_000;
 /** Not signed in on this computer (for this origin), or the sign-in ended: the person runs `pendingyou login`. */
 export class SignInNeeded extends Error {
     name = 'SignInNeeded';
@@ -23,12 +39,11 @@ export class Unavailable extends Error {
         this.retryAfter = retryAfter;
     }
 }
-async function freshToken(io, origin, force) {
-    const stored = await readCredential(io, origin);
-    if (!stored)
-        throw new SignInNeeded(false);
-    if (!force && stored.expiresAt - EARLY_MS > io.now())
-        return stored.accessToken;
+/**
+ * Refreshes the sign-in under the lock unless it no longer needs it: a token with more than `earlyMs` left (or, when
+ * `force`d after a 401, a refresh token another process already replaced) is used as it is.
+ */
+async function refreshStored(io, origin, stored, options) {
     let ended = false;
     const updated = await updateCredential(io, origin, async (current) => {
         if (!current)
@@ -36,6 +51,8 @@ async function freshToken(io, origin, force) {
         // Another process may have refreshed while this one waited for the lock.
         if (current.refreshToken !== stored.refreshToken && current.expiresAt - EARLY_MS > io.now())
             return current;
+        if (!options.force && current.expiresAt - options.earlyMs > io.now())
+            return current;
         try {
             const tokens = await refresh(io, origin, current.clientId, current.refreshToken);
             return { ...current, ...tokens };
@@ -51,7 +68,53 @@ async function freshToken(io, origin, force) {
     });
     if (!updated)
         throw new SignInNeeded(ended);
-    return updated.accessToken;
+    return updated;
+}
+async function freshToken(io, origin, force) {
+    const stored = await readCredential(io, origin);
+    if (!stored)
+        throw new SignInNeeded(false);
+    if (!force && stored.expiresAt - EARLY_MS > io.now())
+        return stored.accessToken;
+    return (await refreshStored(io, origin, stored, { force, earlyMs: EARLY_MS })).accessToken;
+}
+/**
+ * `pendingyou refresh`, what a hook starts in the background: refreshes the sign-in when it runs out within SOON_MS
+ * (or `force`, after a 401), under the lock, to the end. Quiet; true when there's a sign-in afterwards.
+ */
+export async function refreshInBackground(io, origin, force) {
+    const stored = await readCredential(io, origin);
+    if (!stored)
+        return false;
+    if (!force && stored.expiresAt - SOON_MS > io.now())
+        return true;
+    await refreshStored(io, origin, stored, { force, earlyMs: SOON_MS });
+    return true;
+}
+/** A hook's token: never refreshed here (see the top of this file). */
+async function hookToken(io, origin, force, signal) {
+    const stored = await readCredential(io, origin);
+    if (!stored)
+        throw new SignInNeeded(false);
+    const left = stored.expiresAt - io.now();
+    if (!force && left > SOON_MS)
+        return stored.accessToken;
+    // One refresher at a time: a lock held now is a refresh (or a write) already under way.
+    if (!(await isLocked(credentialsPath(io))))
+        io.background(['refresh', '--origin', origin, ...(force ? ['--force'] : [])]);
+    // Still good for a few seconds: this request goes with it, the next one with the new token.
+    if (!force && left > USABLE_MS)
+        return stored.accessToken;
+    const until = io.now() + REFRESH_WAIT_MS;
+    while (io.now() < until && !signal?.aborted) {
+        await io.sleep(50, signal);
+        const current = await readCredential(io, origin);
+        if (!current)
+            throw new SignInNeeded(true);
+        if (current.refreshToken !== stored.refreshToken)
+            return current.accessToken;
+    }
+    throw new Unavailable('The sign-in is being refreshed in the background.');
 }
 /** Aborts on `signal` or after `ms`, whichever comes first (AbortSignal.any needs Node 20.3). */
 function either(signal, ms) {
@@ -70,13 +133,18 @@ function either(signal, ms) {
  * GETs `path` on `origin` as the command line, and returns the JSON body with its status. 401 after a refresh means
  * the sign-in is over (revoked, or 30 days passed). Network failures and 5xx are `Unavailable`.
  */
-export async function getJson(io, origin, path, timeoutMs, signal) {
+export async function getJson(io, origin, path, timeoutMs, signal, options = {}) {
     for (let attempt = 0;; attempt++) {
         let token;
         try {
-            token = await freshToken(io, origin, attempt > 0);
+            token =
+                options.hook && io.background
+                    ? await hookToken(io, origin, attempt > 0, signal)
+                    : await freshToken(io, origin, attempt > 0);
         }
         catch (error) {
+            if (error instanceof Unavailable)
+                throw error;
             if (error instanceof SignInNeeded)
                 throw error;
             throw new Unavailable('Pending You couldn’t be reached to refresh the sign-in.');

package/dist/args.js

@@ -49,6 +49,7 @@ const COMMANDS = new Set([
     'init',
     'uninstall',
     'watch',
+    'refresh',
 ]);
 /** Flags each command takes; `true` when the flag takes a value. */
 const FLAGS = {
@@ -64,6 +65,7 @@ const FLAGS = {
     init: { origin: true, 'no-login': false, 'no-browser': false, device: false },
     uninstall: { origin: true },
     watch: { origin: true, once: false },
+    refresh: { origin: true, force: false },
 };
 /** Options that take a value, whichever command they belong to: needed to find the command behind them. */
 const VALUE_OPTIONS = new Set(['origin', 'timeout']);
@@ -177,6 +179,10 @@ export function parseArgs(argv, env = {}) {
         case 'uninstall':
             none();
             return { name: 'uninstall', origin };
+        // Not in USAGE: what a hook starts in the background when the sign-in needs refreshing (api.ts).
+        case 'refresh':
+            none();
+            return { name: 'refresh', origin, force: flags.has('force') };
         case 'init':
             none();
             return {

package/dist/files.js

@@ -60,7 +60,11 @@ export async function writeWhole(path, text, options = {}) {
     }
 }
 /** A lock older than this was left by a process that died; it's taken over. */
-const STALE_MS = 30_000;
+export const STALE_MS = 30_000;
+/** Whether another process holds `<path>.lock` now (a lock older than STALE_MS doesn't count). */
+export async function isLocked(path) {
+    return stat(`${path}.lock`).then((info) => Date.now() - info.mtimeMs <= STALE_MS, () => false);
+}
 /** Runs `work` while holding `<path>.lock`, so two processes (a hold and a hook) never write over each other. */
 export async function withLock(path, io, work) {
     const lock = `${path}.lock`;

package/dist/format.js

@@ -4,6 +4,9 @@
 const MAX_ANSWER = 600;
 const MAX_MESSAGE = 400;
 const MAX_TITLE = 140;
+/** A grouped card's question and its answer, each: four of them stay well under one long answer. */
+const MAX_QUESTION = 100;
+const MAX_QUESTION_ANSWER = 300;
 /** Cuts text to `max` characters on one line, and says so. */
 export function clip(text, max) {
     const flat = text.replace(/\s+/g, ' ').trim();
@@ -22,6 +25,11 @@ const quoted = (text, max) => {
     const { text: clipped, cut } = clip(text, max);
     return { line: `“${clipped}”`, cut };
 };
+/**
+ * The session's name, as it asked (its session label): the card tools take it, and need it where other sessions share
+ * the sign-in (guide 2.5).
+ */
+const named = (heard) => `“${clip(heard.sessionLabel, MAX_TITLE).text}”`;
 /** Closed for good: nothing more to wait for. */
 export const isClosed = (heard) => heard.status === 'answered' ||
     heard.status === 'resolved' ||
@@ -40,12 +48,24 @@ export function describe(heard, again) {
     const lines = [];
     switch (heard.status) {
         case 'answered': {
-            const answer = clip(heard.said ?? 'Answered', MAX_ANSWER);
-            cut ||= answer.cut;
-            lines.push(`Pending You: ${id} is answered.`, question, `Answer: ${answer.text}`);
+            if (heard.answers?.length) {
+                // One line per question, so each answer reads against its own question (and its id, as answer.answers has it).
+                lines.push(`Pending You: ${id} is answered, all ${heard.answers.length} questions.`, question);
+                for (const [index, each] of heard.answers.entries()) {
+                    const asked = clip(each.title, MAX_QUESTION);
+                    const answer = clip(each.said, MAX_QUESTION_ANSWER);
+                    cut ||= asked.cut || answer.cut;
+                    lines.push(`${index + 1}. ${asked.text} (${each.questionId}): ${answer.text}`);
+                }
+            }
+            else {
+                const answer = clip(heard.said ?? 'Answered', MAX_ANSWER);
+                cut ||= answer.cut;
+                lines.push(`Pending You: ${id} is answered.`, question, `Answer: ${answer.text}`);
+            }
             if (wrote.length)
                 lines.push(`They also wrote: ${wrote.join(' ')}`);
-            lines.push(`Act on it, then call ack_answer with requestId ${id}, expectedVersion ${heard.version} and a one-line outcome.`);
+            lines.push(`Act on it, then call ack_answer with requestId ${id}, name ${named(heard)}, expectedVersion ${heard.version} and a one-line outcome.`);
             break;
         }
         case 'expired':
@@ -59,12 +79,17 @@ export function describe(heard, again) {
             break;
         default:
             if (heard.turn === 'agent') {
-                lines.push(`Pending You: they wrote back on ${id}.`, question, `They wrote: ${wrote.join(' ') || '(a follow-up; call get_request to read it)'}`, `Answer with reply_in_thread (requestId ${id}), then ${again}.`);
+                lines.push(`Pending You: they wrote back on ${id}.`, question, `They wrote: ${wrote.join(' ') || '(a follow-up; call get_request to read it)'}`, `Answer with reply_in_thread (requestId ${id}, name ${named(heard)}), then ${again}.`);
             }
             else {
                 lines.push(`Pending You: ${id} is still waiting for them (${heard.status}).`, question);
             }
     }
+    // Questions split out of a grouped card are cards of their own now, with answers of their own.
+    if (heard.splits?.length && heard.status !== 'cancelled' && heard.status !== 'resolved')
+        lines.push(`They split ${heard.splits
+            .map((split) => `“${clip(split.title, MAX_QUESTION).text}” (${split.requestId})`)
+            .join(', ')} out into ${heard.splits.length === 1 ? 'a card of its own' : 'cards of their own'}: hear ${heard.splits.length === 1 ? 'its answer' : 'their answers'} there.`);
     if (cut)
         lines.push(`(Cut short: get_request ${id} has all of it.)`);
     return lines;

package/dist/io.js

@@ -105,6 +105,20 @@ async function openBrowser(url) {
     const result = await runProgram(command, args, 10_000);
     return result.code === 0;
 }
+function background(script, args) {
+    if (!script)
+        return;
+    try {
+        const child = spawn(process.execPath, [script, ...args], {
+            detached: true,
+            stdio: 'ignore',
+            windowsHide: true,
+        });
+        child.on('error', () => { });
+        child.unref();
+    }
+    catch { }
+}
 export function realIo() {
     const controller = new AbortController();
     // The first signal lets the command finish cleanly (a hold says how the answer will still arrive); a second one
@@ -132,5 +146,7 @@ export function realIo() {
         sleep,
         signal: controller.signal,
         script: process.argv[1] ?? '',
+        uptime: () => process.uptime() * 1000,
+        background: (args) => background(process.argv[1] ?? '', args),
     };
 }

package/dist/main.js

@@ -1,6 +1,6 @@
 // The command line: parse the arguments, run the command, return the exit code. `cli.ts` runs it for real; tests run
 // it with their own Io.
-import { getJson, SignInNeeded, Unavailable } from "./api.js";
+import { getJson, refreshInBackground, SignInNeeded, Unavailable } from "./api.js";
 import { commandOf, HOOK_COMMANDS, parseArgs, USAGE, UsageError } from "./args.js";
 import { claudeState, installClaude, uninstallClaude } from "./claude.js";
 import { readCredential, signedInOrigins, updateCredential } from "./credentials.js";
@@ -116,7 +116,7 @@ async function uninstall(io, origin) {
     await logout(io, { origin, all: false });
     return steps.every((step) => step.ok) ? 0 : 1;
 }
-async function run(io, command) {
+async function run(io, command, hook = { fallback: '' }) {
     switch (command.name) {
         case 'help':
             io.out(USAGE);
@@ -133,9 +133,9 @@ async function run(io, command) {
         case 'hold':
             return hold(io, command);
         case 'pickup':
-            return pickup(io, { origin: command.origin, mode: 'pickup' });
+            return pickup(io, { origin: command.origin, mode: 'pickup' }, hook);
         case 'handoff':
-            return pickup(io, { origin: command.origin, mode: 'handoff' });
+            return pickup(io, { origin: command.origin, mode: 'handoff' }, hook);
         case 'stopcheck':
             return stopcheck(io, { origin: command.origin });
         case 'init':
@@ -144,6 +144,60 @@ async function run(io, command) {
             return uninstall(io, command.origin);
         case 'watch':
             return watch(io, command);
+        case 'refresh':
+            // Detached and quiet: nobody reads what it prints, and the next hook sees the result in the credentials file.
+            try {
+                await refreshInBackground(io, command.origin, command.force);
+            }
+            catch { }
+            return 0;
+    }
+}
+/**
+ * A hook's hard deadline, from the moment this process started: Claude Code gives a hook 10 seconds (init's
+ * `timeout`), npx takes about half a second before this process starts, and a normal hook is done in about one.
+ * When it's reached, the hook prints its plain fallback (the hand-off's one-line reminder; nothing for pickup and
+ * stopcheck) unless it already printed, and exits 0, whatever it was still waiting on.
+ */
+export const HOOK_DEADLINE_MS = 3000;
+async function runHook(io, command) {
+    const hook = { fallback: '' };
+    const controller = new AbortController();
+    const stop = () => controller.abort();
+    if (io.signal.aborted)
+        stop();
+    io.signal.addEventListener('abort', stop, { once: true });
+    let finished = false;
+    let printed = false;
+    const hookIo = {
+        ...io,
+        out: (text) => {
+            if (finished)
+                return;
+            printed = true;
+            io.out(text);
+        },
+        signal: controller.signal,
+    };
+    let timer;
+    const deadline = new Promise((resolve) => {
+        timer = setTimeout(() => resolve('deadline'), Math.max(0, HOOK_DEADLINE_MS - io.uptime()));
+    });
+    try {
+        const outcome = await Promise.race([run(hookIo, command, hook), deadline]);
+        if (outcome !== 'deadline')
+            return outcome;
+        finished = true;
+        controller.abort();
+        if (!printed && hook.fallback)
+            io.out(hook.fallback);
+        io.err('pendingyou: Pending You took too long; skipped this hook.\n');
+        return 0;
+    }
+    finally {
+        finished = true;
+        clearTimeout(timer);
+        io.signal.removeEventListener('abort', stop);
     }
 }
 /**
@@ -174,7 +228,7 @@ export async function main(argv, io) {
     if (hook && !HOOK_COMMANDS.has(command.name))
         return 0;
     try {
-        return await run(io, command);
+        return hook ? await runHook(io, command) : await run(io, command);
     }
     catch (error) {
         // Plain words only: never a stack, a token or a server's description.

package/dist/oauth.js

@@ -32,10 +32,10 @@ export function pkce() {
 }
 /** The resource the tokens are for: Pending You's MCP server, whose /mcp/cli/* the command line calls. */
 export const resourceOf = (origin) => `${origin}/mcp`;
-export async function discover(io, origin) {
+export async function discover(io, origin, timeoutMs = 15_000) {
     const response = await io.fetch(`${origin}/.well-known/oauth-authorization-server`, {
         headers: { accept: 'application/json' },
-        signal: AbortSignal.timeout(15_000),
+        signal: AbortSignal.timeout(timeoutMs),
     });
     if (!response.ok)
         throw new OAuthError('discovery', `Pending You at ${origin} didn’t answer (${response.status}).`);
@@ -136,12 +136,12 @@ async function listen(state, signal) {
         },
     };
 }
-async function tokenRequest(io, metadata, params) {
+async function tokenRequest(io, metadata, params, timeoutMs = 20_000) {
     const response = await io.fetch(metadata.token_endpoint, {
         method: 'POST',
         headers: { 'content-type': 'application/x-www-form-urlencoded', accept: 'application/json' },
         body: new URLSearchParams(params).toString(),
-        signal: AbortSignal.timeout(20_000),
+        signal: AbortSignal.timeout(timeoutMs),
     });
     const body = (await response.json().catch(() => ({})));
     if (!response.ok ||
@@ -203,15 +203,18 @@ export async function signIn(io, options) {
         loopback.close();
     }
 }
-/** A new access token (and the next refresh token) from the current refresh token. */
+/**
+ * A new access token (and the next refresh token) from the current refresh token. At most 20 seconds in all, well
+ * inside the credentials lock's 30 seconds, so no other process takes the lock over while a refresh is still running.
+ */
 export async function refresh(io, origin, clientId, refreshToken) {
-    const metadata = await discover(io, origin);
+    const metadata = await discover(io, origin, 8_000);
     return tokenRequest(io, metadata, {
         grant_type: 'refresh_token',
         refresh_token: refreshToken,
         client_id: clientId,
         resource: resourceOf(origin),
-    });
+    }, 12_000);
 }
 /** Revokes the sign-in on the server (RFC 7009). Best effort: signing out here still happens if this fails. */
 export async function revoke(io, origin, clientId, refreshToken) {

package/dist/pickup.js

@@ -10,17 +10,21 @@
 //   time-boxed short; on any error, or from a server too old to list open cards, the line is the plain reminder.
 //
 // Whatever they print, Claude Code adds to the conversation. A hook must never get in the way: each is time-boxed,
+// has a hard deadline (main.ts) after which it prints only its fallback, never refreshes the sign-in itself (api.ts),
 // prints nothing when there's nothing new, never repeats an answer it handed over, and always exits 0.
 import { getJson, SignInNeeded } from "./api.js";
 import { readCredential } from "./credentials.js";
 import { clip, describe, isClosed } from "./format.js";
 import { markHanded, momentOf, waitingOn, wasHanded } from "./state.js";
-const TIME_BOX_MS = { pickup: 5000, handoff: 2500, open: 1500 };
+/** Each request's own limit, inside the hook's 3-second deadline (main.ts). */
+const TIME_BOX_MS = { pickup: 2500, handoff: 2000, open: 1500 };
 /** What every message carries while signed in (about 18 tokens). */
 export const REMINDER = 'Pending You: anything you need from your person also goes on a card.';
 /** The most open cards the line names, and how much of each title. */
 export const OPEN_SHOWN = 3;
 export const OPEN_TITLE = 50;
+/** How much of the asking session's name each card shows. */
+export const OPEN_NAME = 24;
 /**
  * The reminder, naming this folder's open cards still waiting on the person when there are any (about 45 tokens plus
  * 20 a card): `… Your open cards here: "Which DNS host?" (req_…); … +2 more. If this message answers …`.
@@ -40,9 +44,14 @@ export function openLine(open) {
         return REMINDER;
     const more = typeof total === 'number' && total > cards.length ? total - cards.length : 0;
     const named = cards
-        .map((card) => `"${clip(card.title.replaceAll('"', "'"), OPEN_TITLE).text}" (${card.requestId})`)
+        .map((card) => {
+        const by = typeof card.name === 'string' && card.name.trim()
+            ? `, by ${clip(card.name.replaceAll('"', "'"), OPEN_NAME).text}`
+            : '';
+        return `"${clip(card.title.replaceAll('"', "'"), OPEN_TITLE).text}" (${card.requestId}${by})`;
+    })
         .join('; ');
-    return `${REMINDER} Your open cards here: ${named}${more ? ` +${more} more` : ''}. If this message answers or settles one, cancel_request it with answeredHere (or update_request if it changed).`;
+    return `${REMINDER} Your open cards here: ${named}${more ? ` +${more} more` : ''}. If this message answers or settles one of yours, cancel_request it with answeredHere and your name (or update_request if it changed).`;
 }
 /** The folder Claude Code says the session is in (the hook's stdin), or where this runs. */
 async function sessionFolder(io) {
@@ -63,18 +72,19 @@ export function folderForms(cwd, home) {
         forms.push(`~${cwd.slice(base.length)}`);
     return forms;
 }
-export async function pickup(io, options) {
+export async function pickup(io, options, hook = { fallback: '' }) {
     const { origin, mode } = options;
-    let remind = false;
-    let line = REMINDER;
+    // The hand-off's line, printed at the end unless something else was printed with it.
+    let line = null;
     try {
         const cwd = await sessionFolder(io);
         // The hand-off hears answers only while a hold from this computer is outstanding; it always asks for open cards.
         let answers = true;
         if (mode === 'handoff') {
-            remind = (await readCredential(io, origin)) !== null;
-            if (!remind)
+            if ((await readCredential(io, origin)) === null)
                 return 0;
+            line = REMINDER;
+            hook.fallback = `${REMINDER}\n`;
             answers = (await waitingOn(io, origin)).length > 0;
         }
         const query = new URLSearchParams([
@@ -82,7 +92,7 @@ export async function pickup(io, options) {
             ['limit', answers ? '5' : '0'],
             ...(mode === 'handoff' ? [['open', String(OPEN_SHOWN)]] : []),
         ]);
-        const { status, body } = await getJson(io, origin, `/mcp/cli/answers?${query}`, answers ? TIME_BOX_MS[mode] : TIME_BOX_MS.open, io.signal);
+        const { status, body } = await getJson(io, origin, `/mcp/cli/answers?${query}`, answers ? TIME_BOX_MS[mode] : TIME_BOX_MS.open, io.signal, { hook: true });
         if (status !== 200)
             return 0;
         if (mode === 'handoff')
@@ -96,6 +106,8 @@ export async function pickup(io, options) {
         if (fresh.length === 0)
             return 0;
         const again = (id) => `run \`npx pendingyou hold ${id}\` in the background`;
+        // One write, the line included: at the deadline a hook has printed all of this or none of it. Printed before it's
+        // marked as handed over, so a hook cut off in between repeats an answer rather than losing it.
         io.out(`${[
             mode === 'pickup'
                 ? 'Pending You: your person answered while no session was listening.'
@@ -103,7 +115,9 @@ export async function pickup(io, options) {
             '',
             ...fresh.flatMap((heard) => [...describe(heard, again(heard.requestId)), '']),
             'Tell them in one line first (“You answered in Pending You: …”), then act.',
+            ...(line ? [line] : []),
         ].join('\n')}\n`);
+        line = null;
         await markHanded(io, origin, fresh.map((heard) => ({
             requestId: heard.requestId,
             moment: momentOf(heard),
@@ -115,11 +129,11 @@ export async function pickup(io, options) {
         if (mode === 'pickup' && error instanceof SignInNeeded && error.ended)
             io.out('Pending You: this computer’s pendingyou sign-in has ended, so answers can’t wake Claude Code. Ask your person to run `npx pendingyou login`.\n');
         if (error instanceof SignInNeeded)
-            remind = false;
+            line = null;
         return 0;
     }
     finally {
-        if (remind)
+        if (line)
             io.out(`${line}\n`);
     }
 }

package/dist/stopcheck.js

@@ -19,8 +19,16 @@ const POSTING_TOOL = /^mcp__.+__(post_request|update_request|reply_in_thread)$/;
  * announces a card to come, not a step left in chat.
  */
 const SAYS_POSTED = /\b(posted|put|added|raised|filed)\b[^.\n]{0,60}\b(cards?|pending ?you)\b|\bon (a|the|its|their|your|that|this) cards?\b|\b(in|to|through|via|on) pending ?you\b|\bpending ?you cards?\b|\b(i|we|you)(?:(?:'|’)ll| will)\s+(?:\w+\s+)?(post|send|put|add|raise|file|get|see|find)\b[^.\n]{0,40}\bcards?\b/i;
-/** Steps only the person can take, said to them. */
-const STEPS_FOR_THEM = /\b(you(?:'|’)ll need to|you will need to|you(?:'|’)ll have to|you will have to|your (?:next )?steps?\b|can you|could you|would you mind|please (?:run|confirm|approve|check|add|set|sign|create|open|paste|reply|send|choose|pick|decide|let me know)|in your terminal|only you can|waiting on you|waiting for you|needs? you to|over to you|parked for you|when you(?:'|’)re ready|up to you|your call\b|is yours\b|say the word|let me know (?:which|whether)|tell me (?:which|whether)|needs? your (?:ok|okay|approval|decision|sign-?off|go-ahead))/i;
+/**
+ * Steps only the person can take, said to them. Not "nothing (is) waiting on you" or "no cards … waiting on you" (a
+ * negation within the clause), nor "say if it needs you to …" (what another agent will say, if it ever does).
+ */
+const STEPS_FOR_THEM = /\b(you(?:'|’)ll need to|you will need to|you(?:'|’)ll have to|you will have to|your (?:next )?steps?\b|can you|could you|would you mind|please (?:run|confirm|approve|check|add|set|sign|create|open|paste|reply|send|choose|pick|decide|let me know)|in your terminal|only you can|(?<!\b(?:no|nothing|none|not)\b[^.,;:!?\n]{0,40})waiting (?:on|for) you|(?<!\bif (?:it|he|she|they|that|this|anything|something|someone|anyone|one) )needs? you to|over to you|parked for you|when you(?:'|’)re ready|up to you|your call\b|is yours\b|say the word|let me know (?:which|whether)|tell me (?:which|whether)|needs? your (?:ok|okay|approval|decision|sign-?off|go-ahead))/i;
+/**
+ * Text that says nothing here needs a card: the "or say they don’t need one" the Stop reason offers ("No card
+ * needed.", "Nothing needs your attention.", "There’s nothing waiting on you.").
+ */
+const SAYS_NO_CARD = /\bno (?:new |more |further )?cards? (?:is |are )?(?:needed|necessary|required)\b|\b(?:doesn(?:'|’)t|don(?:'|’)t|does not|do not|won(?:'|’)t|will not) need (?:a |any )?(?:new )?cards?\b|\bnothing (?:here |else |more |now )?(?:needs|requires) your (?:attention|input|action|answer)\b|\b(?:nothing|no cards?)\b[^.,;:!?\n]{0,40}\b(?:waiting|pending) (?:on|for) you\b/i;
 /** A heading over a list of things for the person. */
 const FOR_THEM_HEADING = /\b(your part|your steps?|your to-?dos?|your turn|your call|for you|waiting on you|left for you|parked for you|needs you|over to you|what you need to do|you(?:'|’)ll need)\b/i;
 const LIST_ITEM = /^\s*(?:\d+[.)]|[-*•]|\[ \])\s+\S/;
@@ -77,6 +85,8 @@ export function itemsForPerson(text) {
 }
 /** Whether the text says the items are already in Pending You. */
 export const saysPosted = (text) => SAYS_POSTED.test(plainText(text));
+/** Whether the text says nothing in it needs a card. */
+export const saysNoCard = (text) => SAYS_NO_CARD.test(plainText(text));
 /** A message from the person (not a tool's result): where a turn starts. */
 function startsTurn(entry) {
     if (entry.type !== 'user' || entry.isMeta || entry.message?.role !== 'user')
@@ -170,7 +180,7 @@ export async function stopcheck(io, options) {
         const text = typeof input.last_assistant_message === 'string' && input.last_assistant_message.trim()
             ? input.last_assistant_message
             : turn.text;
-        if (turn.posted || !text || saysPosted(text) || !itemsForPerson(text))
+        if (turn.posted || !text || saysPosted(text) || saysNoCard(text) || !itemsForPerson(text))
             return 0;
         io.out(`${JSON.stringify({ decision: 'block', reason: STOP_REASON })}\n`);
         return 0;

package/dist/version.js

@@ -1,2 +1,2 @@
 // The command line's version, as published (package.json). A test keeps them the same.
-export const VERSION = '0.4.0';
+export const VERSION = '0.6.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pendingyou",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Pending You for Claude Code: hear your answers from Pending You in the background, and set Claude Code up in one command.",
   "license": "Apache-2.0",
   "homepage": "https://www.pendingyou.com",