pendingyou 0.8.0 → 0.10.0

package/dist/claude.js

@@ -7,13 +7,20 @@
 // Since 0.7.0 the hooks run a private copy of this version with Node directly (install.ts), and init asks Claude Code
 // itself as little as it can: `claude mcp get` and `claude mcp add` each take up to a minute or more (Claude Code checks
 // its servers), so the MCP server is looked up in ~/.claude.json first (read only), and init says what it's waiting on.
+//
+// Since 0.10.0, on Claude Code 2.1.287 or later, settings' env.CLAUDE_CODE_PLUGIN_DIRS also loads the wake mod from
+// that private copy (mod.ts), so a session is woken when the person answers, with no hold running. And on a computer
+// with no browser (remote.ts) the MCP server is added with a headersHelper, `claude mcp add-json`, which signs Claude
+// Code in through this computer's own sign-in instead of OAuth.
 import { createHash } from 'node:crypto';
-import { rm, rmdir } from 'node:fs/promises';
+import { rm, rmdir, stat } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { DEFAULT_ORIGIN } from "./args.js";
 import { PlainError } from "./errors.js";
 import { claudeDir, configDir, readJson, readText, writeWhole } from "./files.js";
-import { hookForm, hookRuns, installCli, pruneCli, removeCli, shellQuote, } from "./install.js";
+import { cliPackage, hookForm, hookRuns, installCli, pruneCli, removeCli, shellQuote, } from "./install.js";
+import { claudeVersion, isOurModDir, loadsMods, modDir, PLUGIN_DIRS, pluginDirs, pluginEnabled, separatorFor, withModDir, } from "./mod.js";
+import { helperCommand, helperPath, isOurHelper, removeHelper, writeHelper } from "./remote.js";
 import { VERSION } from "./version.js";
 export const MCP_NAME = 'pendingyou';
 /** The hooks, by Claude Code event, and the command each runs. */
@@ -212,7 +219,12 @@ export async function mcpFromFile(io) {
     if (typeof server !== 'object' || server === null)
         return 'unknown';
     const url = server.url;
-    return { url: typeof url === 'string' ? url : null, scope: 'user' };
+    const helper = server.headersHelper;
+    return {
+        url: typeof url === 'string' ? url : null,
+        scope: 'user',
+        helper: typeof helper === 'string' ? helper : null,
+    };
 }
 /** `claude mcp get pendingyou`'s answer: the server, null when there isn't one, 'timeout' when it took too long. */
 async function mcpFromClaude(io) {
@@ -239,7 +251,10 @@ const removeCommand = (scope) => `claude mcp remove${scope ? ` --scope ${scope}`
 async function addMcp(io, origin, options, progress) {
     const url = `${origin}/mcp`;
     let existing = await mcpFromFile(io);
-    if (existing !== 'unknown' && existing?.url && sameUrl(existing.url, url))
+    if (existing !== 'unknown' &&
+        existing?.url &&
+        sameUrl(existing.url, url) &&
+        !isOurHelper(existing.helper))
         return {
             added: false,
             step: { ok: true, text: `The pendingyou MCP server (${url}) was already in Claude Code.` },
@@ -266,7 +281,9 @@ async function addMcp(io, origin, options, progress) {
             };
     }
     let replacing = null;
-    if (existing) {
+    // `init --browser` where Claude Code signed in through this computer's helper (remote.ts): back to its own sign-in.
+    const helped = existing && isOurHelper(existing.helper) && (!existing.url || sameUrl(existing.url, url));
+    if (existing && !helped) {
         if (!existing.url || sameUrl(existing.url, url))
             return {
                 added: false,
@@ -307,6 +324,19 @@ async function addMcp(io, origin, options, progress) {
             };
         replacing = existing;
     }
+    if (existing && helped) {
+        progress('Removing the pendingyou MCP server that signs in through this computer’s helper…\n');
+        const removed = await io.run('claude', ['mcp', 'remove', ...(existing.scope ? ['--scope', existing.scope] : []), MCP_NAME], MCP_TIMEOUT_MS);
+        if (removed.code !== 0)
+            return {
+                added: false,
+                step: {
+                    ok: false,
+                    text: `Claude Code didn’t remove the MCP server that signs in through this computer’s helper. Run:\n  ${removeCommand(existing.scope)}\n    ${addCommand(url)}`,
+                },
+            };
+        replacing = existing;
+    }
     progress('Adding the pendingyou MCP server to Claude Code (this can take a minute)…\n');
     const add = await io.run('claude', ['mcp', 'add', '--scope', 'user', '--transport', 'http', MCP_NAME, url], MCP_TIMEOUT_MS);
     if (add.code === 0)
@@ -314,9 +344,11 @@ async function addMcp(io, origin, options, progress) {
             added: true,
             step: {
                 ok: true,
-                text: replacing
-                    ? `Replaced the pendingyou MCP server (was ${replacing.url}) with ${url}. Restart Claude Code, then run /mcp, choose pendingyou and Authenticate.`
-                    : `Added the pendingyou MCP server (${url}) for every project.`,
+                text: !replacing
+                    ? `Added the pendingyou MCP server (${url}) for every project.`
+                    : isOurHelper(replacing.helper) && replacing.url && sameUrl(replacing.url, url)
+                        ? `Switched the pendingyou MCP server (${url}) from this computer’s sign-in to your browser’s. Restart Claude Code, then run /mcp, choose pendingyou and Authenticate.`
+                        : `Replaced the pendingyou MCP server (was ${replacing.url}) with ${url}. Restart Claude Code, then run /mcp, choose pendingyou and Authenticate.`,
             },
         };
     return {
@@ -329,6 +361,122 @@ async function addMcp(io, origin, options, progress) {
         },
     };
 }
+/** `claude mcp add-json`'s arguments for the server signed in through the helper, and the same as a command to type. */
+function helperServer(url, command) {
+    const json = JSON.stringify({ type: 'http', url, headersHelper: command });
+    return {
+        args: ['mcp', 'add-json', '--scope', 'user', MCP_NAME, json],
+        text: `claude mcp add-json --scope user ${MCP_NAME} ${quote(json)}`,
+    };
+}
+/**
+ * On a computer with no browser (remote.ts): the MCP server at user scope with the helper as its headersHelper, so
+ * Claude Code signs in through this computer's sign-in and never needs Authenticate. One already like that is kept. One
+ * at this origin that signs in through a browser (a plain `claude mcp add`, which can't finish here) is switched over
+ * without asking: it's the same Pending You. One with a headersHelper of someone else's is kept, with the commands to
+ * switch. One at another origin is replaced as addMcp replaces it: once the person agrees.
+ */
+async function addMcpWithHelper(io, origin, command, options, progress) {
+    const url = `${origin}/mcp`;
+    const add = helperServer(url, command);
+    let existing = await mcpFromFile(io);
+    if (existing !== 'unknown' &&
+        existing?.url &&
+        sameUrl(existing.url, url) &&
+        existing.helper === command)
+        return {
+            added: false,
+            step: {
+                ok: true,
+                text: `The pendingyou MCP server (${url}) already signs in through this computer’s sign-in.`,
+            },
+        };
+    const version = await io.run('claude', ['--version'], 20_000);
+    if (version.code === 127)
+        return {
+            added: false,
+            step: {
+                ok: false,
+                text: `Claude Code isn’t on this computer’s PATH. Install it, then run init again, or run: ${add.text}`,
+            },
+        };
+    if (existing === 'unknown') {
+        progress('Checking Claude Code’s MCP servers (this can take a minute)…\n');
+        existing = await mcpFromClaude(io);
+        if (existing === 'timeout')
+            return {
+                added: false,
+                step: {
+                    ok: false,
+                    text: `Claude Code took more than 3 minutes to list its MCP servers, so I left them alone. Check with: claude mcp get ${MCP_NAME}. If it isn’t there, run: ${add.text}`,
+                },
+            };
+    }
+    let replacing = null;
+    if (existing) {
+        const commands = `  ${removeCommand(existing.scope)}\n    ${add.text}`;
+        const here = !existing.url || sameUrl(existing.url, url);
+        if (here && existing.helper && !isOurHelper(existing.helper))
+            return {
+                added: false,
+                step: {
+                    ok: false,
+                    text: `Kept the pendingyou MCP server: it signs in through a headersHelper of its own (${existing.helper}). To use this computer’s sign-in instead, run:\n  ${commands}`,
+                },
+            };
+        if (!here) {
+            progress(`Claude Code’s pendingyou MCP server points at ${existing.url}, not ${url}.\n`);
+            let replace = options.yes;
+            if (!replace && io.interactive) {
+                const answer = await io.ask(`Replace it with ${url}? [y/N] `);
+                replace = /^\s*y(es)?\s*$/i.test(answer);
+            }
+            if (!replace)
+                return {
+                    added: false,
+                    step: {
+                        ok: false,
+                        text: `Kept the MCP server at ${existing.url}. To use ${url}, run init again with --yes, or run:\n  ${commands}`,
+                    },
+                };
+        }
+        progress('Removing the old pendingyou MCP server (this can take a minute)…\n');
+        const removed = await io.run('claude', ['mcp', 'remove', ...(existing.scope ? ['--scope', existing.scope] : []), MCP_NAME], MCP_TIMEOUT_MS);
+        if (removed.code !== 0)
+            return {
+                added: false,
+                step: {
+                    ok: false,
+                    text: `${removed.code === 124 ? 'Claude Code took more than 3 minutes to remove' : 'Claude Code didn’t remove'} the old MCP server. Run:\n  ${commands}`,
+                },
+            };
+        replacing = existing;
+    }
+    progress('Adding the pendingyou MCP server to Claude Code…\n');
+    const added = await io.run('claude', add.args, MCP_TIMEOUT_MS);
+    if (added.code !== 0)
+        return {
+            added: false,
+            step: {
+                ok: false,
+                text: added.code === 124
+                    ? `Claude Code took more than 3 minutes to add the MCP server. Check with: claude mcp get ${MCP_NAME}. If it isn’t there, run: ${add.text}`
+                    : `Claude Code didn’t add the MCP server. Run: ${add.text}`,
+            },
+        };
+    const how = `It signs in through this computer’s sign-in (${helperPath(io)}): no browser, nothing to Authenticate.`;
+    return {
+        added: true,
+        step: {
+            ok: true,
+            text: !replacing
+                ? `Added the pendingyou MCP server (${url}) for every project. ${how}`
+                : replacing.url && !sameUrl(replacing.url, url)
+                    ? `Replaced the pendingyou MCP server (was ${replacing.url}) with ${url}. ${how} Restart Claude Code.`
+                    : `Switched the pendingyou MCP server (${url}) from a browser sign-in, which can’t finish on this computer, to this computer’s own. ${how}`,
+        },
+    };
+}
 /** The stub skill: written when it isn't there, or refreshed while it's still the one init wrote. */
 async function saveSkill(io, origin, before) {
     const path = skillPath(io);
@@ -363,7 +511,11 @@ async function saveSkill(io, origin, before) {
         step: { ok: true, text: `Saved the skill to ${path}.` },
     };
 }
-/** Everything init does in Claude Code (not the sign-in). Idempotent. Each step is reported as it's done. */
+/**
+ * Everything init does in Claude Code (not the sign-in). Idempotent. Each step is reported as it's done. `remote`: a
+ * computer with no browser (remote.ts), where the MCP server signs in through the helper, which runs the hooks' copy,
+ * so that copy comes first.
+ */
 export async function installClaude(io, origin, options = {}) {
     const before = await readManifest(io);
     const steps = [];
@@ -372,13 +524,11 @@ export async function installClaude(io, origin, options = {}) {
         options.report?.(step);
     };
     const progress = (text) => io.out(text);
-    const mcp = await addMcp(io, origin, { yes: options.yes ?? false }, progress);
-    report(mcp.step);
-    const skill = await saveSkill(io, origin, before?.skill ?? null);
-    report(skill.step);
     // The hooks' own copy of this version, unless PENDINGYOU_SELF says what they run.
     let installed = null;
-    if (!io.env.PENDINGYOU_SELF) {
+    const installCopy = async () => {
+        if (io.env.PENDINGYOU_SELF)
+            return;
         const cli = await installCli(io, progress);
         installed = cli.installed;
         report(cli.installed
@@ -387,26 +537,66 @@ export async function installClaude(io, origin, options = {}) {
                 text: `${cli.installed.how === 'kept' ? `pendingyou ${VERSION} for the hooks was already in` : `Installed pendingyou ${VERSION} for the hooks in`} ${cli.installed.prefix} (they run it with ${cli.installed.node}, no npx).`,
             }
             : {
-                ok: true,
+                ok: !options.remote,
                 text: `Couldn’t install pendingyou for the hooks (${cli.error}), so they run it through npx, which is slower. Run init again to retry.`,
             });
+    };
+    let mcp;
+    let helper = null;
+    if (options.remote) {
+        await installCopy();
+        const copy = installed;
+        const written = copy ? await writeHelper(io, copy).catch(() => null) : null;
+        if (written) {
+            helper = { path: written.path, command: helperCommand(io, origin) };
+            report({
+                ok: true,
+                text: written.changed
+                    ? `Saved Claude Code’s sign-in helper for this computer: ${written.path}.`
+                    : 'Claude Code’s sign-in helper was already in place.',
+            });
+            mcp = await addMcpWithHelper(io, origin, helper.command, { yes: options.yes ?? false }, progress);
+        }
+        else
+            mcp = {
+                added: false,
+                step: {
+                    ok: false,
+                    text: copy
+                        ? `Couldn’t write Claude Code’s sign-in helper to ${helperPath(io)}. Run init again.`
+                        : 'Didn’t add the pendingyou MCP server: on this computer it signs in through pendingyou’s own copy, which isn’t installed. Run init again.',
+                },
+            };
+        report(mcp.step);
+    }
+    else {
+        mcp = await addMcp(io, origin, { yes: options.yes ?? false }, progress);
+        report(mcp.step);
     }
+    const skill = await saveSkill(io, origin, before?.skill ?? null);
+    report(skill.step);
+    if (!options.remote)
+        await installCopy();
+    const copy = installed;
     const commands = Object.fromEntries(Object.keys(HOOKS).map((event) => [
         event,
-        hookCommand(io, origin, HOOKS[event], installed),
+        hookCommand(io, origin, HOOKS[event], copy),
     ]));
     const merged = mergeSettings(await readSettings(io), commands);
-    if (merged.changed)
-        await writeSettings(io, merged.settings);
     report({
         ok: true,
         text: merged.changed
             ? `Installed or updated the session-start pickup, next-message hand-off and Stop check hooks in ${settingsPath(io)}.`
             : 'The hooks were already installed.',
     });
+    const mod = await addMod(io, merged.settings, copy);
+    if (mod.step)
+        report(mod.step);
+    if (merged.changed || mod.changed)
+        await writeSettings(io, mod.settings);
     // The hooks run this version now (or npx): the copies of other versions are no longer used.
     if (!io.env.PENDINGYOU_SELF)
-        await pruneCli(io, installed?.version ?? null);
+        await pruneCli(io, copy?.version ?? null);
     const manifest = {
         version: 1,
         origin,
@@ -415,25 +605,69 @@ export async function installClaude(io, origin, options = {}) {
         skill: skill.skill,
         hooks: commands,
         permissions: [...new Set([...(before?.permissions ?? []), ...merged.permissionsAdded])],
-        cli: installed ? { version: installed.version, prefix: installed.prefix } : null,
+        cli: copy ? { version: copy.version, prefix: copy.prefix } : null,
+        modDir: mod.dir,
+        // A remote setup's helper stays recorded when this run couldn't redo it, so uninstall still takes it out.
+        helper: helper ?? (options.remote ? (before?.helper ?? null) : null),
     };
     await writeWhole(manifestPath(io), `${JSON.stringify(manifest, null, 2)}\n`, { secret: true });
     return steps;
 }
+const exists = (path) => stat(path).then(() => true, () => false);
+/**
+ * The wake mod in Claude Code's settings (0.10.0): on Claude Code 2.1.287 or later, this version's copy in
+ * CLAUDE_CODE_PLUGIN_DIRS, every other entry kept and an older version's replaced. Nothing, and nothing said, for an
+ * older Claude Code or none. Without the hooks' private copy there's no folder to point at, so it says so.
+ */
+async function addMod(io, settings, installed) {
+    const unchanged = { settings, changed: false, dir: null };
+    const result = await io.run('claude', ['--version'], 20_000);
+    const version = result.code === 0 ? claudeVersion(result.stdout) : null;
+    if (!version || !loadsMods(version))
+        return unchanged;
+    const dir = installed ? modDir(cliPackage(installed.prefix)) : null;
+    if (!dir || !(await exists(join(dir, 'hooks', 'hooks.json'))))
+        return {
+            ...unchanged,
+            step: {
+                ok: true,
+                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));
+    if ('invalid' in added)
+        return { ...unchanged, step: { ok: false, text: added.invalid } };
+    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.',
+        },
+    };
+}
 /** Removes what init added: the hooks, its permissions, its skill (if unchanged), its MCP server. */
 export async function uninstallClaude(io) {
     const manifest = await readManifest(io);
     const steps = [];
     const settings = await readSettings(io);
     const removed = unmergeSettings(settings, manifest?.permissions ?? []);
-    if (removed.changed)
-        await writeSettings(io, removed.settings);
+    // The wake mod lives in the private copy, which goes too: any copy of it in CLAUDE_CODE_PLUGIN_DIRS is ours.
+    const unmodded = withModDir(removed.settings, null, separatorFor(io.platform));
+    const modRemoved = !('invalid' in unmodded) && unmodded.changed;
+    if (removed.changed || modRemoved)
+        await writeSettings(io, 'invalid' in unmodded ? removed.settings : unmodded.settings);
     steps.push({
         ok: true,
         text: removed.changed
             ? 'Removed the Pending You hooks and permissions from Claude Code.'
             : 'No Pending You hooks were installed.',
     });
+    if (modRemoved)
+        steps.push({ ok: true, text: `Removed the wake mod from ${PLUGIN_DIRS}.` });
     if (manifest?.skill) {
         const text = await readText(manifest.skill.path);
         if (text !== null && sha256(text) === manifest.skill.sha256) {
@@ -446,6 +680,8 @@ export async function uninstallClaude(io) {
     }
     if (await removeCli(io))
         steps.push({ ok: true, text: 'Removed the hooks’ copy of pendingyou.' });
+    if (await removeHelper(io))
+        steps.push({ ok: true, text: 'Removed Claude Code’s sign-in helper for this computer.' });
     if (manifest?.mcpAdded) {
         io.out('Removing the pendingyou MCP server from Claude Code (this can take a minute)…\n');
         const result = await io.run('claude', ['mcp', 'remove', '--scope', 'user', MCP_NAME], MCP_TIMEOUT_MS);
@@ -473,8 +709,14 @@ export async function claudeState(io) {
     }
     const skill = (await readText(skillPath(io))) !== null;
     let ours = (_event) => undefined;
+    const mod = { loads: false, dirs: [], present: false, plugin: false };
+    const loads = claude ? claudeVersion(claude) : null;
+    mod.loads = loads !== null && loadsMods(loads);
     try {
-        const all = objectAt(await readSettings(io), 'hooks') ?? {};
+        const settings = await readSettings(io);
+        mod.dirs = (pluginDirs(settings, separatorFor(io.platform)) ?? []).filter(isOurModDir);
+        mod.plugin = pluginEnabled(settings);
+        const all = objectAt(settings, 'hooks') ?? {};
         ours = (event) => Array.isArray(all[event])
             ? all[event]
                 .flatMap((group) => group.hooks ?? [])
@@ -484,6 +726,8 @@ export async function claudeState(io) {
     catch { }
     const start = ours('SessionStart');
     const form = typeof start?.command === 'string' ? hookForm(start.command) : null;
+    const found = await Promise.all(mod.dirs.map((dir) => exists(join(dir, 'hooks', 'hooks.json'))));
+    mod.present = found.length > 0 && found.every(Boolean);
     return {
         claude,
         mcp,
@@ -491,5 +735,6 @@ export async function claudeState(io) {
         hooks: Boolean(start && ours('UserPromptSubmit')),
         stopcheck: Boolean(ours('Stop')),
         form: form ? { ...form, runs: await hookRuns(form) } : null,
+        mod,
     };
 }

package/dist/confirm.js

@@ -0,0 +1,231 @@
+// "Confirm in your agent" (guide 2.21, CLI 0.9.0). Some steps an agent takes only on its person's own words in its
+// conversation: a card answer reaches it as a tool's result, and its rules (or its app's) want more for something that
+// can't be undone, credentials, or anything outside its sandbox. That's right, but on 2026-10-03 a Claude Code agent
+// declined to act on an approved "Erase disk12?" card, asked for "yes, erase disk12" in its own chat, and never told
+// Pending You, so Darin had to go and find the session.
+//
+// The Stop hook (stopcheck.ts) now catches a final message that asks the person to type or reply something in this
+// chat: asksToTypeHere finds it, cardFits says whether a card already asks for it (one posted in the turn, or one still
+// open), and confirmReason is what Claude Code reads when none does: post an action card that sends them here, with
+// the exact words as a step's command and, when Claude Code says it, the session's link.
+//
+// Pattern matching only, deliberately narrow (a block costs a whole extra turn): an ask said to the person (an
+// imperative, "please …", "can you …", "I need you to …"), with the words quoted or a plain "yes", and anchored to this
+// chat ("here", "in this chat") or to going ahead ("to confirm", "and I'll …"). Never in code, block quotes or quoted
+// text; never what a program, a page or a message says; never a step somewhere else (their terminal, a prompt, a page,
+// a link) or a standing offer ("anytime"); never a command or slash command to run.
+/** Verbs that hand the person something to type. */
+const VERB = '(?:type|reply|respond|write|say|send|enter|paste|answer)';
+/**
+ * What comes right before a verb said to the person: the start of a sentence or clause, "and"/"then", a request
+ * ("can you", "I need you to", "I'll wait for you to", "you'll need to", "you can"), then any "please", "just" or
+ * "now".
+ */
+const LEAD = String.raw `(?:^|[,;:(—–→]\s*|\s-\s+|\b(?:and|then|or|so)\s+|\b(?:can|could|would|will)\s+you\s+|\b(?:need|want|like|for)\s+you\s+to\s+|\byou(?:’|')ll\s+(?:need|have)\s+to\s+|\byou\s+(?:need|have)\s+to\s+|\byou\s+can\s+|\ball\s+you\s+need\s+to\s+do\s+is\s+)(?:(?:please|just|simply|kindly|now|then)\s+)*`;
+const ASK = new RegExp(`${LEAD}${VERB}\\b`, 'giu');
+/** "Confirm here", "please confirm in this chat", "can you confirm it here". */
+const CONFIRM_HERE = new RegExp(`${LEAD}confirm(?:\\s+(?:it|this|that|so))?\\s+(?:here|below|in\\s+(?:this|our|the)\\s+(?:chat|conversation|session))\\b`, 'iu');
+/** "Confirm (in this chat) by typing “…”". */
+const CONFIRM_BY = /\bconfirm\b[^.!?\n]{0,30}?\bby\s+(?:typing|replying(?:\s+with)?|saying|sending)\s+⟦(\d+)⟧/iu;
+/** This chat: where the words go. */
+const HERE = /\b(?:here|below|in\s+(?:this|our|the)\s+(?:chat|conversation|session)|in\s+chat|in\s+this\s+(?:terminal|window)|(?:back\s+)?to\s+me)\b/iu;
+/** What typing it does: lets the agent go ahead. */
+const PURPOSE = /\b(?:to\s+(?:confirm|proceed|continue|go\s+ahead|approve|start|begin|carry\s+on|unblock\s+me)|(?:and|so|then)\s+I(?:’|')ll\b|(?:and|so)\s+I\s+(?:can|will)\b|if\s+you\s+want\s+me\s+to\b|when\s+you(?:’|')re\s+ready\b|before\s+I\b)/iu;
+/** Plain words people are asked to type without quotes. */
+const PLAIN_WORD = /^\s*(?:back\s+)?(?:with\s+)?(go ahead|ship it|do it|yes|y|ok|okay|go|proceed|confirm|confirmed|continue|approve|approved)\b/iu;
+/**
+ * What may come between the verb and the quoted words: "Reply here with “…”", "Type these words in this chat: “…”",
+ * "Reply with the exact phrase “…”". Never a recipient ("Reply to Sarah with “…”").
+ */
+const FILLER = /^(?:\s|[,:]|back\b|me\b|it\b|to me\b|with\b|exactly\b|precisely\b|verbatim\b|just\b|the\b|exact\b|following\b|phrase\b|words?\b|text\b|these\b|this\b|that\b|here\b|below\b|in (?:this|our) (?:chat|conversation|session|terminal|window)\b)*$/iu;
+/** Somewhere else to type it: their terminal, a prompt, a page or a form, or a link (but this session's own). */
+const ELSEWHERE = /\b(?:in|into|at|on)\s+(?:your|a|the|that|their)\s+(?:terminal|shell|browser|console|prompt|form|field|dialog|email|inbox|page|app|site|website|portal|dashboard)\b|\bin\s+(?:Terminal|iTerm)\b|\bwhen\s+(?:prompted|asked|it\s+asks)\b|\bat\s+the\s+prompt\b|https?:\/\/(?!claude\.ai\/code\/)/iu;
+/** This chat, said outright, which wins over another place in the same sentence. */
+const THIS_CHAT = /\bin\s+(?:this|our)\s+(?:chat|conversation|session)\b/iu;
+/** A standing offer, not a wait: "Say “stop” anytime". */
+const OFFER = /\b(?:any\s?time|whenever|at\s+any\s+(?:point|time)|if\s+you\s+change\s+your\s+mind|if\s+(?:anything|something)\s+(?:looks|seems|goes))\b/iu;
+/** What something says rather than an ask: "The email ends with: Reply “STOP” here". */
+const DESCRIBED = /\b(?:says?|said|reads?|ends?\s+with|starts?\s+with|shows?|prints?|displays?|asks?|prompts?|tells?\s+\w+|text|message|copy|label|button|template)\s*[:,]?$/iu;
+/** A command or a slash command: a step to run (the general check's business), not words to type to the agent. */
+const COMMAND_LIKE = /^\s*(?:[!/]|\$\s|(?:cd|npm|npx|pnpm|yarn|bun|git|gh|curl|wget|brew|node|python3?|pip|docker|ssh|scp|sudo|claude|codex|wrangler)\s)/u;
+/** Quoted spans the words come in: “…”, "…", `…`, ‘…’ and '…' (not an apostrophe). */
+const QUOTED = /“([^“”\n]{1,160})”|"([^"\n]{1,160})"|`([^`\n]{1,160})`|‘([^‘’\n]{1,160})’|(?<![\p{L}\p{N}])'([^'\n]{1,160})'(?![\p{L}\p{N}])/gu;
+/**
+ * The text as it reads to the person: without fenced code and block quotes (quoted words stay), and without Markdown's
+ * list markers, headings and emphasis (`**Reply “yes” here**`).
+ */
+export function proseOf(text) {
+    const kept = [];
+    let fence = null;
+    for (const line of text.split('\n')) {
+        const marker = /^\s*(`{3,}|~{3,})/.exec(line)?.[1];
+        if (fence) {
+            if (marker?.startsWith(fence))
+                fence = null;
+            continue;
+        }
+        if (marker) {
+            fence = marker;
+            continue;
+        }
+        if (/^\s*>/.test(line))
+            continue;
+        kept.push(line
+            .replace(/^\s*(?:[-*•+]|\d+[.)])\s+/u, '')
+            .replace(/^\s*#+\s*/u, '')
+            .replace(/\*+|__/gu, ''));
+    }
+    return kept.join('\n');
+}
+/** Each quoted span replaced by ⟦n⟧, with what it held. */
+function marked(text) {
+    const quotes = [];
+    const out = text.replace(QUOTED, (...groups) => {
+        const inner = groups.slice(1, 6).find((group) => typeof group === 'string');
+        quotes.push(inner.trim());
+        return `⟦${quotes.length - 1}⟧`;
+    });
+    return { text: out, quotes };
+}
+/** One sentence's ask, or null. `quotes` are the message's quoted spans, by marker number. */
+function askIn(sentence, quotes) {
+    if ((ELSEWHERE.test(sentence) && !THIS_CHAT.test(sentence)) || OFFER.test(sentence))
+        return null;
+    const by = CONFIRM_BY.exec(sentence);
+    if (by) {
+        const words = quotes[Number(by[1])] ?? '';
+        if (words && !COMMAND_LIKE.test(words))
+            return { words };
+    }
+    for (const found of sentence.matchAll(ASK)) {
+        const start = found.index ?? 0;
+        // What a program, a page or a message says isn't an ask: "The SMS ends with: Reply “STOP” here".
+        if (DESCRIBED.test(sentence.slice(0, start).trimEnd()))
+            continue;
+        const from = start + found[0].length;
+        const tail = sentence.slice(from, from + 140);
+        const quote = /⟦(\d+)⟧/u.exec(tail);
+        let words = null;
+        let after = tail;
+        let before = '';
+        if (quote && FILLER.test(tail.slice(0, quote.index))) {
+            words = quotes[Number(quote[1])] ?? null;
+            before = tail.slice(0, quote.index);
+            after = tail.slice(quote.index + quote[0].length);
+        }
+        else {
+            const plain = PLAIN_WORD.exec(tail);
+            if (plain) {
+                words = plain[1].toLowerCase();
+                after = tail.slice(plain[0].length);
+            }
+        }
+        if (words !== null) {
+            if (COMMAND_LIKE.test(words))
+                continue;
+            // Anchored to this chat or to going ahead, or the ask stands alone: "Reply “yes, erase disk12”."
+            const near = after.slice(0, 80);
+            const alone = quote !== null && /^[\s.!)…]*$/u.test(after);
+            if (HERE.test(before) || HERE.test(near) || PURPOSE.test(near) || alone)
+                return { words };
+            continue;
+        }
+        // "Reply here to confirm": no words, but here and going ahead.
+        if (HERE.test(tail.slice(0, 40)) && PURPOSE.test(tail.slice(0, 80)))
+            return { words: null };
+    }
+    return CONFIRM_HERE.test(sentence) ? { words: null } : null;
+}
+/**
+ * Whether the final message asks the person to type or reply something in this chat, and what: "Reply “yes, erase
+ * disk12” here", "To confirm, type `yes`", "Please reply yes here and I'll merge it", "Confirm here". Null otherwise.
+ */
+export function asksToTypeHere(text) {
+    const { text: prose, quotes } = marked(proseOf(text));
+    for (const sentence of prose.split(/(?<=[.!?])\s+|\n+/u)) {
+        const ask = askIn(sentence.trim(), quotes);
+        if (ask)
+            return ask;
+    }
+    return null;
+}
+/** Words that don't tell one card from another: "yes", "confirm", "please"… */
+const COMMON = new Set([
+    'yes',
+    'y',
+    'ok',
+    'okay',
+    'sure',
+    'please',
+    'confirm',
+    'confirmed',
+    'go',
+    'ahead',
+    'proceed',
+    'continue',
+    'approve',
+    'approved',
+    'do',
+    'it',
+    'i',
+    'the',
+    'a',
+    'an',
+    'to',
+    'and',
+    'of',
+    'me',
+    'my',
+    'this',
+    'that',
+]);
+const wordsOf = (text) => text.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
+/** The words that say what's being confirmed: "yes, erase disk12" → erase, disk12. */
+export const telling = (words) => words === null ? [] : [...new Set(wordsOf(words).filter((word) => !COMMON.has(word)))];
+/**
+ * Whether a card asks for this: one posted in the turn (`posted`: the words its call carried) or one still open
+ * (`open`: its title). A card fits when it names everything that tells the words apart ("erase" and "disk12" for
+ * “yes, erase disk12”). With nothing to tell them by ("yes", or no words at all), any card posted in the turn fits,
+ * and an open one only when its title asks to confirm; an open "Confirm …" card that names some of them fits too.
+ */
+export function cardFits(text, words, where) {
+    const wanted = telling(words);
+    const has = new Set(wordsOf(text));
+    if (wanted.length && wanted.every((word) => has.has(word)))
+        return true;
+    if (where === 'posted')
+        return wanted.length === 0;
+    return /\bconfirm/i.test(text) && (wanted.length === 0 || wanted.some((word) => has.has(word)));
+}
+/**
+ * The session's link when Claude Code says it: Remote Control's session (CLAUDE_CODE_BRIDGE_SESSION_ID, in `session_`
+ * form) or a session on the web (CLAUDE_CODE_REMOTE_SESSION_ID, whose `cse_` is the link's `session_`), as
+ * https://code.claude.com/docs/en/env-vars documents them. Null when neither is set.
+ */
+export function sessionLink(env) {
+    const bridge = env.CLAUDE_CODE_BRIDGE_SESSION_ID?.trim();
+    if (bridge && /^session_[A-Za-z0-9]{8,80}$/.test(bridge))
+        return `https://claude.ai/code/${bridge}`;
+    const remote = env.CLAUDE_CODE_REMOTE_SESSION_ID?.trim();
+    if (remote && /^(?:cse|session)_[A-Za-z0-9]{8,80}$/.test(remote))
+        return `https://claude.ai/code/${remote.replace(/^cse_/, 'session_')}`;
+    return null;
+}
+/** The most of the asked-for words the reason repeats. */
+export const REASON_WORDS = 60;
+/**
+ * What Claude Code reads when it asked for words here and no card says so: post the action card that sends them here,
+ * or reopen the card they already answered (about 65 tokens, 80 with a link).
+ */
+export function confirmReason(words, link) {
+    const chars = [...(words?.replace(/\s+/g, ' ').trim() ?? '')];
+    const shown = chars.length > REASON_WORDS
+        ? `${chars
+            .slice(0, REASON_WORDS - 1)
+            .join('')
+            .trimEnd()}…`
+        : chars.join('');
+    const asked = shown ? `to type “${shown}” here` : 'to confirm here';
+    const what = shown ? 'those exact words' : 'the words to type';
+    return `You asked them ${asked}, but no open Pending You card says so: post an action card “Confirm in Claude Code on <computer>: <step>” with ${what} as a step command, where Claude Code on <computer>${link ? `, ${link}` : ''}, done what you’ll do (a card they answered: reply_in_thread with reopen).`;
+}