pendingyou 0.21.0 → 0.22.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.22.0 (2026-10-06)
+
+- Trusting Codex's hooks is one command now. When `init` or `status` finds Pending You's hooks in Codex but not trusted
+  yet, it prints the command that opens a Codex here (`codex` on PATH, else the Codex command line the ChatGPT app
+  brings, by its full path, quoted) and says to type `/hooks` there, look over Pending You's hooks and trust them. At a
+  terminal it then waits, looking again every 3 seconds for up to 10 minutes, and says "Ready: Codex hears answers
+  right away" once they're trusted (Ctrl-C stops the wait; `npx pendingyou status` checks later). Run by an agent, it
+  prints the same steps without waiting. It never trusts them for you.
+- The instructions no longer send you to a Hooks page in the Codex app's Settings, which people couldn't find, nor to
+  other ways of trusting the hooks that haven't been seen working: init's last lines and `status` lead with `/hooks`.
+- Looking for the Codex inside the ChatGPT or Codex app, the command line tries the `CodexCLI.app` it carries first,
+  then its `bin` folder.
+
 ## 0.21.0 (2026-10-06)
 
 - Answer from Herdr. The Pending You plugin for Herdr (0.2) can now answer your cards from its popup, once you sign

package/README.md

@@ -41,8 +41,8 @@ Finish setting up Pending You: it’s connected here already.
 ```
 
 The first session finishes setting up on its own: it checks in with Pending You, reports what's set up and sends you a
-test card. Claude Code 2.1.287 or later starts that turn by itself; otherwise (and in Codex, after you trust its hooks:
-“Trust all and continue” in Codex CLI, Review hooks › Allow all in the Codex app) the session start adds one line with
+test card. Claude Code 2.1.287 or later starts that turn by itself; otherwise (and in Codex, after you trust its hooks in
+`/hooks`) the session start adds one line with
 the three calls that are left, and you say the sentence.
 `npx pendingyou status` says what's set up for each agent, what's missing with the command that fixes it, and how setup
 stands. `npx pendingyou uninstall` removes exactly what `init` added.
@@ -99,9 +99,11 @@ default_tools_approval_mode = "approve"
 and hooks in `~/.codex/hooks.json`: a session start, each message, Pending You's card tools (so the Stop check knows a
 turn posted, and so the thread is woken), and the Stop check; and (0.15.0) Codex's permission prompt and every tool
 call that ran (a card when Codex waits for your OK, [below](#when-claude-code-waits-for-your-ok)) and the session's end
-([below](#which-sessions-are-open)). **Codex runs a hook only once you trust it**: in Codex CLI, start `codex` and
-choose “Trust all and continue” (or trust them in `/hooks`); in the Codex app, click Review hooks › Allow all (or
-Settings › Hooks › Trust all). `status` says which are trusted. Upgrading from 0.14.0 adds three hooks, which Codex
+([below](#which-sessions-are-open)). **Codex runs a hook only once you trust it**, in Codex's `/hooks`. When `init` or
+`status` finds Pending You's hooks not trusted yet, it prints the one command that opens a Codex here (`codex`, or
+the one the ChatGPT app brings, by its full path) and says to type `/hooks` there and trust them; at a terminal it
+then waits (every 3 seconds, for up to 10 minutes; Ctrl-C stops it) until Codex trusts them, and says whether Codex is
+ready. It never trusts them for you. `status` says which are trusted. Upgrading from 0.14.0 adds three hooks, which Codex
 skips until you trust them once; `init` says so, and the ones you trusted stay trusted. A `pendingyou` server or
 hooks Codex's `/import` copied from Claude Code (without its sign-in) are replaced.
 

package/dist/apps/codex-app.js

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

package/dist/apps/codex.js

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

package/dist/init.js

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

package/dist/trust.js

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

package/dist/version.js

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

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

@@ -1,7 +1,7 @@
 {
   "name": "pendingyou-wake",
   "displayName": "Pending You",
-  "version": "2.34.0",
+  "version": "2.34.1",
   "description": "Wakes Claude Code when your person answers a Pending You card it posted, even while it sits idle. Installed by `npx pendingyou init`.",
   "author": {
     "name": "RecordPlane",

package/mod/README.md

@@ -4,4 +4,4 @@ The pendingyou command line’s copy of the Pending You plugin’s wake mod, for
 
 In each session it learns the cards the session posts to Pending You, checks them through the session’s own Pending You connection, and starts a turn when your person answers, writes back or a fallback comes due, or hands the session a question from another of their assistants (CLI 0.14.0), even while it sits idle. It answers `npx pendingyou hold` itself, so nothing waits in the background, and shows “2 waiting on you” under the prompt, after the plugin’s name. With the Pending You plugin installed too, only one copy acts.
 
-Generated from recordplane/pendingyou (packages/claude-plugin/src/wake) with Pending You’s guide 2.34.0; send changes there.
+Generated from recordplane/pendingyou (packages/claude-plugin/src/wake) with Pending You’s guide 2.34.1; send changes there.

package/package.json

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