pendingyou 0.32.3 → 0.34.0

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # 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
+  [args…]` (it runs `claude --dangerously-load-development-channels server:pendingyou-permissions [args…]`) and a
+  prompt left waiting gets a card with **Allow** and **Deny** and the whole input, its secrets masked, instead of a
+  card that only says where to answer. The terminal dialog stays open: whichever answer comes first wins, and Allow is
+  for that one call only. `init` registers the channel (`pendingyou channel --app claude-code`, a stdio MCP server that
+  sends nothing to the model) at user scope through the hooks' shim, beside the permission-prompt hooks, on Claude
+  Code 2.1.234 or later; `uninstall` and `--no-permission-cards` take it out; `status` says whether it's there. The card
+  still waits the same 10 seconds, so a prompt answered at the terminal gets none; answered there later, the card goes
+  as before. A session started with plain `claude` keeps today's card, which now says it's a permission
+  prompt's (`permissionPrompt` with `relay: false`). Needs Pending You with `post_request`'s `permissionPrompt`
+  (deploy the server first). Claude Code warns about the development channel at each start until
+  the channel is on its allowlist.
+
 ## 0.32.3 (2026-10-09)
 
 - Claude Code's and Codex's permission prompts get their cards. The worker posted each card without `context`, which

package/README.md

@@ -274,6 +274,40 @@ PermissionRequest hook prints nothing, so Codex asks exactly as before; the card
 Codex, the turn ends or the thread closes. It needs Codex signing in through this computer's sign-in, and trusting the
 new hooks once. The Codex app's browser-use prompts don't run that hook, so they get no card.
 
+### Allow or Deny on the card (0.33.0)
+
+Start Claude Code with `npx pendingyou claude` (any of `claude`'s own arguments after it) and a prompt left waiting gets
+a card with **Allow** and **Deny**, and the whole command or input it asks about, secrets masked: “Allow Claude Code
+(billing-webhooks) to run a command?”. Tap one and the terminal's dialog closes and the call runs, or is refused. The
+dialog stays open meanwhile, so you can still answer at the terminal: the first answer wins, and the card goes. Allow
+is for that one call only; nothing is allowed after it.
+
+It works through Claude Code's channels (a research preview): `init` registers a small local MCP server,
+`pendingyou-permissions`, that Claude Code relays its permission prompts to in a session started this way, and that
+sends Claude nothing. Until it's on Claude Code's allowlist, Claude Code shows a warning about development channels at
+each start (`pendingyou claude` runs `claude --dangerously-load-development-channels server:pendingyou-permissions`).
+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
@@ -501,6 +535,8 @@ its environment. A failing command is tried twice more, then skipped. `--once` s
 | `hold <requestId>` | Wait for the answer, print it, exit (`--timeout 4h`); the wake mod answers it itself |
 | `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/claude-code.js

@@ -1,9 +1,10 @@
+import { CHANNEL_CLAUDE } from "../channel.js";
 import { addCommand, claudeState, helperServer, installClaude, mcpFromClaude, mcpFromFile, PLUGIN_ORIGINS, permissionBlocker, pluginFor, readManifest, removeCommand, sameUrl, uninstallClaude, } from "../claude.js";
 import { connectionMachine, readCredential } from "../credentials.js";
 import { differs, serverForFolder, siteOf } from "../environment.js";
 import { originArgs } from "../hooks.js";
 import { modConfigured, pruneLoadedNotes, unwokenLines, unwokenSessions, } from "../loaded.js";
-import { claudeVersion, isOurModDir, loadsMods, MOD_CLAUDE } from "../mod.js";
+import { atLeast, claudeVersion, isOurModDir, loadsMods, MOD_CLAUDE } from "../mod.js";
 import { checkHelper, foundBy, headlessReason, helperCommand, helperPath, isOurHelper, machineOf, usesHelper, } from "../remote.js";
 import { connectionTitle, FINISH_SAY, setupOf, setupStatus } from "../setup.js";
 import { shimPath } from "../shim.js";
@@ -223,6 +224,23 @@ function permissionLine(io, claude, manifest, helper, flag) {
         ? `          ${label} no card when Claude Code waits for your OK: ${blocker}`
         : `  missing ${label} no card when Claude Code waits for your OK; run npx pendingyou@latest init${flag}`;
 }
+function channelLine(claude, flag) {
+    if (!claude.permission || claude.channel === 'unknown')
+        return [];
+    const label = 'Permission answers:';
+    if (claude.channel)
+        return [
+            `  ok      ${label} start Claude Code with npx pendingyou claude, and a prompt’s card has Allow and Deny`,
+        ];
+    const version = claude.claude ? claudeVersion(claude.claude) : null;
+    if (!version || !atLeast(version, CHANNEL_CLAUDE))
+        return [
+            `          ${label} Allow and Deny on a prompt’s card need Claude Code ${CHANNEL_CLAUDE} or later${version ? ` (this is ${version})` : ''}`,
+        ];
+    return [
+        `  missing ${label} no Allow or Deny on a prompt’s card; run npx pendingyou@latest init${flag}`,
+    ];
+}
 function presenceLine(claude, connected, mod, flag) {
     const label = 'Presence:';
     if (!connected)
@@ -338,7 +356,7 @@ async function claudeStatus(io, ctx) {
         ? [
             `  ok      Plugin: ${plugin} is enabled${pluginServer ? '' : mcp !== false && mcp !== 'unknown' ? '; Claude Code uses the server added by hand instead of its own' : ''}`,
         ]
-        : []), `  ${mark(skillOk)} Skill: ${skillText}`, `  ${mark(claude.hooks && hooksRun)} Hooks: ${claude.hooks ? `session-start pickup and next-message hand-off; ${formText}` : `not installed; run npx pendingyou init${flag}`}`, `  ${mark(claude.stopcheck)} Stop check: ${claude.stopcheck ? 'asks Claude Code to post what it leaves you in chat' : `not installed; run npx pendingyou init${flag}`}`, `  ${mark(modOk)} Wake mod: ${modText}`, permissionLine(io, claude, manifest, helper, flag), presenceLine(claude, helper && connected, modOk, flag));
+        : []), `  ${mark(skillOk)} Skill: ${skillText}`, `  ${mark(claude.hooks && hooksRun)} Hooks: ${claude.hooks ? `session-start pickup and next-message hand-off; ${formText}` : `not installed; run npx pendingyou init${flag}`}`, `  ${mark(claude.stopcheck)} Stop check: ${claude.stopcheck ? 'asks Claude Code to post what it leaves you in chat' : `not installed; run npx pendingyou init${flag}`}`, `  ${mark(modOk)} Wake mod: ${modText}`, permissionLine(io, claude, manifest, helper, flag), ...channelLine(claude, flag), presenceLine(claude, helper && connected, modOk, flag));
     const setup = setupStatus(NAME, signIn.state === 'ok' ? setupOf(signIn.for) : null);
     if (setup)
         lines.push(`  ${setup === 'finished' ? 'ok     ' : '       '} Setup: ${setup}`);

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;
@@ -84,6 +85,9 @@ const COMMANDS = new Set([
     'herdr',
     'machine',
     'app',
+    'channel',
+    'claude',
+    'codex-answers',
 ]);
 const FLAGS = {
     help: {},
@@ -139,6 +143,9 @@ const FLAGS = {
     refresh: { origin: true, force: false, app: true },
     'mcp-headers': { origin: true, check: false, app: true },
     mcp: { origin: true, app: true, check: false },
+    channel: { origin: true, app: true },
+    claude: {},
+    'codex-answers': { origin: true, wait: true },
     herdr: {
         origin: true,
         app: true,
@@ -233,6 +240,8 @@ export function parseArgs(argv, env = {}) {
         return { name: 'version' };
     if (!COMMANDS.has(first))
         throw new UsageError(`There’s no “${first}” command.`);
+    if (first === 'claude')
+        return { name: 'claude', args: [...after] };
     const rest = [...leading, ...after];
     const allowed = FLAGS[first] ?? {};
     const flags = new Map();
@@ -425,6 +434,9 @@ export function parseArgs(argv, env = {}) {
         case 'mcp':
             none();
             return { name: 'mcp', origin, ...app(), check: flags.has('check') };
+        case 'channel':
+            none();
+            return { name: 'channel', origin, ...app() };
         case 'herdr':
             return herdrCommand(origin, positional, flags, app);
         case 'machine':
@@ -445,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])
@@ -662,6 +681,14 @@ export const USAGE = `pendingyou: Pending You for your coding agents (Claude Cod
   npx pendingyou status        What's set up for each agent, and whether it hears answers right away
   npx pendingyou login [--app <app>] | logout
                                Sign an agent in again (Claude Code's when none is named), or out
+  npx pendingyou claude [args…]
+                               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/channel.js

@@ -0,0 +1,276 @@
+import { DEFAULT_APP } from "./apps/ids.js";
+import { McpFailure, mcpClient, SIGN_IN_ERROR } from "./bridge.js";
+import { ALLOW, answeredOnCard, computerOf, DENY, promptWords, RELAY_MATCH_MS, recordRelay, relayedPrompt, } from "./permission.js";
+import { cut, maskSecrets, redactText } from "./redact.js";
+import { VERSION } from "./version.js";
+export const CHANNEL = 'pendingyou-permissions';
+export const CHANNEL_CLAUDE = '2.1.234';
+export const READ_MS = 2000;
+export const READ_FOR_MS = 30 * 60_000;
+export const SLOW_READ_MS = 30_000;
+const MATCH_STEP_MS = 500;
+const CALL_MS = 15_000;
+const INPUT_MAX = 40_000;
+const LINES_MAX = 400;
+const REQUEST_ID = /^[a-km-z]{5}$/;
+const UNSERIALIZABLE = '(value unserializable)';
+const NO_DESCRIPTION = 'Run shell command';
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const INSTRUCTIONS = 'Pending You’s permission channel: it puts Claude Code’s permission prompts on the person’s Pending You card, with Allow and Deny. It sends you no messages and has no tools; ignore it.';
+export function inputLines(tool, preview) {
+    let parsed = null;
+    try {
+        parsed = JSON.parse(preview);
+    }
+    catch { }
+    const input = isObject(parsed) ? parsed : {};
+    let lines;
+    let lang = 'text';
+    if (isObject(parsed) &&
+        (tool === 'Bash' || tool === 'PowerShell') &&
+        typeof parsed.command === 'string') {
+        lines = maskSecrets(parsed.command).split('\n');
+        lang = 'shell';
+    }
+    else if (isObject(parsed))
+        lines = Object.entries(parsed).flatMap(([key, value]) => maskSecrets(`${key}: ${typeof value === 'string' ? value : JSON.stringify(value)}`).split('\n'));
+    else
+        lines = maskSecrets(preview).split('\n');
+    const kept = [];
+    let size = 0;
+    for (const line of lines) {
+        if (kept.length >= LINES_MAX || size + line.length > INPUT_MAX) {
+            kept.push('… (cut here: the rest is in Claude Code’s dialog)');
+            break;
+        }
+        kept.push(line);
+        size += line.length;
+    }
+    return { lines: kept.length ? kept : [''], lang, input };
+}
+export function heardOf(io, params) {
+    if (!isObject(params))
+        return null;
+    const { request_id: id, tool_name: tool, description, input_preview: preview } = params;
+    if (typeof id !== 'string' || !REQUEST_ID.test(id))
+        return null;
+    if (typeof tool !== 'string' || !tool || tool.length > 200)
+        return null;
+    const text = typeof preview === 'string' ? preview : '';
+    const said = typeof description === 'string' ? description.trim() : '';
+    const shown = inputLines(tool, text);
+    return {
+        tool,
+        words: promptWords(tool, shown.input, io.home),
+        relay: {
+            id,
+            at: io.now(),
+            description: said && said !== NO_DESCRIPTION ? redactText(said, 160) : '',
+            lines: shown.lines,
+            lang: shown.lang,
+            ...(text.includes(UNSERIALIZABLE) ? { unserializable: true } : {}),
+        },
+    };
+}
+export function verdictOf(card, relay) {
+    if (!['answered', 'resolved'].includes(String(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 null;
+    if (picked[0] === DENY)
+        return 'deny';
+    if (picked[0] === ALLOW && !relay.unserializable)
+        return 'allow';
+    return null;
+}
+export async function channel(io, options) {
+    const app = options.app ?? DEFAULT_APP;
+    const controller = new AbortController();
+    const stop = () => controller.abort();
+    if (io.signal.aborted)
+        stop();
+    io.signal.addEventListener('abort', stop, { once: true });
+    const write = (message) => io.out(`${JSON.stringify({ jsonrpc: '2.0', ...message })}\n`);
+    const session = /^[A-Za-z0-9][A-Za-z0-9_-]{0,99}$/.test(io.env.CLAUDE_CODE_SESSION_ID ?? '')
+        ? io.env.CLAUDE_CODE_SESSION_ID
+        : null;
+    const cwd = io.env.CLAUDE_PROJECT_DIR || io.cwd;
+    const following = new Set();
+    const lines = io.lines()[Symbol.asyncIterator]();
+    const stopped = new Promise((resolve) => {
+        const done = () => resolve({ done: true, value: undefined });
+        if (controller.signal.aborted)
+            done();
+        else
+            controller.signal.addEventListener('abort', done, { once: true });
+    });
+    let client = null;
+    const pending = {
+        async call(name, args) {
+            try {
+                client ??= await mcpClient(io, options.origin, 'claude-code', CALL_MS);
+                return await client.call(name, args);
+            }
+            catch (error) {
+                if (error instanceof McpFailure)
+                    client = null;
+                throw error;
+            }
+        },
+    };
+    try {
+        for (;;) {
+            const next = await Promise.race([lines.next(), stopped]);
+            if (next.done)
+                break;
+            let message;
+            try {
+                message = JSON.parse(next.value);
+            }
+            catch {
+                continue;
+            }
+            if (!isObject(message) || typeof message.method !== 'string')
+                continue;
+            const id = message.id;
+            const asked = typeof id === 'string' || typeof id === 'number';
+            switch (message.method) {
+                case 'initialize': {
+                    const params = isObject(message.params) ? message.params : {};
+                    if (asked)
+                        write({
+                            id,
+                            result: {
+                                protocolVersion: typeof params.protocolVersion === 'string'
+                                    ? params.protocolVersion
+                                    : '2025-06-18',
+                                capabilities: {
+                                    experimental: { 'claude/channel': {}, 'claude/channel/permission': {} },
+                                },
+                                serverInfo: { name: CHANNEL, version: VERSION },
+                                instructions: INSTRUCTIONS,
+                            },
+                        });
+                    break;
+                }
+                case 'ping':
+                    if (asked)
+                        write({ id, result: {} });
+                    break;
+                case 'tools/list':
+                    if (asked)
+                        write({ id, result: { tools: [] } });
+                    break;
+                case 'notifications/claude/channel/permission_request': {
+                    if (app !== 'claude-code')
+                        break;
+                    const heard = heardOf(io, message.params);
+                    if (!heard)
+                        break;
+                    const task = follow(io, options.origin, heard, {
+                        session,
+                        cwd,
+                        signal: controller.signal,
+                        pending,
+                        verdict: (behavior) => write({
+                            method: 'notifications/claude/channel/permission',
+                            params: { request_id: heard.relay.id, behavior },
+                        }),
+                    }).catch(() => { });
+                    following.add(task);
+                    task.then(() => following.delete(task));
+                    break;
+                }
+                default:
+                    if (asked)
+                        write({ id, error: { code: -32601, message: 'Method not found' } });
+            }
+        }
+    }
+    finally {
+        controller.abort();
+        io.signal.removeEventListener('abort', stop);
+        lines.return?.().catch(() => undefined);
+        await Promise.allSettled([...following]);
+        await client?.close().catch(() => { });
+    }
+    await io.flush();
+    return 0;
+}
+async function follow(io, origin, heard, options) {
+    const { signal } = options;
+    const id = heard.relay.id;
+    let where = null;
+    const waitFrom = io.now();
+    for (;;) {
+        const last = io.now() - waitFrom >= RELAY_MATCH_MS;
+        where = await recordRelay(io, origin, heard, {
+            session: options.session,
+            cwd: options.cwd,
+            last,
+        });
+        if (where || last || signal.aborted)
+            break;
+        await io.sleep(MATCH_STEP_MS, signal);
+    }
+    if (!where)
+        return;
+    const started = io.now();
+    while (!signal.aborted) {
+        await io.sleep(io.now() - started < READ_FOR_MS ? READ_MS : SLOW_READ_MS, signal);
+        if (signal.aborted)
+            return;
+        const now = await relayedPrompt(io, where, id);
+        if (!now)
+            return;
+        const card = now.prompt.card;
+        if (!card)
+            continue;
+        let read;
+        try {
+            read = await options.pending.call('get_request', {
+                requestId: card.requestId,
+                name: card.name,
+            });
+        }
+        catch (error) {
+            if (error instanceof McpFailure && error.code === SIGN_IN_ERROR)
+                return;
+            continue;
+        }
+        const status = String(read.status);
+        if (['pending', 'snoozed', 'delegated'].includes(status))
+            continue;
+        const verdict = verdictOf(read, heard.relay);
+        if (!verdict) {
+            if (status === 'answered' && typeof read.version === 'number') {
+                const machine = await computerOf(io, origin, 'claude-code');
+                await options.pending
+                    .call('ack_answer', {
+                    requestId: card.requestId,
+                    name: card.name,
+                    expectedVersion: read.version,
+                    outcome: cut(`Not allowed or denied: it waits for your answer in Claude Code on ${machine}.`, 200),
+                })
+                    .catch(() => { });
+            }
+            return;
+        }
+        options.verdict(verdict);
+        await answeredOnCard(io, where, id);
+        if (status === 'answered' && typeof read.version === 'number') {
+            const machine = await computerOf(io, origin, 'claude-code');
+            await options.pending
+                .call('ack_answer', {
+                requestId: card.requestId,
+                name: card.name,
+                expectedVersion: read.version,
+                outcome: cut(`${verdict === 'allow' ? 'Allowed' : 'Denied'} in Claude Code on ${machine}.`, 200),
+            })
+                .catch(() => { });
+        }
+        return;
+    }
+}