pendingyou 0.22.0 → 0.25.0

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # Changelog
 
+## 0.25.0 (2026-10-06)
+
+- An answer reaches only the session that asked. The hooks asked Pending You for their folder's answers and open
+  cards, and got every card asked from that folder, or from any folder above it, whoever asked: two sessions in one
+  folder each heard the other's answers and were told to ack them, the next-message line listed the other's cards as
+  "Your open cards here", and a card asked from a folder above another session's reached it on any computer. Now each
+  hook says who its session is: the cards it posted (Claude Code's from its own transcript, with whether that's all of
+  them; Codex's, OpenCode's and Pi's from what their hooks remember), the name it goes by, and this computer's names.
+  Pending You hands it a card it posted (whatever name it asked under, the app's own included), else one asked under
+  its name; only a session that can say neither falls back to its folder, that exact folder on this computer, and
+  never for a card asked under another agent's name. The Stop check's look at open cards asks the same way. Needs
+  Pending You's matching release; until then the hooks hear as before.
+
+## 0.24.0 (2026-10-06)
+
+- When your person approves a card that carried a draft, or picks a reply option that sends (`sends`), the hold, the
+  hooks' hand-off and the wake mods (Claude Code's and Codex's) add one line: “The approved words are in
+  get_request’s answer.approvedDrafts: send them exactly.” Pending You's `get_request` now gives those exact words with
+  the answer (and every answer the card's title), so an agent that starts fresh, or a smaller model, sends what was
+  approved instead of hunting for it or rewriting it. Needs Pending You's matching release; with an older one nothing
+  changes.
+
+## 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

package/README.md

@@ -354,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-wake.js

@@ -5,7 +5,7 @@ import { getJson, SignInNeeded, Unavailable } from "../api.js";
 import { DEFAULT_ORIGIN } from "../args.js";
 import { connectionMachine, readCredential } from "../credentials.js";
 import { configDir, readJson, withLock, writeWhole } from "../files.js";
-import { clip, delegatedOf, handledOf, isClosed, noticeOf } from "../format.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 { macName, tailscaleName } from "../remote.js";
@@ -280,6 +280,12 @@ export async function threadNames(io, app, thread) {
         return [];
     return (await load(io, app).catch(() => null))?.threads[thread]?.names ?? [];
 }
+export async function threadCards(io, app, thread) {
+    if (!thread)
+        return [];
+    const cards = (await load(io, app).catch(() => null))?.threads[thread]?.cards ?? {};
+    return Object.keys(cards).filter((id) => REQUEST_ID.test(id));
+}
 export async function markHandedTurn(io, turn, app) {
     const now = io.now();
     await change(io, app, (state) => {
@@ -411,7 +417,7 @@ function line(heard, card) {
                 ];
             return [
                 `your person answered ${titled}`,
-                `call ${get}, act on their words, then ack_answer with its version and a one-line outcome`,
+                `call ${get}, act on their words, then ack_answer with its version and a one-line outcome${approvesDraft(heard) ? `. ${APPROVED_DRAFT_NOTICE.slice(0, -1)}` : ''}`,
             ];
         default:
             return [

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

@@ -12,6 +12,8 @@ export function handledOf(heard) {
     return given === 'self' || given === 'leave' ? given : null;
 }
 const HANDLED_SAID = { self: 'I’ll do it myself', leave: 'Leave it' };
+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';
 export const HANDED_REPLY = 'on the question handed to you';
 export const HANDED_TALK_TODO = 'If you know now, answer_delegated with your answer and how you know; if you need more, reply_in_thread to “asker”; if it’s your person’s to decide, reply_in_thread with escalate true; if not, hand_back with what you checked.';
@@ -170,6 +172,8 @@ export function describe(heard, again) {
             }
             if (wrote.length)
                 lines.push(`${noticeOf(heard) ? 'Also' : 'They also wrote'}: ${wrote.join(' ')}`);
+            if (approvesDraft(heard))
+                lines.push(APPROVED_DRAFT_NOTICE);
             lines.push(`Act on it, then call ack_answer with requestId ${id}, name ${named(heard)}, expectedVersion ${heard.version} and a one-line outcome.`);
             break;
         }

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

@@ -526,6 +526,95 @@ export async function sessionName(path) {
         await file.close().catch(() => { });
     }
 }
+const POST_TOOL = /^mcp__.*pendingyou.*__post_request$/i;
+const POSTED_ID = /"requestId"\s*:\s*"(req_[A-Za-z0-9-]{1,40})"/;
+export const POSTED_MAX = 50;
+function resultText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content.map((block) => (isObject(block) ? text(block.text) : '')).join('\n');
+}
+export async function sessionPosted(path) {
+    if (!path)
+        return null;
+    let file;
+    try {
+        file = await open(path, 'r');
+    }
+    catch (error) {
+        return error?.code === 'ENOENT' ? { posted: [], whole: true } : null;
+    }
+    try {
+        const size = (await file.stat()).size;
+        let position = size;
+        let carry = Buffer.alloc(0);
+        const results = new Map();
+        const posted = [];
+        let more = false;
+        const read = (line) => {
+            const asResult = line.includes('tool_result') && line.includes('req_');
+            const asCall = line.includes('post_request');
+            if (!asResult && !asCall)
+                return;
+            let entry;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                return;
+            }
+            if (!isObject(entry) || entry.isSidechain === true)
+                return;
+            const message = isObject(entry.message) ? entry.message : {};
+            const blocks = Array.isArray(message.content) ? message.content : [];
+            for (const block of [...blocks].reverse()) {
+                if (!isObject(block))
+                    continue;
+                if (entry.type === 'user' && block.type === 'tool_result' && block.is_error !== true) {
+                    const id = POSTED_ID.exec(resultText(block.content))?.[1];
+                    if (id && text(block.tool_use_id))
+                        results.set(text(block.tool_use_id), id);
+                }
+                else if (entry.type === 'assistant' &&
+                    block.type === 'tool_use' &&
+                    POST_TOOL.test(text(block.name))) {
+                    const id = results.get(text(block.id));
+                    if (!id || posted.includes(id))
+                        continue;
+                    if (posted.length < POSTED_MAX)
+                        posted.push(id);
+                    else
+                        more = true;
+                }
+            }
+        };
+        while (position > 0 && size - position < TRANSCRIPT_CAP) {
+            const length = Math.min(64 * 1024, position);
+            position -= length;
+            const chunk = Buffer.alloc(length);
+            await file.read(chunk, 0, length, position);
+            let buffer = Buffer.concat([chunk, carry]);
+            let newline = buffer.lastIndexOf(10);
+            while (newline !== -1) {
+                read(buffer.subarray(newline + 1).toString('utf8'));
+                buffer = buffer.subarray(0, newline);
+                newline = buffer.lastIndexOf(10);
+            }
+            carry = buffer;
+        }
+        if (position === 0)
+            read(carry.toString('utf8'));
+        return { posted, whole: position === 0 && !more };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await file.close().catch(() => { });
+    }
+}
 export function remoteOf(url) {
     const plain = url
         .trim()

package/dist/pickup.js

@@ -1,15 +1,16 @@
 import { getJson, SignInNeeded } from "./api.js";
-import { computerNames, hearsOnly, keepListening, markHandedTurn, sessionFor, threadNames, touchThread, } from "./apps/codex-wake.js";
+import { computerNames, hearsOnly, keepListening, markHandedTurn, sessionFor, threadCards, threadNames, touchThread, } from "./apps/codex-wake.js";
 import { APP_NAMES, DEFAULT_APP } from "./apps/ids.js";
-import { readCredential } from "./credentials.js";
+import { connectionMachine, readCredential } from "./credentials.js";
 import { environmentWarning } from "./environment.js";
 import { configDir, readJson } from "./files.js";
 import { clip, delegatedOf, describe, HANDED_PREFIX, isHandedWake, } from "./format.js";
 import { goesBy, HANDED_GRACE_MS, namesAnotherComputer } from "./handed.js";
 import { herdrTarget, reportCommand } from "./herdr.js";
 import { holdCommand } from "./hold.js";
-import { isPermissionCard, isPromptApp, sessionName, settlePrompts } from "./permission.js";
-import { announce, keepPresent } from "./presence.js";
+import { unwokenLine } from "./loaded.js";
+import { isPermissionCard, isPromptApp, POSTED_MAX, sessionName, sessionPosted, settlePrompts, } from "./permission.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 };
@@ -109,17 +110,45 @@ export function folderForms(cwd, home) {
         forms.push(`~${cwd.slice(base.length)}`);
     return forms;
 }
+export async function askerParams(io, origin, app, session) {
+    let name = session.name ?? undefined;
+    let posted = [];
+    let own = false;
+    if (app === DEFAULT_APP) {
+        const record = await sessionPosted(session.transcript ?? undefined);
+        if (record) {
+            posted = record.posted;
+            own = record.whole;
+        }
+    }
+    else if (session.id) {
+        name ??= (await threadNames(io, app, session.id).catch(() => [])).at(-1);
+        posted = (await threadCards(io, app, session.id).catch(() => [])).slice(0, POSTED_MAX);
+    }
+    const machine = await connectionMachine(io, origin, app).catch(() => null);
+    const machines = [...new Set([io.host, machine].filter((each) => Boolean(each)))];
+    return [
+        ...(name ? [['name', name]] : []),
+        ...posted.map((id) => ['posted', id]),
+        ...(own ? [['own', '1']] : []),
+        ...machines.slice(0, 4).map((each) => ['machine', each]),
+    ];
+}
 export async function pickup(io, options, hook = { fallback: '' }) {
     const { origin, mode } = options;
     const app = options.app ?? DEFAULT_APP;
     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 +173,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 +183,20 @@ 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],
+            ...(await askerParams(io, origin, app, {
+                id: input.session,
+                transcript: input.transcript,
+                name: named ?? null,
+            })),
         ]);
         const { status, body } = await getJson(io, origin, `/mcp/cli/answers?${query}`, TIME_BOX_MS[mode], io.signal, {
             hook: true,
@@ -190,10 +230,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 +278,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 +295,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/stopcheck.js

@@ -5,8 +5,8 @@ import { APP_NAMES, DEFAULT_APP } from "./apps/ids.js";
 import { asksToTypeHere, cardFits, confirmReason, sessionLink } from "./confirm.js";
 import { readCredential } from "./credentials.js";
 import { isHandedWake } from "./format.js";
-import { isPermissionCard, isPromptApp, settlePrompts, subagentsRunning } from "./permission.js";
-import { folderForms } from "./pickup.js";
+import { isPermissionCard, isPromptApp, sessionName, settlePrompts, subagentsRunning, } from "./permission.js";
+import { askerParams, folderForms } from "./pickup.js";
 export const READ_CAP = 4 * 1024 * 1024;
 const CHUNK = 64 * 1024;
 export const STOP_REASON = 'Items for your person are in chat but not in Pending You: post them as cards (ask in both places), or say they don’t need one.';
@@ -275,13 +275,15 @@ function opencodeTurn(input) {
     const text = final.join('\n').trim();
     return text ? { text, posted, cards, handed } : null;
 }
-async function openTitles(io, origin, cwd, app) {
+async function openTitles(io, origin, cwd, app, session) {
     try {
+        const name = app === 'claude-code' ? await sessionName(session.transcript ?? undefined) : undefined;
         const query = new URLSearchParams([
             ...folderForms(cwd, io.home).map((form) => ['cwd', form]),
             ['limit', '0'],
             ['open', String(OPEN_CARDS)],
             ['source', app],
+            ...(await askerParams(io, origin, app, { ...session, name: name ?? null })),
         ]);
         const { status, body } = await getJson(io, origin, `/mcp/cli/answers?${query}`, OPEN_TIME_BOX_MS, io.signal, { hook: true, app });
         const requests = status === 200 ? body.open?.requests : undefined;
@@ -366,11 +368,17 @@ export async function stopcheck(io, options) {
             return asksToTypeHere(text) || itemsForPerson(text) ? block(DELEGATED_REASON) : 0;
         }
         const cwd = typeof input.cwd === 'string' && input.cwd ? input.cwd : io.cwd;
+        const session = {
+            id: typeof input.session_id === 'string' && input.session_id ? input.session_id : null,
+            transcript: typeof input.transcript_path === 'string' && input.transcript_path
+                ? input.transcript_path
+                : null,
+        };
         const ask = asksToTypeHere(text);
         if (ask) {
             if (saysNoCard(text) || turn.cards.some((card) => cardFits(card, ask.words, 'posted')))
                 return 0;
-            const open = await openTitles(io, options.origin, cwd, app);
+            const open = await openTitles(io, options.origin, cwd, app, session);
             if (open ? open.some((title) => cardFits(title, ask.words, 'open')) : saysPosted(text))
                 return 0;
             return block(confirmReason(ask.words, sessionLink(io.env), APP_NAMES[app]));
@@ -378,7 +386,7 @@ export async function stopcheck(io, options) {
         if (turn.posted || saysPosted(text) || saysNoCard(text) || !itemsOutsideRecaps(text))
             return 0;
         if (mentionsCards(text)) {
-            const open = await openTitles(io, options.origin, cwd, app);
+            const open = await openTitles(io, options.origin, cwd, app, session);
             if (open === null || open.some((title) => !isPermissionCard(title)))
                 return 0;
         }

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.22.0';
+export const VERSION = '0.25.0';

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

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

@@ -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.1; send changes there.
+Generated from recordplane/pendingyou (packages/claude-plugin/src/wake) with Pending You’s guide 2.37.0; 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

@@ -31,6 +31,7 @@ const READS = new Set([
     'hand_back',
 ]);
 export const HANDED_READS = new Set(['get_request', 'answer_delegated', 'hand_back']);
+export const APPROVED_DRAFT_NOTICE = 'The approved words are in get_request’s answer.approvedDrafts: send them exactly.';
 const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 const parseJson = (text) => {
     try {
@@ -118,12 +119,16 @@ export function stateOf(output) {
         return null;
     const given = isObject(output.answer) ? output.answer.handled : output.handled;
     const handled = given === 'self' || given === 'leave' ? given : undefined;
+    const approvedDraft = isObject(output.answer)
+        ? Array.isArray(output.answer.approvedDrafts) && output.answer.approvedDrafts.length > 0
+        : output.approvedDraft === true;
     return {
         status,
         turn,
         version,
         cursor: typeof output.cursor === 'string' ? output.cursor : '',
         ...(handled ? { handled } : {}),
+        ...(approvedDraft ? { approvedDraft: true } : {}),
     };
 }
 export const emptyBook = (now = 0) => ({ v: 1, updatedAt: now, cards: {} });
@@ -395,7 +400,7 @@ function line(card) {
                 ];
             return [
                 `your person answered ${titled(card)}`,
-                `call ${get}, act on their words, then ack_answer with its version and a one-line outcome`,
+                `call ${get}, act on their words, then ack_answer with its version and a one-line outcome${state.approvedDraft ? `. ${APPROVED_DRAFT_NOTICE.slice(0, -1)}` : ''}`,
             ];
         case 'delegated':
             return [
@@ -616,7 +621,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 +654,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 +773,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.22.0",
+  "version": "0.25.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",