pendingyou 0.11.0 → 0.13.0

package/dist/apps/codex-wake.js

@@ -1,20 +1,27 @@
-// Codex hearing answers (0.11.0): what its hooks remember about the cards a thread posted, and the listener that wakes
-// the thread when one is answered.
+// Codex hearing answers (0.11.0), and OpenCode and Pi the same way (0.12.0): what an app's hooks remember about the
+// cards a thread (OpenCode, Pi: a session) posted, and the listener that wakes the thread when one is answered.
 //
 // - `pendingyou posted --app codex` is Codex's PostToolUse hook for Pending You's card tools (post_request,
 //   update_request, reply_in_thread, cancel_request; Codex runs it only for a call that didn't fail). It records that
 //   the turn put something in front of the person (with the card's words, for the Stop check: stopcheck.ts), and which
 //   thread is waiting on which card (`session_id` is the thread's id), then makes sure that thread has a listener.
+//   OpenCode's plugin runs it from `tool.execute.after` (apps/opencode-plugin.ts), and Pi's extension from Pi's
+//   `tool_result` (apps/pi-extension.ts), with the same fields.
 // - `pendingyou listen --app codex --thread <id>` is that listener: one per thread (a lease file), detached, holding no
-//   hook's output (Codex would wait for it otherwise). It long-polls Pending You with Codex's own connection, as `watch`
-//   does, and when one of the thread's cards is the agent's move (an answer, a message, a fallback that ran) it runs
-//   `codex queue --thread <id> --message "Pending You: your person answered …"`, in the words the Claude Code wake mod
-//   uses. Never the answer itself: a program's arguments are there for any other program on the computer to read, so
-//   the agent reads the answer with get_request, as the message says. Codex starts a turn at once when the thread is
-//   loaded and idle, after the current one when it's working, or when it's next resumed. It stops when the thread has no card left waiting, or after 8
-//   hours; the next session start or message starts it again while one is (pickup.ts).
+//   hook's output (Codex would wait for it otherwise). It long-polls Pending You with the app's own connection, as
+//   `watch` does, and when one of the thread's cards is the agent's move (an answer, a message, a fallback that ran) it
+//   runs `codex queue --thread <id> --message "Pending You: your person answered …"`, in the words the Claude Code wake
+//   mod uses. Never the answer itself: a program's arguments are there for any other program on the computer to read,
+//   so the agent reads the answer with get_request, as the message says. Codex starts a turn at once when the thread is
+//   loaded and idle, after the current one when it's working, or when it's next resumed. It stops when the thread has
+//   no card left waiting, or after 8 hours; the next session start or message starts it again while one is (pickup.ts).
+// - OpenCode's listener is the plugin's child, not detached, since only the plugin can start a turn
+//   (client.session.promptAsync): it writes each wake as one JSON line on stdout, `{"wake": "<the words>",
+//   "requests": ["req_…"]}`, and the plugin answers on its stdin, `{"delivered": true}` once the turn is started (or
+//   false). Only then is it marked handed over. It stops when its stdin closes (OpenCode went), as well as when Codex's
+//   would. Pi's listener is its extension's child in just the same way (`pi.sendMessage` starts the turn).
 //
-// Ids, names and titles only, in ~/.config/pendingyou/codex-threads.json: never an answer.
+// Ids, names and titles only, in ~/.config/pendingyou/<app>-threads.json: never an answer.
 import { randomBytes } from 'node:crypto';
 import { mkdir, readFile, rm, stat, utimes, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -24,6 +31,7 @@ import { readCredential } from "../credentials.js";
 import { configDir, readJson, withLock, writeWhole } from "../files.js";
 import { clip, isClosed } from "../format.js";
 import { markHanded, momentOf, wasHanded } from "../state.js";
+import { findCodex } from "./codex-app.js";
 /** How long a turn's record, and a thread untouched, are kept. */
 const KEEP_TURN_MS = 24 * 60 * 60_000;
 const KEEP_THREAD_MS = 7 * 24 * 60 * 60_000;
@@ -37,14 +45,37 @@ const LEASE_STALE_MS = 90_000;
 const PATIENT_AFTER_MS = 30 * 60_000;
 const PATIENT_PAUSE_MS = 30_000;
 const BACKOFF_MS = [2000, 5000, 10_000, 20_000, 30_000, 60_000];
+/** How long OpenCode's listener waits for the plugin to say whether it started the turn. */
+const REPLY_MS = 60_000;
 const REQUEST_ID = /^req_[A-Za-z0-9-]{1,40}$/;
-/** Codex's tools for the card calls the hook reads, on a Pending You server (`mcp__pendingyou__post_request`). */
-const CARD_TOOL = /^mcp__([A-Za-z0-9_]*pendingyou[A-Za-z0-9_]*)__(post_request|update_request|reply_in_thread|cancel_request)$/i;
-const statePath = (io) => join(configDir(io), 'codex-threads.json');
-const leasePath = (io, thread) => join(configDir(io), 'codex-listen', `${thread}.lease`);
+/** A thread's id: Codex's (a UUID) or an OpenCode session's (`ses_…`). */
+export const THREAD = /^[A-Za-z0-9][A-Za-z0-9_-]{0,99}$/;
+/** Pending You's card tools as Codex and Pi name them: `mcp__pendingyou__post_request`. */
+const MCP_CARD_TOOL = /^mcp__([A-Za-z0-9_]*pendingyou[A-Za-z0-9_]*)__(post_request|update_request|reply_in_thread|cancel_request)$/i;
+/**
+ * The card calls the hook reads, on a Pending You server: Codex and Pi name a tool `mcp__pendingyou__post_request`,
+ * OpenCode `pendingyou_post_request` (the server's name, `_`, the tool's).
+ */
+const CARD_TOOLS = {
+    codex: MCP_CARD_TOOL,
+    opencode: /^([A-Za-z0-9_-]*pendingyou[A-Za-z0-9_-]*)_(post_request|update_request|reply_in_thread|cancel_request)$/i,
+    pi: MCP_CARD_TOOL,
+};
+/** The card tool a call was, for an app whose hooks read them; null for any other tool. */
+export function cardTool(app, name) {
+    const pattern = CARD_TOOLS[app];
+    return pattern && typeof name === 'string' ? (pattern.exec(name)?.[2] ?? null) : null;
+}
+const statePath = (io, app) => join(configDir(io), `${app}-threads.json`);
+const leasePath = (io, app, thread) => join(configDir(io), `${app}-listen`, `${thread}.lease`);
+/** What uninstall takes away for an app: its threads' record and its listeners' leases. */
+export const threadFiles = (io, app) => [
+    statePath(io, app),
+    join(configDir(io), `${app}-listen`),
+];
 const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
-async function load(io) {
-    const file = await readJson(statePath(io)).catch(() => null);
+async function load(io, app) {
+    const file = await readJson(statePath(io, app)).catch(() => null);
     return {
         version: 1,
         threads: isObject(file?.threads) ? file.threads : {},
@@ -52,10 +83,10 @@ async function load(io) {
     };
 }
 /** Changes the state under its lock, dropping what's old. */
-async function change(io, edit) {
-    const path = statePath(io);
+async function change(io, app, edit) {
+    const path = statePath(io, app);
     return withLock(path, io, async () => {
-        const state = await load(io);
+        const state = await load(io, app);
         edit(state);
         const now = io.now();
         for (const [id, turn] of Object.entries(state.turns))
@@ -115,26 +146,26 @@ function nameOf(input) {
     return text(input.name, 120) ?? text(session?.label, 120);
 }
 /**
- * `pendingyou posted --app codex`: Codex's PostToolUse hook. Remembers what the turn put in front of the person and
- * which cards the thread waits on, then makes sure the thread has a listener. Prints nothing (Codex ignores it anyway);
- * never fails.
+ * `pendingyou posted --app <app>`: Codex's PostToolUse hook, and what OpenCode's plugin runs after a card call.
+ * Remembers what the turn put in front of the person and which cards the thread waits on, then (Codex) makes sure the
+ * thread has a listener; OpenCode's plugin starts its own. Prints nothing (Codex ignores it anyway); never fails.
  */
 export async function posted(io, options) {
+    const { app } = options;
     try {
         const input = JSON.parse(await io.readStdin(1000));
         if (!isObject(input))
             return 0;
-        const tool = typeof input.tool_name === 'string' ? CARD_TOOL.exec(input.tool_name) : null;
+        const call = cardTool(app, input.tool_name);
         const thread = typeof input.session_id === 'string' ? input.session_id : null;
         const turn = typeof input.turn_id === 'string' ? input.turn_id : null;
-        if (!tool || !thread)
+        if (!call || !thread)
             return 0;
-        const call = tool[2];
         const args = isObject(input.tool_input) ? input.tool_input : {};
         const output = resultOf(input.tool_response);
         const requestId = [output?.requestId, args.requestId].find((id) => typeof id === 'string' && REQUEST_ID.test(id));
         const now = io.now();
-        const state = await change(io, (state) => {
+        const state = await change(io, app, (state) => {
             if (turn && call !== 'cancel_request') {
                 const record = state.turns[turn] ?? { at: now, cards: [] };
                 record.cards = [...record.cards, wordsIn(args)].slice(-10);
@@ -162,7 +193,7 @@ export async function posted(io, options) {
             waiting.at = now;
             state.threads[thread] = waiting;
         });
-        if (Object.keys(state.threads[thread]?.cards ?? {}).length > 0)
+        if (app === 'codex' && Object.keys(state.threads[thread]?.cards ?? {}).length > 0)
             await keepListening(io, options.origin, thread);
         return 0;
     }
@@ -171,31 +202,32 @@ export async function posted(io, options) {
     }
 }
 /** Whether this turn put something in front of the person, the words of each card, and whether it was nudged. */
-export async function turnRecord(io, turn) {
-    const record = (await load(io)).turns[turn];
+export async function turnRecord(io, turn, app = 'codex') {
+    const record = (await load(io, app)).turns[turn];
     return record ? { cards: record.cards, nudged: record.nudged === true } : null;
 }
 /** Remembers that the Stop check asked this turn to go on: at most once a turn. */
-export async function markNudged(io, turn) {
+export async function markNudged(io, turn, app = 'codex') {
     const now = io.now();
-    await change(io, (state) => {
+    await change(io, app, (state) => {
         state.turns[turn] = { ...(state.turns[turn] ?? { cards: [] }), at: now, nudged: true };
     });
 }
 /** Whether a listener holds this thread now: its lease, touched within LEASE_STALE_MS. */
-async function listening(io, thread) {
-    return stat(leasePath(io, thread)).then((info) => Date.now() - info.mtimeMs < LEASE_STALE_MS, () => false);
+async function listening(io, app, thread) {
+    return stat(leasePath(io, app, thread)).then((info) => Date.now() - info.mtimeMs < LEASE_STALE_MS, () => false);
 }
 /**
- * Makes sure a thread with cards waiting on the person has a listener: starts one, detached, unless one is there or
- * Codex isn't signed in. Quick (three small reads) and never throws: the session-start and next-message hooks call it too.
+ * Makes sure a Codex thread with cards waiting on the person has a listener: starts one, detached, unless one is there
+ * or Codex isn't signed in. Quick (three small reads) and never throws: the session-start and next-message hooks call
+ * it too.
  */
 export async function keepListening(io, origin, thread) {
     try {
-        if (!/^[A-Za-z0-9][A-Za-z0-9-]{0,99}$/.test(thread))
+        if (!THREAD.test(thread))
             return;
-        const cards = (await load(io)).threads[thread]?.cards ?? {};
-        if (Object.keys(cards).length === 0 || (await listening(io, thread)))
+        const cards = (await load(io, 'codex')).threads[thread]?.cards ?? {};
+        if (Object.keys(cards).length === 0 || (await listening(io, 'codex', thread)))
             return;
         if (!(await readCredential(io, origin, 'codex')))
             return;
@@ -265,10 +297,10 @@ export function wakeMessage(ready) {
  * Takes the thread's lease, a file holding this listener's own id: null when a live listener holds it. Two listeners
  * starting at once may both write it; the one whose id isn't there at its next renewal stops.
  */
-async function takeLease(io, thread) {
-    const path = leasePath(io, thread);
+async function takeLease(io, app, thread) {
+    const path = leasePath(io, app, thread);
     await mkdir(join(path, '..'), { recursive: true, mode: 0o700 });
-    if (await listening(io, thread))
+    if (await listening(io, app, thread))
         return null;
     const id = randomBytes(8).toString('hex');
     await rm(path, { recursive: true, force: true });
@@ -281,8 +313,8 @@ async function takeLease(io, thread) {
     }
 }
 /** Renews the lease while it's still this listener's (`id`); false once another listener has taken it. */
-async function renew(io, thread, id) {
-    const path = leasePath(io, thread);
+async function renew(io, app, thread, id) {
+    const path = leasePath(io, app, thread);
     if ((await readFile(path, 'utf8').catch(() => null)) !== id)
         return false;
     const now = new Date();
@@ -290,27 +322,99 @@ async function renew(io, thread, id) {
     return true;
 }
 /**
- * `pendingyou listen --app codex --thread <id>`: waits on Pending You for the thread's cards, and wakes the thread
- * with `codex queue` when one is the agent's move. Quiet; exits when the thread has none left, Codex can't be reached,
- * the sign-in ends, or after LISTEN_MS.
+ * Codex: `codex queue`, which starts the turn itself: the codex on PATH, or the Codex app's own (0.13.0, codex-app.ts),
+ * found once, when the listener first wakes the thread.
+ */
+function byCodexQueue(io, thread) {
+    let program = null;
+    return async (message) => {
+        program ??= findCodex(io).then((found) => found?.command ?? 'codex');
+        const queued = await io.run(await program, ['queue', '--thread', thread, '--message', message], 30_000);
+        return queued.code === 0;
+    };
+}
+/**
+ * OpenCode and Pi: the plugin (Pi: the extension) that started this listener reads the wake on stdout and starts the
+ * turn, then says on stdin whether it did. stdin closing means the plugin (the app) is gone: `gone` stops the listener.
+ */
+function byPlugin(io, gone) {
+    const queue = [];
+    let waiting = null;
+    let closed = false;
+    const settle = (line) => {
+        const resolve = waiting;
+        waiting = null;
+        resolve?.(line);
+    };
+    void (async () => {
+        try {
+            for await (const line of io.lines()) {
+                if (waiting)
+                    settle(line);
+                else
+                    queue.push(line);
+            }
+        }
+        catch { }
+        closed = true;
+        gone();
+        settle(null);
+    })();
+    const reply = () => {
+        if (queue.length)
+            return Promise.resolve(queue.shift());
+        if (closed)
+            return Promise.resolve(null);
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => settle(null), REPLY_MS);
+            timer.unref?.();
+            waiting = (line) => {
+                clearTimeout(timer);
+                resolve(line);
+            };
+        });
+    };
+    return async (message, requests) => {
+        io.out(`${JSON.stringify({ wake: message, requests })}\n`);
+        const answered = await reply();
+        try {
+            return answered !== null && JSON.parse(answered).delivered === true;
+        }
+        catch {
+            return false;
+        }
+    };
+}
+/**
+ * `pendingyou listen --app <app> --thread <id>`: waits on Pending You for the thread's cards, and wakes the thread
+ * (Codex: `codex queue`; OpenCode and Pi: through the plugin or extension) when one is the agent's move. Quiet but for
+ * the wake lines it hands a plugin; exits when the thread has none left, the app can't take the wake, the sign-in ends,
+ * or after LISTEN_MS.
  */
 export async function listen(io, options) {
-    const { origin, thread } = options;
-    const lease = await takeLease(io, thread);
+    const { origin, app, thread } = options;
+    const lease = await takeLease(io, app, thread);
     if (!lease)
         return 0;
+    const controller = new AbortController();
+    const stop = () => controller.abort();
+    if (io.signal.aborted)
+        stop();
+    io.signal.addEventListener('abort', stop, { once: true });
+    const signal = controller.signal;
+    const deliver = app === 'codex' ? byCodexQueue(io, thread) : byPlugin(io, stop);
     try {
         const started = io.now();
         let since;
         let failures = 0;
-        while (io.now() - started < LISTEN_MS && !io.signal.aborted) {
-            const cards = (await load(io)).threads[thread]?.cards ?? {};
+        while (io.now() - started < LISTEN_MS && !signal.aborted) {
+            const cards = (await load(io, app)).threads[thread]?.cards ?? {};
             if (Object.keys(cards).length === 0)
                 return 0;
-            if (!(await renew(io, thread, lease)))
+            if (!(await renew(io, app, thread, lease)))
                 return 0;
             const query = new URLSearchParams({
-                source: 'codex',
+                source: app,
                 limit: '20',
                 wait: String(LONG_POLL_SECONDS),
             });
@@ -318,19 +422,19 @@ export async function listen(io, options) {
                 query.set('since', since);
             let requests;
             try {
-                const { status, body } = await getJson(io, origin, `/mcp/cli/answers?${query}`, (LONG_POLL_SECONDS + 20) * 1000, io.signal, { app: 'codex' });
+                const { status, body } = await getJson(io, origin, `/mcp/cli/answers?${query}`, (LONG_POLL_SECONDS + 20) * 1000, signal, { app });
                 if (status !== 200)
                     throw new Unavailable(`Pending You answered ${status}.`);
                 requests = Array.isArray(body.requests) ? body.requests : [];
                 failures = 0;
             }
             catch (error) {
-                if (error instanceof SignInNeeded || io.signal.aborted)
+                if (error instanceof SignInNeeded || signal.aborted)
                     return 0;
                 // Renewed first: no pause here outlasts the lease.
-                if (!(await renew(io, thread, lease)))
+                if (!(await renew(io, app, thread, lease)))
                     return 0;
-                await io.sleep(BACKOFF_MS[Math.min(failures++, BACKOFF_MS.length - 1)], io.signal);
+                await io.sleep(BACKOFF_MS[Math.min(failures++, BACKOFF_MS.length - 1)], signal);
                 continue;
             }
             for (const heard of requests)
@@ -342,7 +446,7 @@ export async function listen(io, options) {
                 const card = cards[heard.requestId];
                 if (!card || !heard.ready)
                     continue;
-                // Handed over already (the person wrote in Codex since): nothing to wake it for.
+                // Handed over already (the person wrote in the app since): nothing to wake it for.
                 if (await wasHanded(io, origin, heard.requestId, momentOf(heard)))
                     done.push(heard.requestId);
                 else
@@ -350,10 +454,9 @@ export async function listen(io, options) {
             }
             const message = wakeMessage(ready);
             if (message) {
-                const queued = await io.run('codex', ['queue', '--thread', thread, '--message', message], 30_000);
-                // Codex doesn't know the thread (archived, gone), or can't be run from here: the hooks hand answers over.
-                if (queued.code !== 0) {
-                    await change(io, (state) => {
+                // The app doesn't know the thread (archived, gone), or can't be reached from here: the hooks hand answers over.
+                if (!(await deliver(message, ready.map(({ heard }) => heard.requestId)))) {
+                    await change(io, app, (state) => {
                         delete state.threads[thread];
                     });
                     return 0;
@@ -367,20 +470,21 @@ export async function listen(io, options) {
                 if (cards[heard.requestId] && isClosed(heard) && !done.includes(heard.requestId))
                     done.push(heard.requestId);
             if (done.length)
-                await change(io, (state) => {
+                await change(io, app, (state) => {
                     const waiting = state.threads[thread];
                     if (waiting)
                         for (const id of done)
                             delete waiting.cards[id];
                 });
             if (io.now() - started > PATIENT_AFTER_MS)
-                await io.sleep(PATIENT_PAUSE_MS, io.signal);
+                await io.sleep(PATIENT_PAUSE_MS, signal);
         }
         return 0;
     }
     finally {
+        io.signal.removeEventListener('abort', stop);
         // Only its own: a listener that took over keeps the thread.
-        if ((await readFile(leasePath(io, thread), 'utf8').catch(() => null)) === lease)
-            await rm(leasePath(io, thread), { force: true }).catch(() => { });
+        if ((await readFile(leasePath(io, app, thread), 'utf8').catch(() => null)) === lease)
+            await rm(leasePath(io, app, thread), { force: true }).catch(() => { });
     }
 }

package/dist/apps/codex.js

@@ -20,17 +20,22 @@
 //   which it does by itself from 0.157): codex-wake.ts.
 // - Codex's /import can copy Claude Code's Pending You server (without its headersHelper, so it never signs in) and its
 //   hooks (with Claude Code's app): init replaces both.
+// - The Codex app for macOS (0.13.0, codex-app.ts) shares all of ~/.codex with Codex CLI, and carries its own codex:
+//   with none on PATH, init, status and the listener run the app's. Its trust is "Review hooks › Allow all", and Save on
+//   pendingyou in its MCP settings writes the table again without http_headers_helper (and the approval mode): init's
+//   last lines say both, status names the dropped helper, and running init again puts it back.
 import { createHash } from 'node:crypto';
 import { realpath, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { removeSkill, saveSkill } from "../claude.js";
 import { readCredential } from "../credentials.js";
 import { configDir, readJson, readText, writeWhole } from "../files.js";
-import { isOurHook, mergeHooks, originArgs, removeHooks, } from "../hooks.js";
+import { isOurHook, mergeHooks, originArgs, removeHooks, shWord, } from "../hooks.js";
 import { atLeast } from "../mod.js";
 import { checkHelper, foundBy, headlessReason, helperCommand, helperPath, isOurHelper, } from "../remote.js";
 import { connectionTitle, FINISH_SAY, setupOf, setupStatus } from "../setup.js";
 import { basicString, definedInline, headerOf, renameTable, tableSpans, tableValues, withTable, } from "../toml.js";
+import { findCodex } from "./codex-app.js";
 import { APP_NAMES } from "./ids.js";
 const NAME = APP_NAMES.codex;
 const SERVER = ['mcp_servers', 'pendingyou'];
@@ -38,6 +43,18 @@ const SERVER = ['mcp_servers', 'pendingyou'];
 export const CODEX_MIN = '0.152.0';
 /** From here interactive Codex starts its shared background server by itself, so `codex queue` wakes an idle thread. */
 export const CODEX_WAKE = '0.157.0';
+/**
+ * From here `codex queue` is there (0.149), which is all the Codex app needs: its own server reads the queue while the
+ * app is open (codex-app.ts).
+ */
+export const CODEX_APP_WAKE = '0.149.0';
+/** Where init found Codex when it isn't on PATH. */
+const FROM_APP = 'the Codex app’s';
+/** How the person trusts Codex's hooks, in Codex CLI and in the Codex app (0.13.0). */
+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)';
+/** What undoes init in the Codex app: its MCP settings' Save writes the table again without the helper. */
+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).';
 /** The Pending You tools whose calls the PostToolUse hook reads (codex-wake.ts). */
 const CARD_TOOLS = '^mcp__pendingyou__(post_request|update_request|reply_in_thread|cancel_request)$';
 /** Codex's hooks, by event: the command each runs, and its matcher. */
@@ -210,8 +227,8 @@ async function hookTrust(io) {
     });
 }
 /** Whether `codex mcp list` says Codex holds an OAuth sign-in for its pendingyou server; null when it can't say. */
-async function signedInByItself(io) {
-    const result = await io.run('codex', ['mcp', 'list', '--json'], 30_000);
+async function signedInByItself(io, program) {
+    const result = await io.run(program, ['mcp', 'list', '--json'], 30_000);
     if (result.code !== 0)
         return null;
     try {
@@ -279,10 +296,14 @@ export const codex = {
     name: NAME,
     minVersion: CODEX_MIN,
     async detect(io) {
-        const result = await io.run('codex', ['--version'], 20_000);
-        if (result.code !== 0)
+        // `codex` on PATH, else the Codex app's own (codex-app.ts): init, status and the listener run that one.
+        const found = await findCodex(io);
+        if (!found)
             return null;
-        return { version: /(\d+\.\d+\.\d+)/.exec(result.stdout)?.[1] ?? 'installed' };
+        return {
+            version: found.version,
+            ...(found.app ? { command: found.command, from: FROM_APP } : {}),
+        };
     },
     async installed(io) {
         return (await readCodexManifest(io)) !== null;
@@ -311,6 +332,8 @@ export const codex = {
                 text: 'Codex on Windows isn’t set up by init yet: paste Pending You’s setup message for Codex into it instead.',
             });
         const helperMode = !ctx.oauth;
+        // The codex init runs: the one on PATH, or the Codex app's own.
+        const program = detected.command ?? 'codex';
         const server = await codexServer(io).catch(() => null);
         if (server?.inline)
             return skip({
@@ -351,7 +374,7 @@ export const codex = {
                     text: `Kept Codex’s pendingyou MCP server: it signs in through a headers helper of its own (${server.helper}).`,
                 };
             }
-            else if ((await signedInByItself(io)) !== true) {
+            else if ((await signedInByItself(io, program)) !== true) {
                 // Never signed in: copied from Claude Code by /import (which leaves its helper behind), or left half-made.
                 action = 'write';
             }
@@ -397,7 +420,7 @@ export const codex = {
                     });
                 else {
                     if (mode === 'helper' && server)
-                        await io.run('codex', ['mcp', 'logout', 'pendingyou'], 60_000);
+                        await io.run(program, ['mcp', 'logout', 'pendingyou'], 60_000);
                     const doc = (await readText(config).catch(() => null)) ?? '';
                     const next = withTable(doc, SERVER, serverTable(doc, url, mode === 'helper' ? ictx.helper : null));
                     if (await writeConfig(config, next)) {
@@ -408,11 +431,13 @@ export const codex = {
                                 ? `Added the pendingyou MCP server (${url}) to ${config}${mode === 'helper' ? ', signed in through this computer’s sign-in' : ''}; its tools run without asking.`
                                 : server.url && !sameUrl(server.url, url)
                                     ? `Replaced Codex’s pendingyou MCP server (was ${server.url}) with ${url}.`
-                                    : mode === 'helper'
-                                        ? `Switched Codex’s pendingyou MCP server (${url}) to this computer’s sign-in: one sign-in for it and its hooks.`
-                                        : server.helper
-                                            ? `Switched Codex’s pendingyou MCP server (${url}) to Codex’s own sign-in: run codex mcp login pendingyou.`
-                                            : `Codex’s pendingyou MCP server (${url}) signs in by itself, and its tools now run without asking.`,
+                                    : mode === 'helper' && before?.helper && !server.helper
+                                        ? `Put this computer’s sign-in back on Codex’s pendingyou MCP server (${url}): it had lost its http_headers_helper, which saving it in the Codex app’s MCP settings does.`
+                                        : mode === 'helper'
+                                            ? `Switched Codex’s pendingyou MCP server (${url}) to this computer’s sign-in: one sign-in for it and its hooks.`
+                                            : server.helper
+                                                ? `Switched Codex’s pendingyou MCP server (${url}) to Codex’s own sign-in: run codex mcp login pendingyou.`
+                                                : `Codex’s pendingyou MCP server (${url}) signs in by itself, and its tools now run without asking.`,
                         });
                     }
                     else
@@ -450,10 +475,12 @@ export const codex = {
                         });
                     }
                 }
-                if (!atLeast(version, CODEX_WAKE))
+                if (!atLeast(version, detected.command ? CODEX_APP_WAKE : CODEX_WAKE))
                     report({
                         ok: true,
-                        text: `Codex ${version} wakes an idle thread with your answer only while its background server runs, which Codex starts by itself from ${CODEX_WAKE}. Until you update, an answer reaches a thread when you next write in it.`,
+                        text: detected.command
+                            ? `The Codex app’s codex ${version} has no codex queue, so an answer reaches a chat only when you next write in it. Update the Codex app, then run init again.`
+                            : `Codex ${version} wakes an idle thread with your answer only while its background server runs, which Codex starts by itself from ${CODEX_WAKE}. Until you update, an answer reaches a thread when you next write in it.`,
                     });
                 const manifest = {
                     version: 1,
@@ -472,15 +499,14 @@ export const codex = {
             },
             next: () => {
                 const login = mode === 'oauth' && action !== 'keep';
-                const start = `start codex here, or in the folder you work in, and choose “Trust all and continue” when it asks about hooks (or trust Pending You’s in /hooks)`;
+                const first = login ? `run ${shWord(program)} mcp login pendingyou, then ` : '';
+                // Codex CLI and the Codex app share ~/.codex: name both ways to trust the hooks (0.13.0).
+                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}`;
                 return {
-                    lines: [
-                        `Next: ${login ? 'run codex mcp login pendingyou, then ' : ''}${start}.`,
-                        'Then say this to it:',
-                        '',
-                        FINISH_SAY,
-                    ],
-                    together: `- Codex: ${login ? 'run codex mcp login pendingyou, then ' : ''}${start}, then say the line below to it.`,
+                    lines: [`Next: ${first}${start}.`, DONT_SAVE, 'Then say this to it:', '', FINISH_SAY],
+                    together: `- Codex: ${first}${start}, then say the line below to it. ${DONT_SAVE}`,
                     say: true,
                 };
             },
@@ -560,6 +586,8 @@ export const codex = {
                     ? `not signed in; run ${fix}`
                     : 'Pending You couldn’t be reached';
         const mcpOk = Boolean(server?.url && sameUrl(server.url, url) && (!helper || helped));
+        // init gave it the helper, and it's gone: saving it in the Codex app's MCP settings writes the table again without.
+        const dropped = Boolean(server?.url && sameUrl(server.url, url) && !server.helper && manifest?.helper);
         const mcpText = !server
             ? `not added; run npx pendingyou init --app codex${flag}`
             : server.inline
@@ -568,9 +596,11 @@ export const codex = {
                     ? `points at ${server.url}, not ${url}; run npx pendingyou init --app codex${flag} to replace it`
                     : helped
                         ? `pendingyou (${server.url}), signed in through ${helperPath(io)} --app codex${server.approval === 'approve' ? '; its tools run without asking' : ''}`
-                        : helper
-                            ? `pendingyou (${server.url}) signs in by itself; run npx pendingyou init --app codex${flag} to use this computer’s sign-in`
-                            : `pendingyou (${server.url}), signed in by Codex itself`;
+                        : dropped
+                            ? `pendingyou (${server.url}) has lost its http_headers_helper${server.approval === 'approve' ? '' : ' and default_tools_approval_mode'} (saving it in the Codex app’s MCP settings does that), so Codex can’t sign in through this computer’s sign-in; run npx pendingyou init --app codex${flag} again`
+                            : helper
+                                ? `pendingyou (${server.url}) signs in by itself; run npx pendingyou init --app codex${flag} to use this computer’s sign-in`
+                                : `pendingyou (${server.url}), signed in by Codex itself`;
         const check = helper ? await checkHelper(io, origin, 'codex') : null;
         const words = {
             trusted: 'trusted',
@@ -582,12 +612,14 @@ export const codex = {
         const hooksOk = trust.every((hook) => hook.trust === 'trusted');
         const hooksText = trust.some((hook) => hook.trust === 'missing')
             ? `not installed; run npx pendingyou init --app codex${flag}`
-            : `${trust.map((hook) => `${hook.event} ${words[hook.trust]}`).join(', ')}${hooksOk ? '' : '. Start codex and choose “Trust all and continue”, or trust them in /hooks: Codex skips a hook you haven’t trusted'}`;
-        const wakes = detected ? atLeast(detected.version, CODEX_WAKE) : false;
+            : `${trust.map((hook) => `${hook.event} ${words[hook.trust]}`).join(', ')}${hooksOk ? '' : `. Codex skips a hook you haven’t trusted: ${TRUST_CLI}; ${TRUST_APP}`}`;
+        const wakes = detected
+            ? atLeast(detected.version, detected.command ? CODEX_APP_WAKE : CODEX_WAKE)
+            : false;
         const lines = [
             `Pending You for Codex · ${origin}${why ? ` · no browser here (${why})` : ''}`,
             `  ${mark(signOk)} Sign-in: ${signText}`,
-            `  ${mark(detected !== null)} Codex: ${detected?.version ?? 'not found on PATH'}`,
+            `  ${mark(detected !== null)} Codex: ${detected ? `${detected.version}${detected.command ? ` (${FROM_APP}: ${detected.command})` : ''}` : 'not found on PATH, nor the Codex app'}`,
             `  ${mark(mcpOk)} MCP server: ${mcpText}`,
             ...(check
                 ? [
@@ -598,7 +630,11 @@ 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}`,
-            `  ${mark(wakes)} Wake: ${wakes ? 'codex queue wakes a thread when you answer, even while it’s idle' : `needs Codex ${CODEX_WAKE} or later${detected ? ` (this is ${detected.version})` : ''}; until then an answer reaches a thread when you next write in it`}`,
+            `  ${mark(wakes)} Wake: ${wakes
+                ? detected?.command
+                    ? 'codex queue wakes a chat the Codex app has open when you answer, while the app runs (one it let go, idle 3 hours or behind 10 newer idle chats, hears it when you open it again)'
+                    : 'codex queue wakes a thread when you answer, even while it’s idle'
+                : `needs Codex ${detected?.command ? CODEX_APP_WAKE : CODEX_WAKE} or later${detected ? ` (this is ${detected.version})` : ''}; until then an answer reaches a thread when you next write in it`}`,
         ];
         const setup = setupStatus(NAME, signIn.state === 'ok' ? setupOf(signIn.for) : null);
         if (setup)

package/dist/apps/ids.js

@@ -3,11 +3,13 @@
 // (registry.ts lists them; docs/apps.md says what a module does). Kept apart from the modules so the argument parser can
 // read the list without loading them.
 /** Every app with a module, in the order init sets them up and status lists them. */
-export const APP_IDS = ['claude-code', 'codex'];
+export const APP_IDS = ['claude-code', 'codex', 'opencode', 'pi'];
 /** What people call each app: "Claude Code on devbox" is a connection's name on the Assistants page. */
 export const APP_NAMES = {
     'claude-code': 'Claude Code',
     codex: 'Codex',
+    opencode: 'OpenCode',
+    pi: 'Pi',
 };
 /**
  * The app a command acts for when it names none: Claude Code, the only app before 0.11.0, so hook lines and helpers