pendingyou 0.28.0 → 0.30.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 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
+  computer and shows one computer, not two. Besides the connections `init` made, it now finds the sign-ins your apps
+  made on their own at this Pending You (Claude Code's `/mcp` Authenticate, or the Pending You plugin's server, kept in
+  Claude Code's own credentials; Codex's and OpenCode's MCP sign-ins kept in their files) and proves this computer's key
+  for each, reading only their OAuth clients, never a token. Pending You links the ones that are yours and on no other
+  computer, and merges an app's older sign-ins here into the one in use. Nothing is ever linked by a computer's name.
+  `init` links at once; the hooks, `hold`, the MCP headers helper and the wake do it in the background every few hours.
+  `npx pendingyou machine link` does it now.
+- Proving the key again no longer renames the computer: a name you gave it in Pending You stays.
+
 ## 0.28.0 (2026-10-07)
 
 - When a card you asked was handed to another assistant and comes back to your person without its answer (handed

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
@@ -440,8 +440,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
@@ -467,6 +467,12 @@ computer's agents.
   account; the next `init` then proves the new one.
 - `npx pendingyou machine attest --client-id <id>` prints a proof of this computer for an app's own sign-in with a code
   (`--cnf <thumbprint>` for that app's own key, `--name` for another name). It never prints the key.
+- `npx pendingyou machine link` (0.29.0) links this computer's sign-ins to it now: the agents' connections, and the
+  sign-ins your apps made on their own (Claude Code's `/mcp` Authenticate or the Pending You plugin, Codex's and
+  OpenCode's MCP sign-ins), found by their OAuth clients in those apps' own stores here, never a token. Pending You then
+  names them all by this computer and merges an app's older sign-ins here into the one in use. `init` does it, and the
+  hooks every few hours in the background; nothing is linked by a computer's name. Rename a computer once, in Settings
+  › Apps and devices, and every assistant on it follows.
 
 `uninstall` leaves the key: it names the computer and grants nothing on its own.
 
@@ -500,7 +506,7 @@ its environment. A failing command is tried twice more, then skipped. `--once` s
 | `uninstall` | Remove what `init` added, and sign out (`--app`) |
 | `mcp --app <app>` | The stdio bridge: a local MCP server for an agent that can't run a headers helper (OpenCode, Pi), which passes each message on to Pending You with that agent's own sign-in here (`--check`) |
 | `herdr doctor` | Pending You in Herdr: the badges, the plugin, its toasts and its sidebar row. The plugin runs `herdr next`, `open`, `setup`, `view` and `unconfigure`; the agents' writers `herdr report` |
-| `machine status` / `attest` / `rotate` | This computer's key: whether Pending You knows each agent's connection by it (exits 0 when it does), a proof of it for an app's own sign-in (`--client-id`, `--cnf`, `--name`), or a new key (`--yes`) |
+| `machine status` / `attest` / `rotate` / `link` | This computer's key: whether Pending You knows each agent's connection by it (exits 0 when it does), a proof of it for an app's own sign-in (`--client-id`, `--cnf`, `--name`), a new key (`--yes`), or this computer's sign-ins linked to it now, your apps' own ones too (`--quiet`) |
 | `app login` / `logout` / `status` | An app that answers your cards when you press a key in it, signed in on this computer (`herdr`, or another app with `--client-id` and `--scope`; `--device`, `--browser`, `--name`), out again, or what each may do and until when |
 
 Every command takes `--origin` (default `https://www.pendingyou.com`, or `$PENDINGYOU_ORIGIN`). `--app` takes
@@ -521,8 +527,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

@@ -8,6 +8,7 @@ import { configDir, readJson, withLock, writeWhole } from "../files.js";
 import { APPROVED_DRAFT_NOTICE, approvesDraft, clip, delegatedOf, handledOf, isClosed, noticeOf, } from "../format.js";
 import { chooseThread, goesBy, HANDED_FOR_MS, handedCard, handedMessage, namesAnotherComputer, } from "../handed.js";
 import { clearHerdr, herdrTarget, isUrgency, PANE_ID, reportCommand, writeHerdr, } from "../herdr.js";
+import { linkSoon } from "../link.js";
 import { macName, tailscaleName } from "../remote.js";
 import { claimHanded, markHanded, momentOf, releaseHanded, wasHanded } from "../state.js";
 import { findCodex } from "./codex-app.js";
@@ -563,6 +564,7 @@ export async function listen(io, options) {
     const lease = await takeLease(io, app, thread);
     if (!lease)
         return 0;
+    await linkSoon(io, origin);
     const controller = new AbortController();
     const stop = () => controller.abort();
     if (io.signal.aborted)

package/dist/args.js

@@ -3,7 +3,7 @@ export const DEFAULT_ORIGIN = 'https://www.pendingyou.com';
 export const DEFAULT_TIMEOUT_MS = 4 * 60 * 60 * 1000;
 const MAX_TIMEOUT_MS = 24 * 60 * 60 * 1000;
 export const APP_SUBS = ['login', 'logout', 'status'];
-export const MACHINE_SUBS = ['status', 'attest', 'rotate'];
+export const MACHINE_SUBS = ['status', 'attest', 'rotate', 'link'];
 export const HERDR_SUBS = [
     'report',
     'next',
@@ -152,7 +152,7 @@ const FLAGS = {
         wait: false,
         ensure: false,
     },
-    machine: { origin: true, 'client-id': true, cnf: true, name: true, yes: false },
+    machine: { origin: true, 'client-id': true, cnf: true, name: true, yes: false, quiet: false },
     app: {
         origin: true,
         'client-id': true,
@@ -560,6 +560,7 @@ function machineCommand(origin, positional, flags, machine) {
         status: [],
         attest: ['client-id', 'cnf', 'name'],
         rotate: ['yes'],
+        link: ['quiet'],
     };
     for (const key of flags.keys())
         if (key !== 'origin' && !allowed[sub].includes(key))
@@ -568,6 +569,8 @@ function machineCommand(origin, positional, flags, machine) {
         return { name: 'machine', origin, sub };
     if (sub === 'rotate')
         return { name: 'machine', origin, sub, yes: flags.has('yes') };
+    if (sub === 'link')
+        return { name: 'machine', origin, sub, quiet: flags.has('quiet') };
     const clientId = flags.get('client-id');
     if (typeof clientId !== 'string' || !CLIENT_ID.test(clientId))
         throw new UsageError('machine attest needs the client the app signs in with, like: --client-id <its client id>');
@@ -671,7 +674,7 @@ export const USAGE = `pendingyou: Pending You for your coding agents (Claude Cod
   npx pendingyou herdr doctor  Pending You in Herdr: the badges on your agents' panes, the plugin, its
                                toasts and its sidebar row. The plugin runs herdr next, open, setup,
                                view and unconfigure
-  npx pendingyou machine status | attest | rotate
+  npx pendingyou machine status | attest | rotate | link
                                This computer's key, which Pending You knows it by (init makes it; it
                                never leaves the computer): whether Pending You knows each agent's
                                connection by it, a proof of it for an app's own sign-in

package/dist/hold.js

@@ -4,6 +4,7 @@ import { readPiManifest } from "./apps/pi.js";
 import { DEFAULT_ORIGIN, DEFAULT_TIMEOUT_MS } from "./args.js";
 import { readCredential } from "./credentials.js";
 import { describe } from "./format.js";
+import { linkSoon } from "./link.js";
 import { markHanded, momentOf } from "./state.js";
 export const LONG_POLL_SECONDS = 25;
 const PATIENT_AFTER_MS = 30 * 60 * 1000;
@@ -57,6 +58,7 @@ export async function hold(io, options) {
     };
     if (!(await readCredential(io, origin)))
         return signInNeeded(false);
+    await linkSoon(io, origin);
     let failures = 0;
     for (;;) {
         if (io.signal.aborted) {

package/dist/index.js

@@ -1,6 +1,7 @@
 export { getJson, SignInNeeded, Unavailable } from "./api.js";
 export { DEFAULT_ORIGIN, parseArgs } from "./args.js";
 export { readCredential, updateCredential } from "./credentials.js";
+export { appClients, clientsIn, LINK_PATH, linkClients, machineLink } from "./link.js";
 export { attest, ensureMachine, machinePath, proveConnections, readMachine, thumbprintOf, } from "./machine.js";
 export { main } from "./main.js";
 export { CLIENT_NAME, deviceLink, discover, register, revoke, SCOPE, signIn, signInWithDevice, startDevice, waitForDevices, } from "./oauth.js";

package/dist/init.js

@@ -5,11 +5,13 @@ import { hookCommand } from "./claude.js";
 import { readCredential, saveConnectionClient } from "./credentials.js";
 import { hookLine, originArgs } from "./hooks.js";
 import { installCli, pruneCli, removeCli } from "./install.js";
+import { linkClients } from "./link.js";
 import { keyForSignIn, proveConnections } from "./machine.js";
 import { headlessReason, helperCommand, removeHelper, writeHelper } from "./remote.js";
 import { FINISH_SAY } from "./setup.js";
 import { removeShim, shimPath, writeShim } from "./shim.js";
 import { checkSignIn, logout, signInApps, titleFrom, titleHere } from "./signin.js";
+import { markLinked } from "./state.js";
 import { trustHooks } from "./trust.js";
 import { VERSION } from "./version.js";
 const line = (step) => `  ${step.ok ? 'ok     ' : 'check  '} ${step.text}\n`;
@@ -155,8 +157,13 @@ export async function init(io, options) {
             ...(options.machine ? { machine: options.machine } : {}),
             key,
         });
-        if (key)
+        if (key) {
             await proveConnections(io, options.origin, [...signed].flatMap(([app, how]) => (how === 'already' ? [app] : [])), key);
+            const linked = await linkClients(io, options.origin, key);
+            await markLinked(io, options.origin).catch(() => { });
+            if (linked.joined)
+                io.out(`Linked ${linked.joined === 1 ? 'a sign-in' : `${linked.joined} sign-ins`} your apps made on this computer to it, so Pending You names them by this computer.\n`);
+        }
     }
     else
         io.out(going.length === 1

package/dist/link.js

@@ -0,0 +1,143 @@
+import { createHash } from 'node:crypto';
+import { join } from 'node:path';
+import { sendJson } from "./api.js";
+import { APP_IDS } from "./apps/ids.js";
+import { connectionMachine, readCredential } from "./credentials.js";
+import { claudeDir, readJson } from "./files.js";
+import { attest, clockOffset, proveConnections, readMachine } from "./machine.js";
+import { machineOf } from "./remote.js";
+import { linkDue, markLinked } from "./state.js";
+export const LINK_PATH = '/mcp/cli/machine/link';
+export const LINK_EVERY_MS = 6 * 60 * 60 * 1000;
+const MAX_LINKS = 8;
+const CLIENT_ID = /^[\x21-\x7e]{1,300}$/;
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const sameUrl = (a, b) => a.replace(/\/+$/, '') === b.replace(/\/+$/, '');
+export function clientsIn(entries, url) {
+    if (!isRecord(entries))
+        return [];
+    const found = [];
+    for (const entry of Object.values(entries)) {
+        if (!isRecord(entry))
+            continue;
+        const address = entry.serverUrl ?? entry.server_url ?? entry.url;
+        const info = isRecord(entry.clientInfo) ? entry.clientInfo : {};
+        const client = entry.clientId ?? entry.client_id ?? info.clientId ?? info.client_id;
+        if (typeof address !== 'string' || !sameUrl(address, url))
+            continue;
+        if (typeof client === 'string' && CLIENT_ID.test(client) && !found.includes(client))
+            found.push(client);
+    }
+    return found;
+}
+async function claudeCodeStore(io) {
+    if (io.platform === 'darwin') {
+        const custom = io.env.CLAUDE_SECURESTORAGE_CONFIG_DIR ?? io.env.CLAUDE_CONFIG_DIR;
+        const suffix = custom
+            ? `-${createHash('sha256').update(custom.normalize('NFC')).digest('hex').slice(0, 8)}`
+            : '';
+        const user = io.env.USER || io.env.LOGNAME || '';
+        const account = /^[a-zA-Z0-9._-]+$/.test(user) ? user : 'claude-code-user';
+        const found = await io
+            .run('security', ['find-generic-password', '-a', account, '-w', '-s', `Claude Code-credentials${suffix}`], 5000)
+            .catch(() => null);
+        if (found?.code === 0 && found.stdout.trim()) {
+            try {
+                return JSON.parse(found.stdout.trim());
+            }
+            catch { }
+        }
+    }
+    return readJson(join(claudeDir(io), '.credentials.json')).catch(() => null);
+}
+export async function appClients(io, origin) {
+    const url = `${origin}/mcp`;
+    const found = [];
+    const add = (app, clients) => {
+        for (const clientId of clients)
+            if (!found.some((each) => each.clientId === clientId))
+                found.push({ app, clientId });
+    };
+    const claude = await claudeCodeStore(io);
+    add('claude-code', clientsIn(isRecord(claude) ? claude.mcpOAuth : null, url));
+    const codexHome = io.env.CODEX_HOME || join(io.home, '.codex');
+    add('codex', clientsIn(await readJson(join(codexHome, '.credentials.json')).catch(() => null), url));
+    const data = io.env.XDG_DATA_HOME || join(io.home, '.local', 'share');
+    add('opencode', clientsIn(await readJson(join(data, 'opencode', 'mcp-auth.json')).catch(() => null), url));
+    return found.slice(0, MAX_LINKS);
+}
+export async function linkClients(io, origin, machine) {
+    const clients = await appClients(io, origin);
+    const none = { found: clients.length, joined: 0, merged: 0, failed: false };
+    if (clients.length === 0)
+        return none;
+    let signedIn = null;
+    for (const app of APP_IDS)
+        if (await readCredential(io, origin, app)) {
+            signedIn = app;
+            break;
+        }
+    if (!signedIn)
+        return { ...none, failed: true };
+    try {
+        const name = (await connectionMachine(io, origin, signedIn)) ?? machineOf(io.host);
+        const offset = await clockOffset(io, origin);
+        const links = [];
+        for (const { clientId } of clients)
+            links.push({
+                clientId,
+                attestation: await attest(machine, { aud: `${origin}${LINK_PATH}`, client_id: clientId, name }, io.now() + offset),
+            });
+        const { status, body } = await sendJson(io, origin, LINK_PATH, { links }, 15_000, { app: signedIn });
+        if (status !== 200)
+            return { ...none, failed: true };
+        return {
+            found: clients.length,
+            joined: (body.links ?? []).filter((each) => each.connection === 'joined').length,
+            merged: typeof body.merged === 'number' ? body.merged : 0,
+            failed: false,
+        };
+    }
+    catch {
+        return { ...none, failed: true };
+    }
+}
+export async function machineLink(io, command) {
+    const say = (text) => {
+        if (!command.quiet)
+            io.out(text);
+    };
+    const machine = await readMachine(io).catch(() => null);
+    if (!machine) {
+        say('This computer has no key yet. npx -y pendingyou@latest init makes one, and links its sign-ins.\n');
+        return 1;
+    }
+    await markLinked(io, command.origin).catch(() => { });
+    const own = [];
+    for (const app of APP_IDS)
+        if ((await readCredential(io, command.origin, app))?.kind === 'connection')
+            own.push(app);
+    const proven = own.length
+        ? await proveConnections(io, command.origin, own, machine).catch(() => new Map())
+        : new Map();
+    const linked = await linkClients(io, command.origin, machine);
+    const joined = [...proven.values()].filter((each) => each === 'joined').length + linked.joined;
+    if (linked.failed && linked.found > 0)
+        say(`Found ${linked.found === 1 ? 'a sign-in' : `${linked.found} sign-ins`} of this computer’s apps, but Pending You couldn’t be asked to link ${linked.found === 1 ? 'it' : 'them'} now. Try again later.\n`);
+    else if (joined === 0)
+        say('Every sign-in on this computer is linked to it already.\n');
+    else
+        say(`Linked ${joined === 1 ? 'a sign-in' : `${joined} sign-ins`} on this computer to it${linked.merged ? `, and Pending You merged ${linked.merged === 1 ? 'an older one' : `${linked.merged} older ones`} into the one in use` : ''}.\n`);
+    return 0;
+}
+export async function linkSoon(io, origin) {
+    try {
+        if (!(await linkDue(io, origin, LINK_EVERY_MS)))
+            return;
+        if (!(await readMachine(io)))
+            return;
+        await markLinked(io, origin);
+        io.background(['machine', 'link', '--quiet', '--origin', origin]);
+    }
+    catch { }
+}

package/dist/machine-command.js

@@ -1,6 +1,7 @@
 import { APP_NAMES } from "./apps/ids.js";
 import { readCredential, signedInSlots } from "./credentials.js";
 import { originArgs } from "./hooks.js";
+import { machineLink } from "./link.js";
 import { attest, clockOffset, machinePath, readMachine, rotateMachine } from "./machine.js";
 import { computerName } from "./remote.js";
 import { checkSignIn } from "./signin.js";
@@ -97,5 +98,7 @@ export function machine(io, command) {
             return machineAttest(io, command);
         case 'rotate':
             return machineRotate(io, command);
+        case 'link':
+            return machineLink(io, command);
     }
 }

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/pickup.js

@@ -8,6 +8,7 @@ import { clip, delegatedOf, describe, HANDED_PREFIX, isHandedWake, } from "./for
 import { goesBy, HANDED_GRACE_MS, namesAnotherComputer } from "./handed.js";
 import { herdrTarget, reportCommand } from "./herdr.js";
 import { holdCommand } from "./hold.js";
+import { linkSoon } from "./link.js";
 import { unwokenLine } from "./loaded.js";
 import { stuckLine } from "./mcp-health.js";
 import { isPermissionCard, isPromptApp, POSTED_MAX, sessionName, sessionPosted, settlePrompts, } from "./permission.js";
@@ -147,6 +148,7 @@ export async function pickup(io, options, hook = { fallback: '' }) {
     try {
         const input = await hookInput(io);
         const { cwd } = input;
+        await linkSoon(io, origin);
         if (mode === 'handoff' && isPromptApp(app))
             await settlePrompts(io, { session: input.session, event: 'prompt' });
         const known = mode === 'handoff' && app === DEFAULT_APP && input.session

package/dist/remote.js

@@ -5,6 +5,7 @@ import { APP_NAMES, DEFAULT_APP } from "./apps/ids.js";
 import { cleanName, DEFAULT_ORIGIN } from "./args.js";
 import { readCredential } from "./credentials.js";
 import { configDir, writeWhole } from "./files.js";
+import { linkSoon } from "./link.js";
 import { recordHelper } from "./mcp-health.js";
 import { VERSION } from "./version.js";
 export const HELPER = 'pendingyou-mcp-headers';
@@ -261,6 +262,7 @@ export async function mcpHeaders(io, options) {
         const token = await helperToken(io, options.origin, HELPER_WAIT_MS, app);
         headers(token);
         await recordHelper(io, options.origin, app, 'ok');
+        await linkSoon(io, options.origin);
         return 0;
     }
     catch (error) {

package/dist/state.js

@@ -12,6 +12,7 @@ async function load(io) {
         handed: file?.handed && typeof file.handed === 'object' ? file.handed : {},
         ...(file?.reminded && typeof file.reminded === 'object' ? { reminded: file.reminded } : {}),
         ...(file?.unwoken && typeof file.unwoken === 'object' ? { unwoken: file.unwoken } : {}),
+        ...(file?.linked && typeof file.linked === 'object' ? { linked: file.linked } : {}),
     };
 }
 async function change(io, edit) {
@@ -85,3 +86,12 @@ export async function claimUnwoken(io, session) {
     });
     return claimed;
 }
+export async function linkDue(io, origin, every) {
+    const at = (await load(io)).linked?.[origin];
+    return typeof at !== 'number' || io.now() - at >= every || at > io.now();
+}
+export function markLinked(io, origin) {
+    return change(io, (state) => {
+        state.linked = { ...state.linked, [origin]: io.now() };
+    });
+}

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.28.0';
+export const VERSION = '0.30.0';

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

@@ -1,7 +1,7 @@
 {
   "name": "pendingyou-wake",
   "displayName": "Pending You",
-  "version": "2.44.0",
+  "version": "2.44.1",
   "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.44.1; send changes there.

package/package.json

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