pendingyou 0.21.0 → 0.23.0

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## 0.23.0 (2026-10-06)
+
+- The Claude Code wake mod survives upgrades. `init` now copies it to `~/.config/pendingyou/mod`, a folder that stays
+  put across versions, and points `CLAUDE_CODE_PLUGIN_DIRS` there, so the entry never changes again. Before, it named
+  the version's own folder, which the next upgrade removed: a session already open (Claude Code reads its plugin
+  folders only as a session starts) was left with no wake mod and nothing said, and answers reached it only when you
+  typed. Open interactive sessions reload the mod when `init` updates it. `init` keeps the newest older copy for
+  sessions started before this version, and `status` says when the entry still names a version.
+- A session the wake mod doesn't run in is told so, once: with its next message, the hooks say “Pending You can’t wake
+  this session: Claude Code started before Pending You’s wake was set up. Ask your person to restart it (/exit, then
+  claude --continue) at a good moment.”, and to background a hold until then. The mod notes each session it runs in
+  (`~/.config/pendingyou/wake/sessions/`), and presence remembers when an older mod said a session is live.
+- `init` names the Claude Code sessions open here that started before the wake mod was set up, by the name they go by
+  and their folder, and says to restart each at a good moment.
+- A question handed to your agent by its name reaches it in whatever folder it works. The wake mod and the hooks took
+  one only in the folder Pending You heard it in (its task's, or the agent's last task's), so an agent working elsewhere
+  never heard it. The hooks now send the session's name, and the mod reads Pending You's `byName`; one handed to the app
+  with no agent still goes by its folder. Needs Pending You's matching release.
+
+## 0.22.1 (2026-10-06)
+
+- The Herdr plugin's popup finishes noting your last key press (what keeps your phone quiet while you're in Herdr)
+  before it closes, rather than leaving it half-written in the plugin's state folder.
+
+## 0.22.0 (2026-10-06)
+
+- Trusting Codex's hooks is one command now. When `init` or `status` finds Pending You's hooks in Codex but not trusted
+  yet, it prints the command that opens a Codex here (`codex` on PATH, else the Codex command line the ChatGPT app
+  brings, by its full path, quoted) and says to type `/hooks` there, look over Pending You's hooks and trust them. At a
+  terminal it then waits, looking again every 3 seconds for up to 10 minutes, and says "Ready: Codex hears answers
+  right away" once they're trusted (Ctrl-C stops the wait; `npx pendingyou status` checks later). Run by an agent, it
+  prints the same steps without waiting. It never trusts them for you.
+- The instructions no longer send you to a Hooks page in the Codex app's Settings, which people couldn't find, nor to
+  other ways of trusting the hooks that haven't been seen working: init's last lines and `status` lead with `/hooks`.
+- Looking for the Codex inside the ChatGPT or Codex app, the command line tries the `CodexCLI.app` it carries first,
+  then its `bin` folder.
+
 ## 0.21.0 (2026-10-06)
 
 - Answer from Herdr. The Pending You plugin for Herdr (0.2) can now answer your cards from its popup, once you sign

package/README.md

@@ -41,8 +41,8 @@ Finish setting up Pending You: it’s connected here already.
 ```
 
 The first session finishes setting up on its own: it checks in with Pending You, reports what's set up and sends you a
-test card. Claude Code 2.1.287 or later starts that turn by itself; otherwise (and in Codex, after you trust its hooks:
-“Trust all and continue” in Codex CLI, Review hooks › Allow all in the Codex app) the session start adds one line with
+test card. Claude Code 2.1.287 or later starts that turn by itself; otherwise (and in Codex, after you trust its hooks in
+`/hooks`) the session start adds one line with
 the three calls that are left, and you say the sentence.
 `npx pendingyou status` says what's set up for each agent, what's missing with the command that fixes it, and how setup
 stands. `npx pendingyou uninstall` removes exactly what `init` added.
@@ -99,9 +99,11 @@ default_tools_approval_mode = "approve"
 and hooks in `~/.codex/hooks.json`: a session start, each message, Pending You's card tools (so the Stop check knows a
 turn posted, and so the thread is woken), and the Stop check; and (0.15.0) Codex's permission prompt and every tool
 call that ran (a card when Codex waits for your OK, [below](#when-claude-code-waits-for-your-ok)) and the session's end
-([below](#which-sessions-are-open)). **Codex runs a hook only once you trust it**: in Codex CLI, start `codex` and
-choose “Trust all and continue” (or trust them in `/hooks`); in the Codex app, click Review hooks › Allow all (or
-Settings › Hooks › Trust all). `status` says which are trusted. Upgrading from 0.14.0 adds three hooks, which Codex
+([below](#which-sessions-are-open)). **Codex runs a hook only once you trust it**, in Codex's `/hooks`. When `init` or
+`status` finds Pending You's hooks not trusted yet, it prints the one command that opens a Codex here (`codex`, or
+the one the ChatGPT app brings, by its full path) and says to type `/hooks` there and trust them; at a terminal it
+then waits (every 3 seconds, for up to 10 minutes; Ctrl-C stops it) until Codex trusts them, and says whether Codex is
+ready. It never trusts them for you. `status` says which are trusted. Upgrading from 0.14.0 adds three hooks, which Codex
 skips until you trust them once; `init` says so, and the ones you trusted stay trusted. A `pendingyou` server or
 hooks Codex's `/import` copied from Claude Code (without its sign-in) are replaced.
 
@@ -352,6 +354,11 @@ with `claude --continue`. Under the prompt it shows `⚠ pendingyou-wake: 2 wait
 `npx pendingyou hold`, the mod answers it at once and nothing runs in the background. With the Pending You plugin
 installed as well, only one copy acts. `npx pendingyou status` says whether the mod is loaded.
 
+Claude Code loads the mod only as a session starts, so a session that was already open when you ran `init` the first
+time can't be woken until you restart it (`/exit`, then `claude --continue`): `init` names those sessions, and the
+session itself is told once with your next message. Later upgrades don't need a restart: the mod lives in
+`~/.config/pendingyou/mod`, which `init` updates in place, and open sessions reload it.
+
 The mod's checks are Pending You tool calls like Claude Code's own, so they need Pending You's tools allowed, which
 `init` does (`mcp__pendingyou`). If they aren't, the line under the prompt says which rule to add in `/permissions`, and
 holds run as before.

package/dist/apps/claude-code.js

@@ -2,7 +2,8 @@ import { addCommand, claudeState, helperServer, installClaude, mcpFromClaude, mc
 import { connectionMachine, readCredential } from "../credentials.js";
 import { differs, serverForFolder, siteOf } from "../environment.js";
 import { originArgs } from "../hooks.js";
-import { claudeVersion, loadsMods, MOD_CLAUDE } from "../mod.js";
+import { modConfigured, pruneLoadedNotes, unwokenLines, unwokenSessions, } from "../loaded.js";
+import { claudeVersion, isOurModDir, loadsMods, MOD_CLAUDE } from "../mod.js";
 import { checkHelper, foundBy, headlessReason, helperCommand, helperPath, isOurHelper, machineOf, usesHelper, } from "../remote.js";
 import { connectionTitle, FINISH_SAY, setupOf, setupStatus } from "../setup.js";
 import { shimPath } from "../shim.js";
@@ -144,32 +145,41 @@ export const claudeCode = {
             plan = { action: 'add' };
         const signIn = mode === 'helper' ? 'connection' : 'hear';
         const added = plan.action !== 'keep';
+        let unwoken = [];
         return {
             app: claudeCode,
             detected,
             signIn,
-            install: (ictx) => installClaude(io, ctx.origin, {
-                version: detected.version,
-                mcp: plan,
-                mode,
-                helper: ictx.helper,
-                plugin: Boolean(plugin),
-                copy: ictx.copy,
-                hookLine: ictx.hookLine,
-                report: ictx.report,
-                progress: ictx.progress,
-                ...(ctx.permissionCards === undefined ? {} : { permissionCards: ctx.permissionCards }),
-            }),
+            install: async (ictx) => {
+                const steps = await installClaude(io, ctx.origin, {
+                    version: detected.version,
+                    mcp: plan,
+                    mode,
+                    helper: ictx.helper,
+                    plugin: Boolean(plugin),
+                    copy: ictx.copy,
+                    hookLine: ictx.hookLine,
+                    report: ictx.report,
+                    progress: ictx.progress,
+                    ...(ctx.permissionCards === undefined ? {} : { permissionCards: ctx.permissionCards }),
+                });
+                await pruneLoadedNotes(io).catch(() => { });
+                if (await modConfigured(io))
+                    unwoken = await unwokenSessions(io).catch(() => []);
+                return steps;
+            },
             next: (ictx) => {
+                const restart = unwokenLines(unwoken);
                 if (mode === 'oauth') {
                     const authenticate = added || !ictx.signedIn;
                     return {
                         lines: [
+                            ...restart,
                             authenticate
                                 ? 'Next, in Claude Code: if it’s open, restart it (/exit, then claude --continue), run /mcp, choose pendingyou and Authenticate. Then ask Claude Code to finish setting up Pending You.'
                                 : 'Next, in Claude Code: if it’s open, restart it (/exit, then claude --continue), so the hooks load. Then ask Claude Code to finish setting up Pending You.',
                         ],
-                        together: `- Claude Code: restart it (/exit, then claude --continue)${authenticate ? ', run /mcp, choose pendingyou and Authenticate' : ''}, then ask it to finish setting up Pending You.`,
+                        together: `- Claude Code: restart it (/exit, then claude --continue)${authenticate ? ', run /mcp, choose pendingyou and Authenticate' : ''}, then ask it to finish setting up Pending You.${restart.length ? ` ${restart.join(' ')}` : ''}`,
                         say: false,
                     };
                 }
@@ -177,6 +187,7 @@ export const claudeCode = {
                 const byItself = version !== null && loadsMods(version);
                 return {
                     lines: [
+                        ...restart,
                         `Next: ${RESTART}.`,
                         byItself
                             ? 'It finishes setting up by itself and sends you a test card. If it doesn’t, say this to it:'
@@ -184,7 +195,7 @@ export const claudeCode = {
                         '',
                         FINISH_SAY,
                     ],
-                    together: `- Claude Code: ${RESTART}. ${byItself ? 'It finishes setting up by itself and sends you a test card.' : 'Then say the line below to it.'}`,
+                    together: `- Claude Code: ${RESTART}. ${byItself ? 'It finishes setting up by itself and sends you a test card.' : 'Then say the line below to it.'}${restart.length ? ` ${restart.join(' ')}` : ''}`,
                     say: true,
                 };
             },
@@ -269,7 +280,7 @@ async function claudeStatus(io, ctx) {
         : !mod.loads
             ? `needs Claude Code ${MOD_CLAUDE} or later (this is ${claude.claude}); until then, a background hold wakes it`
             : mod.present
-                ? `in CLAUDE_CODE_PLUGIN_DIRS (${mod.dirs.join(', ')}); a session is woken when you answer, with no hold running`
+                ? `in CLAUDE_CODE_PLUGIN_DIRS (${mod.dirs.join(', ')}); a session is woken when you answer, with no hold running${mod.dirs.every((dir) => isOurModDir(dir)) ? `. Its folder names a version, so an update leaves open sessions without it: run npx pendingyou@latest init${flag}` : ''}`
                 : mod.plugin
                     ? 'in the Pending You plugin; a session is woken when you answer, with no hold running'
                     : mod.dirs.length

package/dist/apps/codex-app.js

@@ -4,7 +4,7 @@ const APP_NAMES = ['ChatGPT.app', 'Codex.app'];
 export function appCodexPaths(home, system = '/Applications') {
     return [system, join(home, 'Applications')].flatMap((root) => APP_NAMES.flatMap((name) => {
         const cli = join(root, name, 'Contents', 'Resources', 'codex-cli');
-        return [join(cli, 'bin', 'codex'), join(cli, 'CodexCLI.app', 'Contents', 'MacOS', 'codex')];
+        return [join(cli, 'CodexCLI.app', 'Contents', 'MacOS', 'codex'), join(cli, 'bin', 'codex')];
     }));
 }
 const versionOf = (stdout) => /(\d+\.\d+\.\d+)/.exec(stdout)?.[1] ?? 'installed';

package/dist/apps/codex.js

@@ -19,8 +19,22 @@ export const CODEX_MIN = '0.152.0';
 export const CODEX_WAKE = '0.157.0';
 export const CODEX_APP_WAKE = '0.149.0';
 const FROM_APP = 'the Codex app’s';
-const TRUST_CLI = 'in Codex CLI choose “Trust all and continue” (or trust them in /hooks)';
-const TRUST_APP = 'in the Codex app click Review hooks › Allow all (or Settings › Hooks › Trust all)';
+const TRUST = 'type /hooks in Codex and trust';
+export function trustSteps(found) {
+    const why = 'Codex runs Pending You’s hooks only once you trust them.';
+    if (!found)
+        return [
+            `${why} Open Codex in a terminal (codex, or the one that comes inside the ChatGPT app), type /hooks, look over Pending You’s hooks, and trust them.`,
+        ];
+    const command = found.app ? `'${found.command.replaceAll("'", `'\\''`)}'` : found.command;
+    return [
+        `${why} Open Codex in a terminal:`,
+        '',
+        `  ${command}`,
+        '',
+        'Type /hooks, look over Pending You’s hooks, and trust them.',
+    ];
+}
 const DONT_SAVE = 'In the Codex app, don’t press Save on pendingyou in Settings › MCP: that writes it again without this computer’s sign-in (if you did, run init again to put it back).';
 const CARD_TOOLS = '^mcp__pendingyou__(post_request|update_request|reply_in_thread|cancel_request)$';
 export const CODEX_HOOKS = [
@@ -161,7 +175,7 @@ async function readHooksFile(io) {
         };
     return { path, json: parsed };
 }
-async function hookTrust(io) {
+async function readHookTrust(io) {
     const file = await readHooksFile(io);
     const config = (await readText(await configPath(io)).catch(() => null)) ?? '';
     const hooks = 'json' in file && file.json.hooks && typeof file.json.hooks === 'object'
@@ -193,6 +207,7 @@ async function hookTrust(io) {
         return { event: spec.event, sub: spec.sub, trust: 'missing' };
     });
 }
+const untrusted = async (io) => (await readHookTrust(io)).filter((hook) => hook.trust === 'untrusted' || hook.trust === 'changed');
 async function signedInByItself(io, program) {
     const result = await io.run(program, ['mcp', 'list', '--json'], 30_000);
     if (result.code !== 0)
@@ -433,7 +448,7 @@ export const codex = {
                         report({
                             ok: true,
                             text: merged.changed
-                                ? `Installed or updated Codex’s session-start pickup, next-message hand-off, card and Stop check hooks${extra ? `, ${cards ? 'its permission-prompt hooks (a card when Codex waits for your OK; --no-permission-cards leaves them out) ' : ''}and its session-end hook (Pending You hears when a thread is open)` : ''} in ${file.path}. Codex asks you to trust them once.`
+                                ? `Installed or updated Codex’s session-start pickup, next-message hand-off, card and Stop check hooks${extra ? `, ${cards ? 'its permission-prompt hooks (a card when Codex waits for your OK; --no-permission-cards leaves them out) ' : ''}and its session-end hook (Pending You hears when a thread is open)` : ''} in ${file.path}. Codex runs them once you trust them (how: below).`
                                 : removed.changed
                                     ? `Took out Codex’s permission-prompt hooks, as you asked: no card when Codex waits for your OK. To turn them on: npx pendingyou init --app codex --permission-cards${originArgs(ictx.origin)}`
                                     : 'Codex’s hooks were already installed.',
@@ -469,14 +484,17 @@ export const codex = {
                 });
                 return steps;
             },
-            next: () => {
+            next: async () => {
                 const login = mode === 'oauth' && action !== 'keep';
                 const first = login ? `run ${shWord(program)} mcp login pendingyou, then ` : '';
-                const start = detected.command
-                    ? `open the Codex app, start a chat in the folder you work in, and trust Pending You’s hooks: click Review hooks › Allow all (or Settings › Hooks › Trust all)`
-                    : `start codex here, or in the folder you work in, and trust Pending You’s hooks: ${TRUST_CLI}; ${TRUST_APP}`;
-                const again = newHooks
-                    ? `Codex has new Pending You hooks (${newHooks}), which it skips until you trust them once: ${detected.command ? TRUST_APP : `${TRUST_CLI}; ${TRUST_APP}`}.`
+                const waiting = (await untrusted(io)).length > 0;
+                const start = waiting
+                    ? 'open Codex as above, type /hooks and trust Pending You’s hooks'
+                    : detected.command
+                        ? 'open the Codex app and start a chat in the folder you work in'
+                        : 'start codex here, or in the folder you work in';
+                const again = newHooks && waiting
+                    ? `Codex has new Pending You hooks (${newHooks}), which it skips until you trust them once.`
                     : null;
                 return {
                     lines: [
@@ -542,7 +560,7 @@ export const codex = {
             codex.detect(io),
             codexServer(io),
             readCodexManifest(io),
-            hookTrust(io),
+            readHookTrust(io),
             readText(codexSkillPath(io)).catch(() => null),
         ]);
         const credential = await readCredential(io, origin, 'codex');
@@ -593,7 +611,7 @@ export const codex = {
         const hooksOk = core.every((hook) => hook.trust === 'trusted');
         const hooksText = core.some((hook) => hook.trust === 'missing')
             ? `not installed; run npx pendingyou init --app codex${flag}`
-            : `${core.map((hook) => `${hook.event} ${words[hook.trust]}`).join(', ')}${hooksOk ? '' : `. Codex skips a hook you haven’t trusted: ${TRUST_CLI}; ${TRUST_APP}`}`;
+            : `${core.map((hook) => `${hook.event} ${words[hook.trust]}`).join(', ')}${hooksOk ? '' : `. Codex skips a hook you haven’t trusted: ${TRUST} them`}`;
         const extraLine = (label, what, subs, off) => {
             const hooks = trust.filter((hook) => subs.includes(hook.sub));
             if (off)
@@ -603,7 +621,7 @@ export const codex = {
             const trusted = hooks.every((hook) => hook.trust === 'trusted');
             return trusted
                 ? `  ok      ${label} ${what} (${hooks.map((hook) => `${hook.event} trusted`).join(', ')})`
-                : `  missing ${label} ${what}, once you trust ${hooks.length === 1 ? 'its hook' : 'its hooks'} (${hooks.map((hook) => `${hook.event} ${words[hook.trust]}`).join(', ')}): ${TRUST_CLI}; ${TRUST_APP}`;
+                : `  missing ${label} ${what}, once you trust ${hooks.length === 1 ? 'its hook' : 'its hooks'} (${hooks.map((hook) => `${hook.event} ${words[hook.trust]}`).join(', ')}): ${TRUST} ${hooks.length === 1 ? 'it' : 'them'}`;
         };
         const ownConnection = credential?.kind === 'connection' && helper;
         const notOwn = 'off: it needs Codex signed in through this computer’s own connection';
@@ -650,4 +668,12 @@ export const codex = {
                 : 'Not ready: Codex here can’t reach Pending You until the lines marked missing are fixed.');
         return { lines, ready };
     },
+    async untrustedHooks(io) {
+        if ((await untrusted(io)).length === 0)
+            return null;
+        return {
+            lines: trustSteps(await findCodex(io)),
+            trusted: async () => (await untrusted(io)).length === 0,
+        };
+    },
 };

package/dist/claude.js

@@ -5,8 +5,9 @@ import { DEFAULT_ORIGIN } from "./args.js";
 import { PlainError } from "./errors.js";
 import { claudeDir, configDir, readJson, readText, writeWhole } from "./files.js";
 import { findHook, hooksOf, mergeHooks, originArgs, removeHooks } from "./hooks.js";
-import { cliPackage, hookForm, hookRuns, shellQuote, } from "./install.js";
-import { atLeast, claudeVersion, isOurModDir, loadsMods, modDir, PLUGIN_DIRS, pluginDirs, pluginEnabled, separatorFor, withModDir, } from "./mod.js";
+import { cliPackage, hookForm, hookRuns, installMod, shellQuote, } from "./install.js";
+import { removeLoadedNotes } from "./loaded.js";
+import { atLeast, claudeVersion, isOurModDir, loadsMods, modDir, PLUGIN_DIRS, pluginDirs, pluginEnabled, separatorFor, stableModDir, withModDir, } from "./mod.js";
 import { removePermissionFiles } from "./permission.js";
 import { removePresenceFiles } from "./presence.js";
 import { helperPath } from "./remote.js";
@@ -396,8 +397,8 @@ async function addMod(io, settings, installed, found) {
     const version = claudeVersion(found);
     if (!version || !loadsMods(version))
         return unchanged;
-    const dir = installed ? modDir(cliPackage(installed.prefix)) : null;
-    if (!dir || !(await exists(join(dir, 'hooks', 'hooks.json'))))
+    const source = installed ? modDir(cliPackage(installed.prefix)) : null;
+    if (!source || !(await exists(join(source, 'hooks', 'hooks.json'))))
         return {
             ...unchanged,
             step: {
@@ -405,18 +406,31 @@ async function addMod(io, settings, installed, found) {
                 text: 'Couldn’t add the wake mod without the hooks’ own copy of pendingyou, so Claude Code hears answers through hold for now. Run init again to retry.',
             },
         };
-    const added = withModDir(settings, dir, separatorFor(io.platform));
+    const dir = stableModDir(io);
+    const separator = separatorFor(io.platform);
+    const added = withModDir(settings, dir, separator);
     if ('invalid' in added)
         return { ...unchanged, step: { ok: false, text: added.invalid } };
+    const copied = await installMod(source, dir).catch(() => null);
+    if (!copied)
+        return {
+            ...unchanged,
+            step: { ok: false, text: `Couldn’t copy the wake mod to ${dir}. Run init again.` },
+        };
+    const moved = (pluginDirs(settings, separator) ?? []).some((entry) => isOurModDir(entry));
     return {
         settings: added.settings,
         changed: added.changed,
         dir,
         step: {
             ok: true,
-            text: added.changed
-                ? `Added the wake mod to ${PLUGIN_DIRS} in ${settingsPath(io)}: Claude Code ${version} wakes a session when you answer, with no hold running.`
-                : 'The wake mod was already in Claude Code’s settings.',
+            text: !added.changed
+                ? copied.changed
+                    ? `Updated the wake mod in ${dir}: open Claude Code sessions reload it by themselves.`
+                    : 'The wake mod was already in Claude Code’s settings.'
+                : moved
+                    ? `Moved the wake mod to ${dir}, a folder that stays put when pendingyou updates, so an update never leaves an open session without it.`
+                    : `Added the wake mod to ${PLUGIN_DIRS} in ${settingsPath(io)}: Claude Code ${version} wakes a session when you answer, with no hold running.`,
         },
     };
 }
@@ -425,7 +439,7 @@ export async function uninstallClaude(io) {
     const steps = [];
     const settings = await readSettings(io);
     const removed = unmergeSettings(settings, manifest?.permissions ?? []);
-    const unmodded = withModDir(removed.settings, null, separatorFor(io.platform));
+    const unmodded = withModDir(removed.settings, null, separatorFor(io.platform), [stableModDir(io)]);
     const modRemoved = !('invalid' in unmodded) && unmodded.changed;
     if (removed.changed || modRemoved)
         await writeSettings(io, 'invalid' in unmodded ? removed.settings : unmodded.settings);
@@ -437,6 +451,8 @@ export async function uninstallClaude(io) {
     });
     if (modRemoved)
         steps.push({ ok: true, text: `Removed the wake mod from ${PLUGIN_DIRS}.` });
+    await rm(stableModDir(io), { recursive: true, force: true }).catch(() => { });
+    await removeLoadedNotes(io);
     await removePermissionFiles(io);
     await removePresenceFiles(io, 'claude-code');
     const skill = await removeSkill(manifest?.skill ?? null);
@@ -484,7 +500,7 @@ export async function claudeState(io) {
     let plugins = [];
     try {
         const settings = await readSettings(io);
-        mod.dirs = (pluginDirs(settings, separatorFor(io.platform)) ?? []).filter(isOurModDir);
+        mod.dirs = (pluginDirs(settings, separatorFor(io.platform)) ?? []).filter((entry) => isOurModDir(entry, [stableModDir(io)]));
         mod.plugin = pluginEnabled(settings);
         plugins = enabledPlugins(settings);
         const all = objectAt(settings, 'hooks') ?? {};

package/dist/herdr/queue.js

@@ -201,6 +201,7 @@ export async function queuePopup(io, place, options) {
             ended = true;
         state = { ...state, note: failureWords(error) };
     };
+    const telling = new Set();
     const here = async () => {
         await markActive(place, io.now());
         if (!client || ended || !scopes.has('presence:desk'))
@@ -466,7 +467,9 @@ export async function queuePopup(io, place, options) {
             if (next.done)
                 return 0;
             pending = keys.next();
-            void here();
+            const told = here();
+            telling.add(told);
+            void told.finally(() => telling.delete(told)).catch(() => { });
             for (const key of options.splitKeys(next.value)) {
                 const [after, effect] = queueKey(state, key, io.now());
                 state = after;
@@ -482,6 +485,7 @@ export async function queuePopup(io, place, options) {
         stop();
         await keys.return?.();
         await feed.catch(() => { });
+        await Promise.allSettled(telling);
         io.signal.removeEventListener('abort', stop);
         io.out('\x1b[?25h');
     }

package/dist/init.js

@@ -10,6 +10,7 @@ import { headlessReason, helperCommand, removeHelper, writeHelper } from "./remo
 import { FINISH_SAY } from "./setup.js";
 import { removeShim, shimPath, writeShim } from "./shim.js";
 import { checkSignIn, logout, signInApps, titleFrom, titleHere } from "./signin.js";
+import { trustHooks } from "./trust.js";
 import { VERSION } from "./version.js";
 const line = (step) => `  ${step.ok ? 'ok     ' : 'check  '} ${step.text}\n`;
 async function findApps(io, wanted) {
@@ -175,7 +176,7 @@ export async function init(io, options) {
     const helped = setUp.some((each) => each.signIn === 'connection' && !each.bridged);
     const bridged = setUp.some((each) => each.bridged);
     const shared = await installShared(io, helped, bridged, report);
-    const nexts = [];
+    const installed = [];
     for (const each of setUp) {
         if (setUp.length > 1)
             io.out(`${each.app.name}:\n`);
@@ -191,14 +192,19 @@ export async function init(io, options) {
             bridge: shared.bridge && each.bridged ? bridgeCommand(io, options.origin, each.app.id) : null,
             signedIn: how === 'signed-in' || how === 'already',
         };
-        const done = await each.install(ictx);
-        const next = each.next(ictx, done);
-        if (next)
-            nexts.push(next);
+        installed.push({ each, ictx, done: await each.install(ictx) });
     }
     const others = await Promise.all(APPS.filter((app) => !setUp.some((each) => each.app.id === app.id)).map((app) => app.installed(io)));
     if (!io.env.PENDINGYOU_SELF && !others.some(Boolean))
         await pruneCli(io, shared.copy?.version ?? null);
+    for (const { each } of installed)
+        await trustHooks(io, each.app, options.origin);
+    const nexts = [];
+    for (const { each, ictx, done } of installed) {
+        const next = await each.next(ictx, done);
+        if (next)
+            nexts.push(next);
+    }
     const last = closing(nexts);
     if (last.length)
         io.out(`${last.join('\n')}\n`);
@@ -223,16 +229,21 @@ async function coveredApps(io, wanted) {
 }
 export async function status(io, options) {
     const apps = await coveredApps(io, options.apps);
-    let ready = true;
+    const ready = [];
     const sections = [];
     for (const app of apps) {
         const signIn = await checkSignIn(io, options.origin, app.id);
         const section = await app.status(io, { origin: options.origin, signIn });
-        ready &&= section.ready;
+        ready.push(section.ready);
         sections.push(section.lines.join('\n'));
     }
     io.out(`${sections.join('\n\n')}\n`);
-    return ready ? 0 : 1;
+    for (const [at, app] of apps.entries()) {
+        const after = await trustHooks(io, app, options.origin);
+        if (after)
+            ready[at] = after.ready;
+    }
+    return ready.every(Boolean) ? 0 : 1;
 }
 export async function uninstall(io, options) {
     const installed = [];

package/dist/install.js

@@ -1,7 +1,7 @@
 import { randomBytes } from 'node:crypto';
-import { cp, mkdir, readdir, realpath, rename, rm, stat } from 'node:fs/promises';
-import { basename, dirname, isAbsolute, join } from 'node:path';
-import { configDir, readJson } from "./files.js";
+import { cp, mkdir, readdir, readFile, realpath, rename, rm, stat } from 'node:fs/promises';
+import { basename, dirname, isAbsolute, join, relative } from 'node:path';
+import { configDir, readJson, readText, writeWhole } from "./files.js";
 import { VERSION } from "./version.js";
 export const cliRoot = (io) => join(configDir(io), 'cli');
 export const cliPrefix = (io, version = VERSION) => join(cliRoot(io), version);
@@ -97,13 +97,59 @@ export async function installCli(io, progress) {
         await rm(staging, { recursive: true, force: true }).catch(() => { });
     }
 }
+function byVersion(a, b) {
+    const parts = (version) => version.split('.').map((part) => Number.parseInt(part, 10));
+    const [left, right] = [parts(a), parts(b)];
+    for (let index = 0; index < Math.max(left.length, right.length); index++) {
+        const difference = (left[index] ?? 0) - (right[index] ?? 0);
+        if (difference)
+            return difference;
+    }
+    return 0;
+}
+const VERSION_NAME = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/;
 export async function pruneCli(io, keep) {
     const root = cliRoot(io);
     const entries = await readdir(root).catch(() => []);
+    const previous = entries
+        .filter((entry) => entry !== keep && VERSION_NAME.test(entry))
+        .sort(byVersion)
+        .at(-1);
     for (const entry of entries)
-        if (entry !== keep)
+        if (entry !== keep && entry !== previous)
             await rm(join(root, entry), { recursive: true, force: true }).catch(() => { });
 }
+async function filesUnder(root, at = root) {
+    const found = [];
+    for (const entry of await readdir(at, { withFileTypes: true })) {
+        const path = join(at, entry.name);
+        if (entry.isDirectory()) {
+            if (at === root && entry.name === 'tests')
+                continue;
+            found.push(...(await filesUnder(root, path)));
+        }
+        else if (entry.isFile())
+            found.push(relative(root, path));
+    }
+    return found;
+}
+const MOD_ORDER = ['hooks/wake.js', 'hooks/register.js', 'hooks/hooks.json'];
+const modRank = (path) => {
+    const at = MOD_ORDER.indexOf(path.replaceAll('\\', '/'));
+    return at === -1 ? MOD_ORDER.length : at;
+};
+export async function installMod(from, to) {
+    const files = (await filesUnder(from)).sort((a, b) => modRank(a) - modRank(b));
+    let changed = false;
+    for (const file of files) {
+        const text = await readFile(join(from, file), 'utf8');
+        if ((await readText(join(to, file)).catch(() => null)) === text)
+            continue;
+        await writeWhole(join(to, file), text, { mode: 0o644 });
+        changed = true;
+    }
+    return { changed };
+}
 export async function removeCli(io) {
     const root = cliRoot(io);
     if (!(await exists(root)))

package/dist/loaded.js

@@ -0,0 +1,88 @@
+import { readdir, rm, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { configDir, readJson } from "./files.js";
+import { holdCommand } from "./hold.js";
+import { readSaid } from "./presence.js";
+import { claimUnwoken } from "./state.js";
+const SESSION = /^[A-Za-z0-9][A-Za-z0-9_-]{0,99}$/;
+export const LOADED_GRACE_MS = 15_000;
+export const OPEN_FOR_MS = 12 * 60 * 60_000;
+const KEEP_NOTES_MS = 7 * 24 * 60 * 60_000;
+const notesDir = (io) => join(configDir(io), 'wake', 'sessions');
+export const loadedPath = (io, session) => join(notesDir(io), `${session}.json`);
+export function unwokenText(origin) {
+    return `Pending You can’t wake this session: Claude Code started before Pending You’s wake was set up. Ask your person to restart it (/exit, then claude --continue) at a good moment. Until then, after each card, run \`${holdCommand('<requestId>', origin)}\` in the background.`;
+}
+export async function modConfigured(io) {
+    const manifest = await readJson(join(configDir(io), 'claude-code.json')).catch(() => null);
+    return typeof manifest?.modDir === 'string' && manifest.modDir !== '';
+}
+export async function modLoaded(io, session, said) {
+    if (said?.mod)
+        return true;
+    if (!SESSION.test(session))
+        return false;
+    return stat(loadedPath(io, session)).then(() => true, () => false);
+}
+export async function unwokenLine(io, origin, session, said) {
+    try {
+        if (!session || !SESSION.test(session))
+            return null;
+        if (!(await modConfigured(io)))
+            return null;
+        const latest = (await readSaid(io, 'claude-code').catch(() => ({})))[session];
+        if ((await modLoaded(io, session, said)) || latest?.mod)
+            return null;
+        if (said?.since !== undefined && io.now() - said.since < LOADED_GRACE_MS)
+            return null;
+        if (!(await claimUnwoken(io, session)))
+            return null;
+        return unwokenText(origin);
+    }
+    catch {
+        return null;
+    }
+}
+export async function unwokenSessions(io) {
+    const said = await readSaid(io, 'claude-code').catch(() => ({}));
+    const found = [];
+    for (const [session, each] of Object.entries(said)) {
+        if (each.state !== 'live' || io.now() - each.at > OPEN_FOR_MS)
+            continue;
+        if (await modLoaded(io, session, each))
+            continue;
+        found.push({
+            session,
+            at: each.at,
+            ...(each.cwd ? { cwd: each.cwd } : {}),
+            ...(each.name ? { name: each.name } : {}),
+        });
+    }
+    return found.sort((a, b) => b.at - a.at).map(({ at: _, ...rest }) => rest);
+}
+const named = (each) => `${each.name ? `“${each.name}”` : 'a session'}${each.cwd ? ` in ${each.cwd}` : ''}`;
+const NAMED = 4;
+export function unwokenLines(sessions) {
+    if (sessions.length === 0)
+        return [];
+    const shown = sessions.slice(0, NAMED).map(named);
+    const more = sessions.length - shown.length;
+    const list = `${shown.join('; ')}${more ? `; and ${more} more` : ''}`;
+    return [
+        sessions.length === 1
+            ? `Pending You can’t wake the Claude Code session open here (${list}): it started before Pending You’s wake was set up. Restart it at a good moment: /exit, then claude --continue.`
+            : `Pending You can’t wake ${sessions.length} Claude Code sessions open here (${list}): they started before Pending You’s wake was set up. Restart each at a good moment: /exit, then claude --continue.`,
+    ];
+}
+export async function pruneLoadedNotes(io) {
+    const dir = notesDir(io);
+    for (const name of await readdir(dir).catch(() => [])) {
+        const path = join(dir, name);
+        const info = await stat(path).catch(() => null);
+        if (info && io.now() - info.mtimeMs > KEEP_NOTES_MS)
+            await rm(path, { force: true }).catch(() => { });
+    }
+}
+export async function removeLoadedNotes(io) {
+    await rm(join(configDir(io), 'wake'), { recursive: true, force: true }).catch(() => { });
+}

package/dist/mod.js

@@ -1,8 +1,10 @@
 import { join } from 'node:path';
+import { configDir } from "./files.js";
 export const MOD_CLAUDE = '2.1.287';
 export const PLUGIN_DIRS = 'CLAUDE_CODE_PLUGIN_DIRS';
 export const PLUGINS_WITH_MOD = ['pending-you@pendingyou', 'pending-you-staging@pendingyou-staging'];
 export const modDir = (packageRoot) => join(packageRoot, 'mod');
+export const stableModDir = (io) => join(configDir(io), 'mod');
 export function claudeVersion(output) {
     return /^\s*(\d+\.\d+\.\d+)\b/.exec(output)?.[1] ?? null;
 }
@@ -18,7 +20,9 @@ export function atLeast(version, least) {
     return true;
 }
 export const loadsMods = (version) => atLeast(version, MOD_CLAUDE);
-export const isOurModDir = (entry) => /(^|[\\/])node_modules[\\/]pendingyou[\\/]mod[\\/]?$/.test(entry.trim());
+const bare = (path) => path.trim().replace(/[\\/]+$/, '');
+export const isOurModDir = (entry, also = []) => /(^|[\\/])node_modules[\\/]pendingyou[\\/]mod[\\/]?$/.test(entry.trim()) ||
+    also.some((dir) => bare(dir) === bare(entry));
 export const separatorFor = (platform) => (platform === 'win32' ? ';' : ':');
 const objectAt = (parent, key) => {
     const value = parent[key];
@@ -37,7 +41,7 @@ export function pluginDirs(settings, separator) {
         return null;
     return value.split(separator).filter((entry) => entry.trim() !== '');
 }
-export function withModDir(settings, dir, separator) {
+export function withModDir(settings, dir, separator, also = []) {
     const entries = pluginDirs(settings, separator);
     if (entries === null)
         return {
@@ -45,7 +49,8 @@ export function withModDir(settings, dir, separator) {
         };
     if (dir?.includes(separator))
         return { invalid: `The wake mod’s folder has a “${separator}” in its path: ${dir}` };
-    const wanted = [...entries.filter((entry) => !isOurModDir(entry)), ...(dir ? [dir] : [])];
+    const ours = dir ? [...also, dir] : also;
+    const wanted = [...entries.filter((entry) => !isOurModDir(entry, ours)), ...(dir ? [dir] : [])];
     if (wanted.join(separator) === entries.join(separator))
         return { settings, changed: false };
     const next = structuredClone(settings);

package/dist/pickup.js

@@ -8,8 +8,9 @@ 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 { unwokenLine } from "./loaded.js";
 import { isPermissionCard, isPromptApp, sessionName, settlePrompts } from "./permission.js";
-import { announce, keepPresent } from "./presence.js";
+import { announce, keepPresent, readSaid } from "./presence.js";
 import { setupReminder } from "./setup.js";
 import { claimHanded, markHanded, momentOf, releaseHanded, wasHanded } from "./state.js";
 const TIME_BOX_MS = { pickup: 2500, handoff: 2000 };
@@ -115,11 +116,15 @@ export async function pickup(io, options, hook = { fallback: '' }) {
     let line = null;
     let warning = null;
     let reminder = null;
+    let unwoken = null;
     try {
         const input = await hookInput(io);
         const { cwd } = input;
         if (mode === 'handoff' && isPromptApp(app))
             await settlePrompts(io, { session: input.session, event: 'prompt' });
+        const known = mode === 'handoff' && app === DEFAULT_APP && input.session
+            ? (await readSaid(io, app).catch(() => ({})))[input.session]
+            : undefined;
         if (app === 'codex')
             await keepPresent(io, origin, input.session, input.given ? cwd : null);
         else if (app === DEFAULT_APP && (mode === 'pickup' || input.session))
@@ -144,6 +149,8 @@ export async function pickup(io, options, hook = { fallback: '' }) {
                 return 0;
             line = REMINDER;
             hook.fallback = `${[REMINDER, warning].filter(Boolean).join('\n')}\n`;
+            if (app === DEFAULT_APP)
+                unwoken = await unwokenLine(io, origin, input.session, known);
         }
         if (app !== DEFAULT_APP && input.session) {
             await touchThread(io, app, input.session, input.given ? input.cwd : null);
@@ -152,11 +159,16 @@ export async function pickup(io, options, hook = { fallback: '' }) {
         }
         if (app === 'codex' && input.session)
             await keepListening(io, origin, input.session);
+        const claudeNames = app === DEFAULT_APP
+            ? sessionName(input.transcript ?? undefined).then((name) => (name ? [name] : []))
+            : null;
+        const named = claudeNames ? (await claudeNames)[0] : undefined;
         const query = new URLSearchParams([
             ...folderForms(cwd, io.home).map((form) => ['cwd', form]),
             ['limit', String(ANSWERS_ASKED)],
             ...(mode === 'handoff' ? [['open', String(OPEN_SHOWN)]] : []),
             ['source', app],
+            ...(named ? [['name', named]] : []),
         ]);
         const { status, body } = await getJson(io, origin, `/mcp/cli/answers?${query}`, TIME_BOX_MS[mode], io.signal, {
             hook: true,
@@ -190,10 +202,7 @@ export async function pickup(io, options, hook = { fallback: '' }) {
                 return computers !== null && namesAnotherComputer(heard.machine, computers);
             },
             names: () => {
-                names ??=
-                    app === DEFAULT_APP
-                        ? sessionName(input.transcript ?? undefined).then((name) => (name ? [name] : []))
-                        : threadNames(io, app, input.session);
+                names ??= claudeNames ?? threadNames(io, app, input.session);
                 return names;
             },
         };
@@ -241,10 +250,12 @@ export async function pickup(io, options, hook = { fallback: '' }) {
             ...(line ? [line] : []),
             ...(warning ? [warning] : []),
             ...(reminder ? [reminder] : []),
+            ...(unwoken ? [unwoken] : []),
         ].join('\n')}\n`);
         line = null;
         warning = null;
         reminder = null;
+        unwoken = null;
         await markHanded(io, origin, fresh.map((heard) => ({ requestId: heard.requestId, moment: momentOf(heard) })));
         return 0;
     }
@@ -256,7 +267,7 @@ export async function pickup(io, options, hook = { fallback: '' }) {
         return 0;
     }
     finally {
-        const last = [line, warning, reminder].filter(Boolean);
+        const last = [line, warning, reminder, unwoken].filter(Boolean);
         if (last.length)
             io.out(`${last.join('\n')}\n`);
     }

package/dist/presence.js

@@ -100,15 +100,28 @@ export async function sendPresence(io, origin, presence, timeoutMs = SEND_MS, op
 }
 const recordPath = (io, app) => join(configDir(io), 'presence', `${app}.json`);
 const leasePath = (io, app, session) => join(configDir(io), 'presence', `${app}-${session}.lease`);
-async function readSaid(io, app) {
+const numberOr = (value) => (typeof value === 'number' ? value : undefined);
+export async function readSaid(io, app) {
     const file = await readJson(recordPath(io, app)).catch(() => null);
     const sessions = {};
     if (isObject(file?.sessions))
         for (const [id, value] of Object.entries(file.sessions))
             if (isObject(value) &&
                 (value.state === 'live' || value.state === 'closed') &&
-                typeof value.at === 'number')
-                sessions[id] = { state: value.state, at: value.at };
+                typeof value.at === 'number') {
+                const since = numberOr(value.since);
+                const mod = numberOr(value.mod);
+                const cwd = text(value.cwd);
+                const name = text(value.name);
+                sessions[id] = {
+                    state: value.state,
+                    at: value.at,
+                    ...(since !== undefined ? { since } : {}),
+                    ...(mod !== undefined ? { mod } : {}),
+                    ...(cwd ? { cwd } : {}),
+                    ...(name ? { name } : {}),
+                };
+            }
     return sessions;
 }
 async function noteSaid(io, app, session, said) {
@@ -118,7 +131,14 @@ async function noteSaid(io, app, session, said) {
         const before = sessions[session] ?? null;
         if (before && before.at > said.at)
             return { newer: true, before };
-        sessions[session] = said;
+        sessions[session] = {
+            ...before,
+            ...said,
+            since: before ? Math.min(before.since ?? 0, said.at) : said.at,
+            ...(said.mod !== undefined || before?.mod !== undefined
+                ? { mod: Math.max(said.mod ?? 0, before?.mod ?? 0) }
+                : {}),
+        };
         const now = io.now();
         for (const [id, each] of Object.entries(sessions))
             if (now - each.at > FORGET_MS)
@@ -131,7 +151,16 @@ async function noteSaid(io, app, session, said) {
 }
 async function sendOnce(io, command) {
     const at = command.at ?? io.now();
-    const noted = await noteSaid(io, command.app, command.session, { state: command.state, at });
+    const cwd = presenceCwd(command.cwd, io.home);
+    const name = await nameFor(io, command);
+    const mod = command.app === 'claude-code' && command.state === 'live' && !command.transcript;
+    const noted = await noteSaid(io, command.app, command.session, {
+        state: command.state,
+        at,
+        ...(mod ? { mod: at } : {}),
+        ...(cwd ? { cwd } : {}),
+        ...(name ? { name } : {}),
+    });
     if (noted.newer)
         return null;
     if (command.state === 'live' &&
@@ -142,8 +171,8 @@ async function sendOnce(io, command) {
         app: command.app,
         session: command.session,
         state: command.state,
-        cwd: presenceCwd(command.cwd, io.home),
-        name: await nameFor(io, command),
+        cwd,
+        name,
     }, SEND_MS, { patient: true });
 }
 const GIVE_UP = new Set(['refused', 'absent', 'skipped']);

package/dist/state.js

@@ -1,6 +1,7 @@
 import { join } from 'node:path';
 import { configDir, readJson, withLock, writeWhole } from "./files.js";
 const KEEP_HANDED = 300;
+const KEEP_UNWOKEN = 100;
 const statePath = (io) => join(configDir(io), 'state.json');
 const key = (origin, requestId) => `${origin} ${requestId}`;
 export const momentOf = (heard) => `${heard.version}:${heard.messages.at(-1)?.id ?? ''}`;
@@ -10,6 +11,7 @@ async function load(io) {
         version: 1,
         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 } : {}),
     };
 }
 async function change(io, edit) {
@@ -20,6 +22,9 @@ async function change(io, edit) {
         const handed = Object.entries(state.handed);
         if (handed.length > KEEP_HANDED)
             state.handed = Object.fromEntries(handed.slice(-KEEP_HANDED));
+        const unwoken = Object.entries(state.unwoken ?? {});
+        if (unwoken.length > KEEP_UNWOKEN)
+            state.unwoken = Object.fromEntries(unwoken.slice(-KEEP_UNWOKEN));
         await writeWhole(path, `${JSON.stringify(state, null, 2)}\n`, { secret: true });
     });
 }
@@ -70,3 +75,13 @@ export function markReminded(io, origin, app, since) {
         state.reminded = { ...state.reminded, [name]: { since, times, at: io.now() } };
     });
 }
+export async function claimUnwoken(io, session) {
+    let claimed = false;
+    await change(io, (state) => {
+        if (state.unwoken?.[session] !== undefined)
+            return;
+        state.unwoken = { ...state.unwoken, [session]: io.now() };
+        claimed = true;
+    });
+    return claimed;
+}

package/dist/trust.js

@@ -0,0 +1,37 @@
+import { originArgs } from "./hooks.js";
+import { checkSignIn } from "./signin.js";
+export const TRUST_EVERY_MS = 3000;
+export const TRUST_FOR_MS = 10 * 60_000;
+export async function waitForTrust(io, trusted) {
+    const until = io.now() + TRUST_FOR_MS;
+    while (io.now() < until) {
+        if (io.signal.aborted)
+            return 'stopped';
+        await io.sleep(TRUST_EVERY_MS, io.signal);
+        if (io.signal.aborted)
+            return 'stopped';
+        if (await trusted())
+            return 'trusted';
+    }
+    return 'timed-out';
+}
+export async function trustHooks(io, app, origin) {
+    const pending = await app.untrustedHooks?.(io);
+    if (!pending)
+        return null;
+    const later = `npx pendingyou status${originArgs(origin)}`;
+    io.out(`\n${pending.lines.join('\n')}\n`);
+    if (!io.interactive) {
+        io.out(`Once you have, run ${later} to check.\n`);
+        return null;
+    }
+    io.out(`Waiting for you to trust the hooks… (Ctrl-C to stop; run ${later} later)\n`);
+    const outcome = await waitForTrust(io, pending.trusted);
+    if (outcome !== 'trusted') {
+        io.out(`${outcome === 'stopped' ? 'Stopped waiting.' : 'Stopped waiting after 10 minutes.'} Once you’ve trusted them, run ${later}.\n`);
+        return null;
+    }
+    const section = await app.status(io, { origin, signIn: await checkSignIn(io, origin, app.id) });
+    io.out(`${section.lines.at(-1)}\n`);
+    return section;
+}

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.21.0';
+export const VERSION = '0.23.0';

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

@@ -1,7 +1,7 @@
 {
   "name": "pendingyou-wake",
   "displayName": "Pending You",
-  "version": "2.34.0",
+  "version": "2.34.2",
   "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

@@ -1,7 +1,7 @@
 # Pending You wake mod
 
-The pendingyou command line’s copy of the Pending You plugin’s wake mod, for Claude Code 2.1.287 and later. `npx pendingyou init` adds this folder to `CLAUDE_CODE_PLUGIN_DIRS` in `~/.claude/settings.json`, so every Claude Code session loads it; `npx pendingyou uninstall` takes it out.
+The pendingyou command line’s copy of the Pending You plugin’s wake mod, for Claude Code 2.1.287 and later. `npx pendingyou init` copies it to `~/.config/pendingyou/mod`, a folder that stays put when pendingyou updates, and adds that folder to `CLAUDE_CODE_PLUGIN_DIRS` in `~/.claude/settings.json`, so every Claude Code session started after loads it (one already open needs a restart: /exit, then claude --continue); `npx pendingyou uninstall` takes it out.
 
 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.34.0; send changes there.
+Generated from recordplane/pendingyou (packages/claude-plugin/src/wake) with Pending You’s guide 2.34.2; send changes there.

package/mod/hooks/register.js

@@ -1,7 +1,7 @@
 // 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, isRefusal, isStale, isWaitingOnYou, KEEP_MS, learn, leaseHolder, 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, 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, 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";
 const RETRY_MS = 60_000;
 const live = {
     me: '',
@@ -85,7 +85,7 @@ async function startHerdr($) {
     live.herdrTimer = null;
     live.herdr = null;
     live.herdrSaid = undefined;
-    const config = cliConfigOf($.plugin.root);
+    const config = cliConfigOf($.plugin.root, $.plugin.name);
     if (!config)
         return;
     const herdr = inHerdr(await $.env.get('HERDR_ENV'), await $.env.get('HERDR_BIN_PATH'), await $.env.get('HERDR_PANE_ID'));
@@ -319,6 +319,15 @@ async function folderOfSession($, cwd) {
         live.home = undefined;
     }
 }
+async function noteLoaded($) {
+    try {
+        const config = cliConfigOf($.plugin.root, $.plugin.name);
+        const path = config && live.sessionId ? loadedPath(config, live.sessionId) : null;
+        if (path)
+            await $.fs.write(path, loadedNote(await $.clock.now()));
+    }
+    catch { }
+}
 async function sayLive($) {
     try {
         const presence = live.presence;
@@ -338,7 +347,7 @@ async function startPresence($) {
     live.presenceTimer?.cancel();
     live.presenceTimer = null;
     live.presence = null;
-    const config = cliConfigOf($.plugin.root);
+    const config = cliConfigOf($.plugin.root, $.plugin.name);
     if (!config)
         return;
     let manifest = null;
@@ -359,6 +368,7 @@ async function start($, e) {
     live.book = readBook(await $.store.get(keyOf(live.sessionId)));
     freshHanded();
     await folderOfSession($, e.cwd);
+    await noteLoaded($);
     await claim($);
     live.timer?.cancel();
     live.timer = $.clock.every(TICK_MS, () => tick($));
@@ -377,6 +387,7 @@ async function switchSession($, e) {
     live.book = carried ?? readBook(await $.store.get(keyOf(id)));
     live.noted.clear();
     freshHanded();
+    await noteLoaded($);
     if (typeof e.cwd === 'string' && e.cwd)
         await folderOfSession($, e.cwd);
     if (carried)

package/mod/hooks/wake.js

@@ -616,7 +616,15 @@ export function handedOf(output) {
         const updatedAt = text(request.updatedAt, 40);
         const cwd = text(request.cwd, 1000);
         return requestId && title && updatedAt
-            ? [{ requestId, title, updatedAt, ...(cwd ? { cwd } : {}) }]
+            ? [
+                {
+                    requestId,
+                    title,
+                    updatedAt,
+                    ...(cwd ? { cwd } : {}),
+                    ...(request.byName === true ? { byName: true } : {}),
+                },
+            ]
             : [];
     });
 }
@@ -641,7 +649,7 @@ export function inTaskFolder(folders, task, home) {
     });
 }
 export function takesHanded(handed, folders, home, now) {
-    if (!handed.cwd)
+    if (handed.byName || !handed.cwd)
         return true;
     if (folders.length === 0)
         return now - Date.parse(handed.updatedAt) >= HANDED_GRACE_MS;
@@ -760,10 +768,18 @@ export function setupPrompt(connection = 'Claude Code') {
 export const PRESENCE_EVERY_MS = 5 * 60_000;
 export const PRESENCE_RUN_MS = 15_000;
 const PRODUCTION = 'https://www.pendingyou.com';
-export function cliConfigOf(root) {
+export function cliConfigOf(root, name = CLI_COPY) {
+    if (name !== CLI_COPY)
+        return null;
     return (/^(.+)[\\/]cli[\\/][^\\/]+[\\/]node_modules[\\/]pendingyou[\\/]mod[\\/]?$/.exec(root)?.[1] ??
+        /^(.+)[\\/]mod[\\/]?$/.exec(root)?.[1] ??
         null);
 }
+const SESSION_FILE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,99}$/;
+export function loadedPath(config, sessionId) {
+    return SESSION_FILE.test(sessionId) ? `${config}/wake/sessions/${sessionId}.json` : null;
+}
+export const loadedNote = (at) => `${JSON.stringify({ at: Math.floor(at) })}\n`;
 export function originOf(manifest) {
     let parsed = manifest;
     if (typeof manifest === 'string')

package/package.json

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