pendingyou 0.29.0 → 0.31.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.31.0 (2026-10-08)
+
+- “I’ll handle it” has one meaning (guide 2.45): the person will handle it themselves. `hold`, the hooks, the wake mod
+  and the Codex wake say so in Pending You's own words, “The person will handle this themselves. Close it out: take no
+  action on it, leave things as they are (an email stays in their inbox, untouched), and don’t follow up or ask
+  again.”, then to ack_answer with an outcome like “Left to you”. The app no longer offers “Leave it”; a server since
+  guide 2.45 sends an older one as the same. `leave` now means only a to-do's Skip: “your person won’t do it”, don't do
+  it for them or follow up, and pick it up with an outcome like “Skipped”. Older command lines still stand down on
+  both.
+
+## 0.30.0 (2026-10-07)
+
+- This computer's own sign-ins (the connections `init` made for Claude Code, Codex, OpenCode and Pi) now last while
+  you use them. Each refresh carries a proof by this computer's key (a DPoP proof, RFC 9449, signed with the key in
+  `~/.config/pendingyou/machine.json`), and Pending You renews a sign-in for 30 days from that refresh when it's proven
+  by the key of the computer it's on. Before, every sign-in ended 30 days after it began, however much it was used. A
+  computer left unused for 30 days still signs out; Pending You says so 3 days before. Its tokens are unchanged, and a
+  refresh never fails for want of a proof: without a key, or when the proof isn't taken, it refreshes as before.
+
 ## 0.29.0 (2026-10-07)
 
 - The command line links this computer's sign-ins to it by its key, so Pending You names every assistant here by this

package/README.md

@@ -339,8 +339,8 @@ hold to approve. Pending You says on the card and to the agent "Answered in Herd
 Herdr (moving between panes, tabs and workspaces, or pressing keys in the popup) your phone stays quiet for those cards,
 as it does while Pending You is open on your desk.
 
-`npx pendingyou app status` says what each app signed in here may do and until when (a sign-in lasts 30 days; it warns
-in the last 3), and `npx pendingyou app logout herdr` ends Herdr's sign-in. Settings › Apps and devices in Pending You
+`npx pendingyou app status` says what each app signed in here may do and until when (a sign-in lasts 30 days from its
+last use here; it warns in the last 3), and `npx pendingyou app logout herdr` ends Herdr's sign-in. Settings › Apps and devices in Pending You
 lists it too, with Remove. It needs `init` to have run here first: this computer's key vouches for the sign-in.
 
 ## How Claude Code hears your answer
@@ -378,10 +378,11 @@ next message brings any answer with it too.
 When you're at the terminal, Claude Code asks you there and puts the same question in Pending You at once; the
 first answer wins. If you answer in the terminal, it withdraws the card and the hold ends by itself.
 
-**When you'll handle it yourself (0.20.0).** A card you end with “I’ll handle it” in Pending You (“I’ll do it myself”,
-or “Leave it”) reaches the agent the same ways, saying which: instead of acting on it, it's told to stand down (nothing
-done, drafted, sent or followed up for it; with “Leave it”, an email or a task gets no reply), to pick it up with
-`ack_answer` and an outcome like “Left to you”, and never to post it again.
+**When you'll handle it yourself (0.20.0; one meaning in 0.31.0).** A card you end with “I’ll handle it” in Pending
+You reaches the agent the same ways, in these words: “The person will handle this themselves. Close it out: take no
+action on it, leave things as they are (an email stays in their inbox, untouched), and don’t follow up or ask again.”
+Then it picks it up with `ack_answer` and an outcome like “Left to you”, and never posts it again. A to-do you Skip
+says you won't do it: the agent doesn't do it for you or follow up, and picks it up with an outcome like “Skipped”.
 
 **Finishing setup by itself (0.11.0).** In `init`'s copy of the mod, a few seconds after a session you're at opens
 (never `claude -p`), it asks Pending You whether Claude Code is set up here (`whoami`, once Pending You's tools are
@@ -440,8 +441,8 @@ The machine is called by its Tailscale name when Tailscale is installed and runn
 else by its hostname, or by `--name build-01` on `init` or `login`; a Mac by its own name (Sharing in System Settings).
 A cloud's own hostname (AWS's `ip-10-42-1-252`) is kept when there's nothing better, and `login` says how to change it:
 `npx pendingyou login --name <name>` asks for one more approval and renames the connection, which stays the same one.
-If an agent's sign-in ends (30 days, or you remove it on your Assistants page), `npx pendingyou login` (`--app codex`
-for Codex's) approves a new code and keeps the same connection.
+If an agent's sign-in ends (30 days unused, or you remove it on your Assistants page), `npx pendingyou login`
+(`--app codex` for Codex's; `--force` while it still works) approves a new code and keeps the same connection.
 
 Only want this command's own sign-in (for `watch`, below)? `npx pendingyou login --device` signs it in with a code,
 hearing answers only, and adds no connection. Your phone asks "Let build-01 hear your answers for the assistants
@@ -527,8 +528,9 @@ The hooks use the same sign-in, and hand a session only the cards its own app po
 signs in by itself (`--oauth`, or one you kept) gets a sign-in that only hears its answers instead: it can't ask,
 answer or change anything, and doesn't show up as an assistant. They're stored in `~/.config/pendingyou/credentials.json`
 (readable only by you, in a folder with a `.gitignore` of `*` so a dotfiles repository never takes it), refresh
-themselves, and end after 30 days or on `logout`. The headers helper hands an agent's token only to that agent's
-Pending You (Claude Code says which server it's for; Codex's is the one `init` wrote). `clients.json` remembers which
+themselves, last 30 days from their last use (0.30.0: each refresh proves this computer's key, and Pending You renews
+the sign-in from then), and end once unused that long, or on `logout`. The headers helper hands an agent's token only
+to that agent's Pending You (Claude Code says which server it's for; Codex's is the one `init` wrote). `clients.json` remembers which
 sign-in each agent's connection used, so signing in again keeps it. `machine.json` (0.18.0) holds this computer's key
 pair, private like the rest; only its proofs leave the computer, each for one sign-in, once. `apps/<app>.json` (0.21.0)
 holds an app's own sign-in and the private key its tokens are bound to (DPoP), private like the rest; the Pending You

package/dist/api.js

@@ -33,8 +33,11 @@ async function refreshStored(io, origin, stored, options, app) {
             return current;
         if (!options.force && current.expiresAt - options.earlyMs > io.now())
             return current;
+        const prove = current.kind === 'connection'
+            ? await (await import("./machine.js")).machineProver(io)
+            : undefined;
         try {
-            const tokens = await refresh(io, origin, current.clientId, current.refreshToken);
+            const tokens = await refresh(io, origin, current.clientId, current.refreshToken, prove);
             return { ...current, ...tokens };
         }
         catch (error) {

package/dist/apps/codex-wake.js

@@ -414,12 +414,12 @@ function line(heard, card) {
             if (handledOf(heard) === 'self')
                 return [
                     `your person will handle ${titled} themselves`,
-                    `call ${get} to read it, don’t act on it, then ack_answer with its version and an outcome like “Left to you”`,
+                    `call ${get} to read it, then close it out: take no action on it, leave things as they are and don’t follow up; ack_answer with its version and an outcome like “Left to you”`,
                 ];
             if (handledOf(heard) === 'leave')
                 return [
-                    `your person said to leave ${titled}`,
-                    `call ${get} to read it, do nothing for it (no reply, no follow-up), then ack_answer with its version and an outcome like “Left it”`,
+                    `your person won’t do ${titled}`,
+                    `call ${get} to read it, then close it out: don’t do it for them and don’t follow up; ack_answer with its version and an outcome like “Skipped”`,
                 ];
             return [
                 `your person answered ${titled}`,

package/dist/format.js

@@ -12,7 +12,12 @@ export function handledOf(heard) {
     const given = heard.handled;
     return given === 'self' || given === 'leave' ? given : null;
 }
-const HANDLED_SAID = { self: 'I’ll do it myself', leave: 'Leave it' };
+const HANDLED_SAID = {
+    self: ['I’ll handle it', 'I’ll do it myself'],
+    leave: ['I won’t do it', 'Leave it'],
+};
+export const HANDLED_MEANS = 'The person will handle this themselves. Close it out: take no action on it, leave things as they are (an email stays in their inbox, untouched), and don’t follow up or ask again.';
+export const SKIPPED_MEANS = 'The person won’t do this to-do. Close it out: don’t do it for them, leave things as they are, and don’t follow up or ask again.';
 export const APPROVED_DRAFT_NOTICE = 'The approved words are in get_request’s answer.approvedDrafts: send them exactly.';
 export const approvesDraft = (heard) => heard.approvedDraft === true;
 export const HANDED_PREFIX = 'Pending You: your person handed you';
@@ -140,11 +145,12 @@ function describeNotice(heard, notice) {
 }
 function standDown(heard, handled) {
     const ack = `ack_answer with requestId ${heard.requestId}, name ${named(heard)}, expectedVersion ${heard.version}`;
-    const noted = Boolean(heard.said?.trim() && heard.said.trim() !== HANDLED_SAID[handled]);
-    const note = noted ? '; if their note asks you for one thing, do just that' : '';
+    const said = heard.said?.trim();
+    const noted = Boolean(said && !HANDLED_SAID[handled].includes(said));
+    const note = noted ? ' If their note asks you for one thing, do just that.' : '';
     return handled === 'self'
-        ? `Stand down: don’t act on it, don’t draft or send anything for it, and don’t follow up${note}. Then call ${ack} and an outcome like “Left to you”. Never post it again.`
-        : `Stand down: nobody does it, so an email or a task gets no reply and no follow-up, and nothing is archived or deleted unless their rules say so${note}. Then call ${ack} and an outcome like “Left it”. Never post it again.`;
+        ? `${HANDLED_MEANS}${note} Then call ${ack} and an outcome like “Left to you”. Never post it again.`
+        : `${SKIPPED_MEANS}${note} Then call ${ack} and an outcome like “Skipped”. Never post it again.`;
 }
 export function describe(heard, again) {
     const id = heard.requestId;
@@ -166,9 +172,9 @@ export function describe(heard, again) {
         case 'answered': {
             const handled = handledOf(heard);
             if (handled) {
-                const answer = clip(heard.said ?? HANDLED_SAID[handled], MAX_ANSWER);
+                const answer = clip(heard.said ?? HANDLED_SAID[handled][0] ?? '', MAX_ANSWER);
                 cut ||= answer.cut;
-                lines.push(`Pending You: ${id} is answered: ${handled === 'self' ? 'your person will do it themselves' : 'your person said to leave it'}.`, question, `Answer: ${answer.text}`);
+                lines.push(`Pending You: ${id} is answered: ${handled === 'self' ? 'your person will handle it themselves' : 'your person won’t do it'}.`, question, `Answer: ${answer.text}`);
                 if (wrote.length)
                     lines.push(`They also wrote: ${wrote.join(' ')}`);
                 lines.push(standDown(heard, handled));

package/dist/machine.js

@@ -7,6 +7,7 @@ import { PlainError } from "./errors.js";
 import { configDir, readJson, withLock, writeWhole } from "./files.js";
 import { discover } from "./oauth.js";
 import { machineOf } from "./remote.js";
+import { proof as dpopProof } from "./sdk/dpop.js";
 export const ATTESTATION_TYPE = 'pendingyou-machine+jwt';
 const ATTESTATION_SECONDS = 300;
 export const MACHINE_PATH = '/mcp/cli/machine';
@@ -100,6 +101,13 @@ export async function attest(machine, claims, now) {
     const signature = await webcrypto.subtle.sign({ name: 'ECDSA', hash: 'SHA-256' }, machine.signer, Buffer.from(signing));
     return `${signing}.${base64url(new Uint8Array(signature))}`;
 }
+export async function machineProver(io) {
+    const machine = await readMachine(io).catch(() => null);
+    if (!machine)
+        return undefined;
+    const key = { jwk: machine.jwk, jkt: machine.thumbprint, privateKey: machine.signer };
+    return ({ method, url, nonce, now }) => dpopProof(key, { method, url, now, ...(nonce ? { nonce } : {}) });
+}
 export async function keyForSignIn(io) {
     try {
         const { machine, made } = await ensureMachine(io);

package/dist/oauth.js

@@ -128,14 +128,28 @@ async function listen(state, signal) {
         },
     };
 }
-async function tokenRequest(io, metadata, params, timeoutMs = 20_000) {
-    const response = await io.fetch(metadata.token_endpoint, {
+async function tokenRequest(io, metadata, params, timeoutMs = 20_000, prove) {
+    const signal = AbortSignal.timeout(timeoutMs);
+    const send = async (dpop) => io.fetch(metadata.token_endpoint, {
         method: 'POST',
-        headers: { 'content-type': 'application/x-www-form-urlencoded', accept: 'application/json' },
+        headers: {
+            'content-type': 'application/x-www-form-urlencoded',
+            accept: 'application/json',
+            ...(dpop ? { dpop } : {}),
+        },
         body: new URLSearchParams(params).toString(),
-        signal: AbortSignal.timeout(timeoutMs),
+        signal,
     });
-    const body = (await response.json().catch(() => ({})));
+    const proof = (nonce) => (prove ? prove(nonce).catch(() => null) : null);
+    let response = await send(await proof());
+    let body = (await response.json().catch(() => ({})));
+    for (const again of ['nonce', 'plain']) {
+        if (body.error !== 'use_dpop_nonce')
+            break;
+        const nonce = response.headers.get('dpop-nonce');
+        response = await send(again === 'nonce' && nonce ? await proof(nonce) : null);
+        body = (await response.json().catch(() => ({})));
+    }
     if (!response.ok ||
         typeof body.access_token !== 'string' ||
         typeof body.refresh_token !== 'string') {
@@ -192,14 +206,21 @@ export async function signIn(io, options) {
         loopback.close();
     }
 }
-export async function refresh(io, origin, clientId, refreshToken) {
+export async function refresh(io, origin, clientId, refreshToken, prove) {
     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);
+    }, 12_000, prove
+        ? (nonce) => prove({
+            method: 'POST',
+            url: metadata.token_endpoint,
+            now: serverNow(io, metadata),
+            ...(nonce ? { nonce } : {}),
+        })
+        : undefined);
 }
 export async function revoke(io, origin, clientId, refreshToken) {
     try {

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.29.0';
+export const VERSION = '0.31.0';

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

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

package/mod/hooks/wake.js

@@ -391,12 +391,12 @@ function line(card) {
             if (state.handled === 'self')
                 return [
                     `your person will handle ${titled(card)} themselves`,
-                    `call ${get} to read it, don’t act on it, then ack_answer with its version and an outcome like “Left to you”`,
+                    `call ${get} to read it, then close it out: take no action on it, leave things as they are and don’t follow up; ack_answer with its version and an outcome like “Left to you”`,
                 ];
             if (state.handled === 'leave')
                 return [
-                    `your person said to leave ${titled(card)}`,
-                    `call ${get} to read it, do nothing for it (no reply, no follow-up), then ack_answer with its version and an outcome like “Left it”`,
+                    `your person won’t do ${titled(card)}`,
+                    `call ${get} to read it, then close it out: don’t do it for them and don’t follow up; ack_answer with its version and an outcome like “Skipped”`,
                 ];
             return [
                 `your person answered ${titled(card)}`,

package/package.json

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