pendingyou 0.33.0 → 0.34.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.34.0 (2026-10-09)
+
+- Codex can ask on your phone first. `npx pendingyou codex-answers --wait <minutes>` (0 to 10; 0, the default, is off)
+  has Codex's permission prompts go to your Pending You card at once, with **Allow** and **Deny** and the whole command
+  or patch, its secrets masked. Codex shows nothing while its hook waits, so tap one and Codex goes on, or is refused
+  (“Denied in Pending You.”); with no answer within the wait, the card is withdrawn and Codex asks in its terminal as
+  usual. It sets the PermissionRequest hook's timeout in Codex's hooks.json to the wait plus 30 seconds (Codex sets no
+  upper limit for that hook), which changes the hook: trust it again in Codex's `/hooks`, as the command says. `init`
+  names the setting when it sets Codex up and keeps it, `status` shows it, and `uninstall` clears it. Needs Pending You
+  with `permissionPrompt` (0.33.0's server).
+
 ## 0.33.0 (2026-10-09)
 
 - Answer Claude Code's permission prompts on their Pending You card. Start Claude Code with `npx pendingyou claude

package/README.md

@@ -289,6 +289,25 @@ each start (`pendingyou claude` runs `claude --dangerously-load-development-chan
 It needs Claude Code 2.1.234 or later and the permission cards on; a session started with plain `claude` gets the card
 without buttons, as above.
 
+### Codex: ask on my phone first (0.34.0)
+
+Codex shows nothing while its PermissionRequest hook runs, so its prompt can't be on the card and in the terminal at
+once. Instead you can have it ask on your phone first:
+
+```sh
+npx pendingyou codex-answers --wait 2
+```
+
+Now when Codex needs your OK, a card goes up at once with **Allow** and **Deny** and the whole command or patch, secrets
+masked: “Allow Codex (infra) to run a command?”. Tap one and Codex goes on (or is refused, told “Denied in Pending
+You.”). With no answer within the wait, the card goes and Codex asks in its terminal as usual. The wait is 0 to 10
+minutes, per computer; 0, the default, turns it off (the card without buttons, as above). `init` names it when it sets
+Codex up, `status` shows it, and `uninstall` clears it.
+
+It gives Codex's PermissionRequest hook the wait plus 30 seconds (630 seconds for 10 minutes; Codex sets no upper limit
+for that hook). Codex trusts a hook by its whole definition, timeout included, so after changing the wait trust the hook
+again: open Codex, type `/hooks`, and trust it. Allow is for that one call only; nothing is allowed after it.
+
 ## Which sessions are open
 
 Since 0.15.0 Pending You hears which of your agents' sessions are open right now, so it can say so and offer an open
@@ -517,6 +536,7 @@ its environment. A failing command is tried twice more, then skipped. `--once` s
 | `status` | What's set up for each agent; exits 0 when each hears answers right away (`--app`) |
 | `login` / `logout` | Sign an agent in again, or out (`--app`, `--device`, `--browser`, `--force`, `--name`, `--all`) |
 | `claude [args…]` | Claude Code with the permission channel: a prompt's card has Allow and Deny; `claude`'s own arguments after it |
+| `codex-answers --wait <minutes>` | Codex's permission prompts go to your card first, with Allow and Deny, for up to that many minutes (0 to 10; 0, the default, is off) before Codex asks in its terminal |
 | `watch -- <command>` | Run a command each time an answer is ready (`--once`) |
 | `pickup` / `handoff` | The session-start and next-message hooks (`--app`) |
 | `stopcheck` | The Stop hook: items for you left only in chat (`--app`) |

package/dist/apps/codex.js

@@ -2,9 +2,10 @@ import { createHash } from 'node:crypto';
 import { realpath, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { removeSkill, saveSkill } from "../claude.js";
+import { codexManifestPath, isAnswerWait, minutes, permissionTimeout } from "../codex-answers.js";
 import { readCredential } from "../credentials.js";
 import { configDir, readJson, readText, writeWhole } from "../files.js";
-import { isOurHook, lineKey, mergeHooks, originArgs, removeHooks, shWord, } from "../hooks.js";
+import { findHook, isOurHook, lineKey, mergeHooks, originArgs, removeHooks, shWord, } from "../hooks.js";
 import { atLeast } from "../mod.js";
 import { removePresenceFiles } from "../presence.js";
 import { checkHelper, foundBy, headlessReason, helperCommand, helperPath, isOurHelper, } from "../remote.js";
@@ -47,6 +48,7 @@ export const CODEX_PERMISSION_HOOKS = [
     { event: 'PermissionRequest', sub: 'permission' },
     { event: 'PostToolUse', sub: 'permission-done' },
 ];
+export const codexPermissionHooks = (wait) => CODEX_PERMISSION_HOOKS.map((spec) => spec.event === 'PermissionRequest' ? { ...spec, timeout: permissionTimeout(wait) } : spec);
 export const CODEX_PRESENCE_HOOKS = [
     { event: 'SessionEnd', sub: 'presence', timeout: 3 },
 ];
@@ -82,7 +84,7 @@ async function codexHome(io) {
 const configPath = async (io) => join(await codexHome(io), 'config.toml');
 const hooksPath = async (io) => join(await codexHome(io), 'hooks.json');
 export const codexSkillPath = (io) => join(io.home, '.agents', 'skills', 'pendingyou', 'SKILL.md');
-const manifestPath = (io) => join(configDir(io), 'codex.json');
+const manifestPath = codexManifestPath;
 export const readCodexManifest = (io) => readJson(manifestPath(io)).catch(() => null);
 export async function codexServer(io) {
     const doc = await readText(await configPath(io)).catch(() => null);
@@ -264,6 +266,51 @@ function keepTheirTrust(config, file, before) {
     }
     return next;
 }
+export function answerWaitWords(wait) {
+    return wait > 0
+        ? `Ask on your phone first: Codex’s permission prompts wait up to ${minutes(wait)} for Allow or Deny on their Pending You card, then Codex asks in its terminal (npx pendingyou codex-answers --wait 0 turns it off).`
+        : 'Ask on your phone first is off: Codex asks for your OK in its terminal at once. To have it put each permission prompt on your Pending You card first, with Allow and Deny, and wait up to 2 minutes for you there: npx pendingyou codex-answers --wait 2';
+}
+export async function setAnswerWait(io, options) {
+    const { wait } = options;
+    const manifest = await readCodexManifest(io);
+    if (!manifest) {
+        io.err('Codex isn’t set up on this computer yet: run npx pendingyou init --app codex, then this again.\n');
+        return 1;
+    }
+    const file = await readHooksFile(io);
+    if ('invalid' in file) {
+        io.err(`${file.invalid}\n`);
+        return 1;
+    }
+    const hooks = file.json.hooks && typeof file.json.hooks === 'object' && !Array.isArray(file.json.hooks)
+        ? file.json.hooks
+        : {};
+    const hook = findHook(hooks, 'PermissionRequest', 'permission');
+    if (manifest.permissionCards === false || typeof hook?.command !== 'string') {
+        io.err('Codex’s permission-prompt hooks aren’t installed here, so nothing can ask you first: run npx pendingyou init --app codex --permission-cards, then this again.\n');
+        return 1;
+    }
+    const spec = codexPermissionHooks(wait).find((each) => each.event === 'PermissionRequest');
+    const merged = mergeHooks(hooks, [spec], { [lineKey(spec)]: hook.command }, file.path);
+    if (merged.changed)
+        await writeWhole(file.path, `${JSON.stringify({ ...file.json, hooks: merged.hooks }, null, 2)}\n`);
+    const next = { ...manifest };
+    if (wait > 0)
+        next.answerWait = wait;
+    else
+        delete next.answerWait;
+    await writeWhole(manifestPath(io), `${JSON.stringify(next, null, 2)}\n`, { secret: true });
+    io.out(wait > 0
+        ? `Codex’s permission prompts now go to your Pending You card first, with Allow and Deny, and wait up to ${minutes(wait)} for you there; with no answer by then, Codex asks in its terminal as usual. Codex shows nothing while it waits.\n`
+        : 'Turned off: Codex asks for your OK in its terminal at once again, and its card only says so.\n');
+    if (!merged.changed) {
+        io.out('That was already the setting.\n');
+        return 0;
+    }
+    io.out(`\nGave Codex’s PermissionRequest hook ${spec.timeout} seconds in ${file.path}: a changed hook, which Codex skips until you trust it again.\n${trustSteps(await findCodex(io)).join('\n')}\n`);
+    return 0;
+}
 export const codex = {
     id: 'codex',
     name: NAME,
@@ -418,12 +465,14 @@ export const codex = {
                 report(skill.step);
                 const cards = ctx.permissionCards ?? before?.permissionCards !== false;
                 const extra = mode === 'helper' && ictx.helper !== null;
+                const wait = isAnswerWait(before?.answerWait) ? before.answerWait : 0;
                 const wanted = [
                     ...CODEX_HOOKS,
-                    ...(extra && cards ? CODEX_PERMISSION_HOOKS : []),
+                    ...(extra && cards ? codexPermissionHooks(wait) : []),
                     ...(extra ? CODEX_PRESENCE_HOOKS : []),
                 ];
-                const unwanted = ALL_CODEX_HOOKS.filter((spec) => !wanted.includes(spec));
+                const wantedKeys = new Set(wanted.map(lineKey));
+                const unwanted = ALL_CODEX_HOOKS.filter((spec) => !wantedKeys.has(lineKey(spec)));
                 const lines = Object.fromEntries(wanted.map((spec) => [lineKey(spec), ictx.hookLine(spec.sub)]));
                 const file = await readHooksFile(io);
                 if ('invalid' in file)
@@ -453,6 +502,8 @@ export const codex = {
                                     ? `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.',
                         });
+                        if (extra && cards)
+                            report({ ok: true, text: answerWaitWords(wait) });
                     }
                     catch (error) {
                         report({
@@ -478,6 +529,7 @@ export const codex = {
                     helper: mode === 'helper' ? ictx.helper : null,
                     setup: { since: new Date(io.now()).toISOString() },
                     permissionCards: cards,
+                    ...(wait > 0 ? { answerWait: wait } : {}),
                 };
                 await writeWhole(manifestPath(io), `${JSON.stringify(manifest, null, 2)}\n`, {
                     secret: true,
@@ -630,6 +682,12 @@ export const codex = {
             : manifest?.permissionCards === false
                 ? `off, as you chose; for a card when Codex waits for your OK, run npx pendingyou init --app codex --permission-cards${flag}`
                 : null);
+        const wait = isAnswerWait(manifest?.answerWait) ? manifest.answerWait : 0;
+        const askFirst = ownConnection && manifest?.permissionCards !== false
+            ? `          Ask on your phone first: ${wait > 0
+                ? `${minutes(wait)}: a permission prompt waits that long for Allow or Deny on its card, then Codex asks in its terminal (npx pendingyou codex-answers --wait 0 turns it off)`
+                : 'off: Codex asks in its terminal at once (npx pendingyou codex-answers --wait 2 sends its prompts to your card first, for up to 2 minutes)'}`
+            : null;
         const presenceText = extraLine('Presence:', 'tells Pending You when this session is open', CODEX_PRESENCE_HOOKS.map((spec) => spec.sub), ownConnection ? null : notOwn);
         const wakes = detected
             ? atLeast(detected.version, detected.command ? CODEX_APP_WAKE : CODEX_WAKE)
@@ -649,6 +707,7 @@ export const codex = {
             `  ${mark(skill !== null)} Skill: ${skill !== null ? `saved (${codexSkillPath(io)})` : `not saved; run npx pendingyou init --app codex${flag}`}`,
             `  ${mark(hooksOk)} Hooks: ${hooksText}`,
             permissionText,
+            ...(askFirst ? [askFirst] : []),
             presenceText,
             `  ${mark(wakes)} Wake: ${wakes
                 ? detected?.command

package/dist/args.js

@@ -1,4 +1,5 @@
 import { APP_IDS, APP_NAMES, DEFAULT_APP, isAppId } from "./apps/ids.js";
+import { ANSWER_WAIT_MAX } from "./codex-answers.js";
 export const DEFAULT_ORIGIN = 'https://www.pendingyou.com';
 export const DEFAULT_TIMEOUT_MS = 4 * 60 * 60 * 1000;
 const MAX_TIMEOUT_MS = 24 * 60 * 60 * 1000;
@@ -86,6 +87,7 @@ const COMMANDS = new Set([
     'app',
     'channel',
     'claude',
+    'codex-answers',
 ]);
 const FLAGS = {
     help: {},
@@ -143,6 +145,7 @@ const FLAGS = {
     mcp: { origin: true, app: true, check: false },
     channel: { origin: true, app: true },
     claude: {},
+    'codex-answers': { origin: true, wait: true },
     herdr: {
         origin: true,
         app: true,
@@ -454,6 +457,13 @@ export function parseArgs(argv, env = {}) {
                 ...apps(),
                 ...permissionCards(),
             };
+        case 'codex-answers': {
+            none();
+            const given = text('wait');
+            if (given === undefined || !/^\d{1,2}$/.test(given) || Number(given) > ANSWER_WAIT_MAX)
+                throw new UsageError(`codex-answers needs --wait and a whole number of minutes, 0 (off) to ${ANSWER_WAIT_MAX}, like: pendingyou codex-answers --wait 2`);
+            return { name: 'codex-answers', wait: Number(given) };
+        }
         case 'watch':
             none();
             if (!command?.length || !command[0])
@@ -675,6 +685,10 @@ export const USAGE = `pendingyou: Pending You for your coding agents (Claude Cod
                                Start Claude Code so its permission prompts can be answered on their
                                Pending You cards: Allow or Deny there, or in the terminal; the first
                                answer wins. Claude Code warns about the development channel each start
+  npx pendingyou codex-answers --wait <minutes>
+                               Codex asks on your phone first: its permission prompts go to your
+                               Pending You card, with Allow and Deny, and wait up to that many minutes
+                               (0 to ${ANSWER_WAIT_MAX}; 0, the default, is off) before Codex asks in its terminal
   npx pendingyou watch -- <command> [args…]
                                Run a command each time an answer is ready (always-on scripts)
   npx pendingyou uninstall     Remove exactly what init added

package/dist/codex-answers.js

@@ -0,0 +1,15 @@
+import { join } from 'node:path';
+import { configDir, readJson } from "./files.js";
+import { HOOK_TIMEOUT } from "./hooks.js";
+export const ANSWER_WAIT_MAX = 10;
+export const ANSWER_MARGIN_S = 30;
+export const ANSWER_DEADLINE_MARGIN_MS = 20_000;
+export const codexManifestPath = (io) => join(configDir(io), 'codex.json');
+export const isAnswerWait = (value) => typeof value === 'number' && Number.isInteger(value) && value >= 0 && value <= ANSWER_WAIT_MAX;
+export async function readAnswerWait(io) {
+    const manifest = await readJson(codexManifestPath(io)).catch(() => null);
+    const wait = manifest?.answerWait;
+    return isAnswerWait(wait) ? wait : 0;
+}
+export const permissionTimeout = (wait) => wait > 0 ? wait * 60 + ANSWER_MARGIN_S : HOOK_TIMEOUT;
+export const minutes = (wait) => `${wait} minute${wait === 1 ? '' : 's'}`;

package/dist/main.js

@@ -1,4 +1,5 @@
 import { HOOK_DEADLINE_MS, refreshInBackground, SignInNeeded, Unavailable } from "./api.js";
+import { setAnswerWait } from "./apps/codex.js";
 import { listen, listenHanded, posted } from "./apps/codex-wake.js";
 import { DEFAULT_APP } from "./apps/ids.js";
 import { appModule } from "./apps/registry.js";
@@ -6,6 +7,7 @@ import { commandOf, HOOK_COMMANDS, parseArgs, USAGE, UsageError } from "./args.j
 import { bridge } from "./bridge.js";
 import { channel } from "./channel.js";
 import { claudeWithChannel } from "./claude.js";
+import { ANSWER_DEADLINE_MARGIN_MS, readAnswerWait } from "./codex-answers.js";
 import { PlainError } from "./errors.js";
 import { hold } from "./hold.js";
 import { init, status, uninstall } from "./init.js";
@@ -85,6 +87,8 @@ async function run(io, command, hook = { fallback: '' }) {
             return uninstall(io, command);
         case 'watch':
             return watch(io, command);
+        case 'codex-answers':
+            return setAnswerWait(io, command);
         case 'refresh':
             try {
                 await refreshInBackground(io, command.origin, command.force, command.app ?? DEFAULT_APP);
@@ -108,6 +112,12 @@ async function run(io, command, hook = { fallback: '' }) {
     }
 }
 export { HOOK_DEADLINE_MS };
+async function deadlineOf(io, command) {
+    if (command.name !== 'permission' || command.app !== 'codex')
+        return HOOK_DEADLINE_MS;
+    const wait = await readAnswerWait(io).catch(() => 0);
+    return wait > 0 ? wait * 60_000 + ANSWER_DEADLINE_MARGIN_MS : HOOK_DEADLINE_MS;
+}
 async function runHook(io, command) {
     const hook = { fallback: '' };
     const controller = new AbortController();
@@ -127,9 +137,10 @@ async function runHook(io, command) {
         },
         signal: controller.signal,
     };
+    const limit = await deadlineOf(io, command);
     let timer;
     const deadline = new Promise((resolve) => {
-        timer = setTimeout(() => resolve('deadline'), Math.max(0, HOOK_DEADLINE_MS - io.uptime()));
+        timer = setTimeout(() => resolve('deadline'), Math.max(0, limit - io.uptime()));
     });
     try {
         const outcome = await Promise.race([run(hookIo, command, hook), deadline]);

package/dist/permission.js

@@ -5,10 +5,11 @@ import { threadNames } from "./apps/codex-wake.js";
 import { APP_NAMES } from "./apps/ids.js";
 import { DEFAULT_ORIGIN } from "./args.js";
 import { McpFailure, mcpClient, SIGN_IN_ERROR, ToolRefused } from "./bridge.js";
+import { minutes, readAnswerWait } from "./codex-answers.js";
 import { sessionLink } from "./confirm.js";
 import { connectionMachine, readCredential } from "./credentials.js";
 import { claudeDir, configDir, PERMISSION_FOLDER, readJson, withLock, writeWhole } from "./files.js";
-import { BLANK, cut, redactCommand, redactText, redactUrl, shortPath } from "./redact.js";
+import { BLANK, cut, maskSecrets, redactCommand, redactText, redactUrl, shortPath, } from "./redact.js";
 import { machineOf } from "./remote.js";
 export const GRACE_MS = 10_000;
 export const TITLE_MAX = 90;
@@ -456,6 +457,11 @@ export async function permissionHook(io, options) {
             return 0;
         switch (input.hook_event_name) {
             case 'PermissionRequest':
+                if (app === 'codex') {
+                    const wait = await readAnswerWait(io);
+                    if (wait > 0 && (await askFirst(io, options.origin, input, wait)))
+                        break;
+                }
                 await asked(io, options.origin, input, app);
                 break;
             case 'PostToolUse':
@@ -1353,3 +1359,216 @@ export async function removePermissionFiles(io) {
     await rm(folder, { recursive: true, force: true });
     return there;
 }
+export const ANSWER_READ_MS = 2000;
+const ANSWER_CALL_MS = 8000;
+const ANSWER_INPUT_MAX = 40_000;
+const ANSWER_LINES_MAX = 400;
+const ANSWER_LINE_MAX = 2000;
+export const DENIED = 'Denied in Pending You.';
+export function codexDecision(verdict) {
+    const decision = verdict === 'allow' ? { behavior: 'allow' } : { behavior: 'deny', message: DENIED };
+    return JSON.stringify({
+        hookSpecificOutput: { hookEventName: 'PermissionRequest', decision },
+    });
+}
+export function codexInputLines(tool, input) {
+    const { description: _, ...rest } = input;
+    const command = commandText(rest.command);
+    const patch = command || text(rest.patch) || text(rest.input);
+    let lines;
+    let lang = 'text';
+    if (tool === 'apply_patch' && patch)
+        lines = patch.split('\n');
+    else if (command) {
+        lines = command.split('\n');
+        lang = 'shell';
+    }
+    else
+        lines = Object.entries(rest).flatMap(([key, value]) => `${key}: ${typeof value === 'string' ? value : JSON.stringify(value)}`.split('\n'));
+    const kept = [];
+    let size = 0;
+    for (const line of lines) {
+        if (kept.length >= ANSWER_LINES_MAX ||
+            line.length > ANSWER_LINE_MAX ||
+            size + line.length > ANSWER_INPUT_MAX) {
+            kept.push('… (cut here: too long to show whole)');
+            return { lines: kept, lang, cut: true };
+        }
+        kept.push(maskSecrets(line));
+        size += line.length;
+    }
+    return { lines: kept.length ? kept : [''], lang, cut: false };
+}
+function tapOf(card, partial) {
+    if (!['answered', 'resolved'].includes(text(card.status)))
+        return null;
+    const answer = isObject(card.answer) ? card.answer : null;
+    const picked = Array.isArray(answer?.choiceIds) ? answer.choiceIds : [];
+    if (picked.length !== 1)
+        return 'terminal';
+    if (picked[0] === DENY)
+        return 'deny';
+    if (picked[0] === ALLOW && !partial)
+        return 'allow';
+    return 'terminal';
+}
+async function askFirst(io, origin, input, wait) {
+    if (io.platform === 'win32')
+        return false;
+    const where = whereOf(input);
+    const tool = text(input.tool_name);
+    if (!where || !tool)
+        return false;
+    if ((await readCredential(io, origin, 'codex'))?.kind !== 'connection')
+        return false;
+    const started = io.now();
+    const toolInput = isObject(input.tool_input) ? input.tool_input : {};
+    const cwd = text(input.cwd) || io.cwd;
+    const known = await load(io, where.session).catch(() => null);
+    const state = {
+        version: 1,
+        origin,
+        app: 'codex',
+        session: where.session,
+        cwd,
+        prompts: [],
+        ...(known?.areaId && known.cwd === cwd ? { areaId: known.areaId } : {}),
+        at: started,
+    };
+    const prompt = {
+        key: promptKey(tool, keyInput('codex', toolInput)),
+        tool: tool.slice(0, 100),
+        ...promptWords(tool, toolInput, io.home, 'codex'),
+        at: started,
+    };
+    const shown = codexInputLines(tool, toolInput);
+    let client = null;
+    let card;
+    let machine;
+    try {
+        client = await mcpClient(io, origin, 'codex', ANSWER_CALL_MS);
+        const name = await nameOf(io, state);
+        await client.call('whoami', { name });
+        const areaId = state.areaId ?? (await areaFor(io, client, state, name));
+        machine = await computerOf(io, origin, 'codex');
+        const title = relayTitle(state, prompt, name);
+        const who = name === defaultName('codex') ? APP_NAMES.codex : `${APP_NAMES.codex} (${name})`;
+        const wants = prompt.doing.startsWith('to ')
+            ? `wants your OK ${prompt.doing}`
+            : `wants your OK to use ${toolName(tool)}`;
+        const reason = reasonOf('codex', toolInput);
+        const why = reason ? ` It says: “${reason}”.` : '';
+        const answer = shown.cut
+            ? ' It’s too long to show whole, so only Deny is here; to allow it, choose “I’ll answer in Codex” and answer in its terminal.'
+            : ` Allow or Deny here: Codex waits up to ${minutes(wait)} for you, showing nothing, then asks in its terminal.`;
+        const session = createHash('sha256').update(where.session).digest('hex').slice(0, 24);
+        const result = await client.call('post_request', {
+            idempotencyKey: `codex-ask:${session}:${prompt.key}:${started}`,
+            areaId,
+            session: { label: name, machine, cwd: cut(tilde(io, cwd), 300) },
+            kind: 'choice',
+            intent: 'approve',
+            title,
+            summary: cut(`${who} in ${tilde(io, cwd)} on ${machine} ${wants}.${why}${answer}`, 400),
+            options: shown.cut
+                ? [
+                    { id: DENY, label: 'Deny' },
+                    { id: IN_TERMINAL, label: `I’ll answer in ${APP_NAMES.codex}` },
+                ]
+                : [
+                    { id: ALLOW, label: 'Allow', detail: 'This call only. Nothing is allowed after it.' },
+                    { id: DENY, label: 'Deny' },
+                ],
+            artifacts: [
+                {
+                    kind: 'code',
+                    title: shown.lang === 'shell' ? 'The command' : `${toolName(tool)}’s input`,
+                    ref: `permission-${prompt.key.slice(0, 16)}`,
+                    lang: shown.lang,
+                    lines: shown.lines,
+                },
+            ],
+            context: { ...contextOf(state, prompt), trace: [{ state: 'paused', text: title }] },
+            blocking: false,
+            urgency: 'now',
+            permissionPrompt: { app: 'codex', relay: true },
+        });
+        const requestId = idOf(result, 'requestId', 'req_');
+        if (!requestId)
+            throw new McpFailure(-32000, 'Pending You posted no card.');
+        card = {
+            requestId,
+            version: typeof result.version === 'number' ? result.version : 1,
+            key: prompt.key,
+            name,
+        };
+    }
+    catch {
+        await client?.close().catch(() => { });
+        return false;
+    }
+    const pending = client;
+    const read = () => pending.call('get_request', { requestId: card.requestId, name: card.name });
+    const say = async (tap, now) => {
+        if (tap !== 'terminal')
+            io.out(`${codexDecision(tap)}\n`);
+        if (now.status !== 'answered' || typeof now.version !== 'number')
+            return;
+        await pending
+            .call('ack_answer', {
+            requestId: card.requestId,
+            name: card.name,
+            expectedVersion: now.version,
+            outcome: cut(tap === 'allow'
+                ? `Allowed in Codex on ${machine}.`
+                : tap === 'deny'
+                    ? `Denied in Codex on ${machine}.`
+                    : `Not allowed or denied here: Codex asks in its terminal on ${machine} now.`, 200),
+        })
+            .catch(() => { });
+    };
+    const until = started + wait * 60_000;
+    try {
+        while (!io.signal.aborted && io.now() < until) {
+            await io.sleep(Math.min(ANSWER_READ_MS, until - io.now()), io.signal);
+            if (io.signal.aborted)
+                return true;
+            let now;
+            try {
+                now = await read();
+            }
+            catch (error) {
+                if (error instanceof McpFailure && error.code === SIGN_IN_ERROR)
+                    break;
+                continue;
+            }
+            if (['pending', 'snoozed', 'delegated'].includes(text(now.status)))
+                continue;
+            const tap = tapOf(now, shown.cut);
+            if (tap)
+                await say(tap, now);
+            return true;
+        }
+        if (io.signal.aborted)
+            return true;
+        try {
+            await pending.call('cancel_request', {
+                requestId: card.requestId,
+                name: card.name,
+                reason: cut(`No answer here in ${minutes(wait)}, so Codex is asking in its terminal on ${machine} now.`, 200),
+            });
+        }
+        catch (error) {
+            if (!(error instanceof ToolRefused))
+                return true;
+            const now = await read().catch(() => null);
+            const tap = now ? tapOf(now, shown.cut) : null;
+            if (now && tap)
+                await say(tap, now);
+        }
+        return true;
+    }
+    finally {
+        await pending.close().catch(() => { });
+    }
+}

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.33.0';
+export const VERSION = '0.34.0';

package/package.json

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