pendingyou 0.32.2 → 0.33.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 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
+  Pending You's `post_request` requires, so every post was refused, retried, and given up without a word: a prompt
+  left waiting in the terminal never reached the queue. The card now carries a `context` with only what it already
+  says (the prompt, as its title says it, and the session's link). The tests' pretend Pending You checks every
+  `post_request` and `update_request` with Pending You's own input schemas, so a card the server would refuse fails
+  them.
+
 ## 0.32.2 (2026-10-08)
 
 - A Claude Code dialog in bypassPermissions or dontAsk mode always gets its card. A subagent's `rm -rf $S/*` met Claude

package/README.md

@@ -274,6 +274,21 @@ 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.
+
 ## 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 +516,7 @@ 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 |
 | `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/args.js

@@ -84,6 +84,8 @@ const COMMANDS = new Set([
     'herdr',
     'machine',
     'app',
+    'channel',
+    'claude',
 ]);
 const FLAGS = {
     help: {},
@@ -139,6 +141,8 @@ 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: {},
     herdr: {
         origin: true,
         app: true,
@@ -233,6 +237,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 +431,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':
@@ -662,6 +671,10 @@ 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 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;
+    }
+}

package/dist/claude.js

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import { rm, rmdir, stat } from 'node:fs/promises';
 import { basename, dirname, join } from 'node:path';
 import { DEFAULT_ORIGIN } from "./args.js";
+import { CHANNEL, CHANNEL_CLAUDE } from "./channel.js";
 import { PlainError } from "./errors.js";
 import { claudeDir, configDir, readJson, readText, writeWhole } from "./files.js";
 import { findHook, hooksOf, mergeHooks, originArgs, removeHooks } from "./hooks.js";
@@ -11,7 +12,7 @@ import { atLeast, claudeVersion, isOurModDir, loadsMods, modDir, PLUGIN_DIRS, pl
 import { removePermissionFiles } from "./permission.js";
 import { removePresenceFiles } from "./presence.js";
 import { helperPath } from "./remote.js";
-import { readShim, SHIM } from "./shim.js";
+import { readShim, SHIM, shimPath } from "./shim.js";
 import { VERSION } from "./version.js";
 export { isOurHook } from "./hooks.js";
 export const MCP_NAME = 'pendingyou';
@@ -192,6 +193,105 @@ export function helperServer(url, command) {
         text: `claude mcp add-json --scope user ${MCP_NAME} ${quote(json)}`,
     };
 }
+export function channelEntry(io, origin) {
+    return {
+        type: 'stdio',
+        command: shimPath(io),
+        args: [
+            'channel',
+            '--app',
+            'claude-code',
+            ...(origin === DEFAULT_ORIGIN ? [] : ['--origin', origin]),
+        ],
+    };
+}
+export async function channelFromFile(io) {
+    let parsed;
+    try {
+        const text = await readText(claudeJsonPath(io));
+        if (text === null)
+            return 'unknown';
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return 'unknown';
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+        return 'unknown';
+    const servers = objectAt(parsed, 'mcpServers');
+    return servers ? objectAt(servers, CHANNEL) : null;
+}
+const sameEntry = (entry, wanted) => entry.command === wanted.command && JSON.stringify(entry.args) === JSON.stringify(wanted.args);
+async function applyChannel(io, origin, wanted, before, progress) {
+    const entry = channelEntry(io, origin);
+    const now = await channelFromFile(io);
+    const remove = () => io.run('claude', ['mcp', 'remove', '--scope', 'user', CHANNEL], MCP_TIMEOUT_MS);
+    if (!wanted) {
+        if (!before?.channel || now === null)
+            return { step: null, registered: false };
+        progress('Removing the permission channel from Claude Code (this can take a minute)…\n');
+        const removed = await remove();
+        return removed.code === 0
+            ? {
+                step: { ok: true, text: `Took out the permission channel (${CHANNEL}).` },
+                registered: false,
+            }
+            : {
+                step: {
+                    ok: false,
+                    text: `Couldn’t take out the permission channel. Run: claude mcp remove --scope user ${CHANNEL}`,
+                },
+                registered: true,
+            };
+    }
+    if (now !== null && now !== 'unknown' && sameEntry(now, entry))
+        return {
+            step: { ok: true, text: 'The permission channel was already registered.' },
+            registered: true,
+        };
+    const json = JSON.stringify(entry);
+    const add = `claude mcp add-json --scope user ${CHANNEL} ${quote(json)}`;
+    if (now !== null && now !== 'unknown') {
+        progress('Updating the permission channel in Claude Code (this can take a minute)…\n');
+        if ((await remove()).code !== 0)
+            return {
+                step: {
+                    ok: false,
+                    text: `Couldn’t update the permission channel. Run:\n  claude mcp remove --scope user ${CHANNEL}\n    ${add}`,
+                },
+                registered: false,
+            };
+    }
+    else
+        progress('Adding the permission channel to Claude Code (this can take a minute)…\n');
+    const added = await io.run('claude', ['mcp', 'add-json', '--scope', 'user', CHANNEL, json], MCP_TIMEOUT_MS);
+    if (added.code !== 0)
+        return {
+            step: { ok: false, text: `Claude Code didn’t add the permission channel. Run: ${add}` },
+            registered: false,
+        };
+    return {
+        step: {
+            ok: true,
+            text: `Added the permission channel (${CHANNEL}): start Claude Code with npx pendingyou claude and a prompt’s card has Allow and Deny. The first answer wins, there or in the terminal.`,
+        },
+        registered: true,
+    };
+}
+export async function claudeWithChannel(io, args) {
+    if (!io.handOver)
+        throw new PlainError('This can’t start Claude Code here.');
+    if ((await channelFromFile(io)) === null)
+        io.err('pendingyou: the permission channel isn’t set up, so Claude Code’s prompts get no Allow or Deny on their cards. Run: npx pendingyou@latest init\n');
+    const code = await io.handOver('claude', [
+        '--dangerously-load-development-channels',
+        `server:${CHANNEL}`,
+        ...args,
+    ]);
+    if (code === 127)
+        io.err('pendingyou: Claude Code isn’t installed here (no claude on PATH).\n');
+    return code;
+}
 async function applyMcp(io, origin, plan, helper, progress) {
     const url = `${origin}/mcp`;
     const add = helper
@@ -363,6 +463,10 @@ export async function installClaude(io, origin, options) {
                 ? `${merged.permissionChanged ? 'Took out the permission-prompt hooks' : 'Left out the permission-prompt hooks'}, as you asked: no card when Claude Code waits for your OK. To turn them on: npx pendingyou init --permission-cards${flag}`
                 : `${merged.permissionChanged ? 'Took out' : 'Left out'} the permission-prompt hooks: ${blocker}.`,
     });
+    const found = claudeVersion(options.version);
+    const channel = await applyChannel(io, origin, Boolean(permissionLines) && found !== null && atLeast(found, CHANNEL_CLAUDE), before, options.progress);
+    if (channel.step)
+        report(channel.step);
     const mod = await addMod(io, merged.settings, options.copy, options.version);
     if (mod.step)
         report(mod.step);
@@ -387,6 +491,7 @@ export async function installClaude(io, origin, options) {
         ...(options.plugin ? { plugin: true } : {}),
         permissionHooks: permissionLines,
         permissionCards: wanted,
+        ...(channel.registered ? { channel: true } : {}),
     };
     await writeWhole(manifestPath(io), `${JSON.stringify(manifest, null, 2)}\n`, { secret: true });
     return steps;
@@ -458,6 +563,16 @@ export async function uninstallClaude(io) {
     const skill = await removeSkill(manifest?.skill ?? null);
     if (skill)
         steps.push(skill);
+    if (manifest?.channel && (await channelFromFile(io)) !== null) {
+        io.out('Removing the permission channel from Claude Code (this can take a minute)…\n');
+        const result = await io.run('claude', ['mcp', 'remove', '--scope', 'user', CHANNEL], MCP_TIMEOUT_MS);
+        steps.push(result.code === 0
+            ? { ok: true, text: `Removed the permission channel (${CHANNEL}) from Claude Code.` }
+            : {
+                ok: false,
+                text: `Couldn’t remove the permission channel. Run: claude mcp remove --scope user ${CHANNEL}`,
+            });
+    }
     if (manifest?.mcpAdded) {
         io.out('Removing the pendingyou MCP server from Claude Code (this can take a minute)…\n');
         const result = await io.run('claude', ['mcp', 'remove', '--scope', 'user', MCP_NAME], MCP_TIMEOUT_MS);
@@ -523,6 +638,7 @@ export async function claudeState(io) {
         permission,
         notify,
         presence: Boolean(ours('SessionEnd')),
+        channel: await channelFromFile(io).then((entry) => entry === 'unknown' ? 'unknown' : entry !== null),
         form: form ? { ...form, runs: await hookRuns(form), shim } : null,
         mod,
         plugins,

package/dist/io.js

@@ -68,6 +68,29 @@ export function execProgram(command, args, options) {
         child.stdin?.end(options.stdin);
     });
 }
+let handedTo = null;
+function handOver(command, args) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = spawn(command, [...args], { stdio: 'inherit' });
+        }
+        catch {
+            resolve(127);
+            return;
+        }
+        handedTo = (signal) => {
+            if (signal !== 'SIGINT')
+                child.kill(signal);
+        };
+        const done = (code) => {
+            handedTo = null;
+            resolve(code);
+        };
+        child.on('error', (error) => done(error.code === 'ENOENT' ? 127 : 1));
+        child.on('exit', (code, signal) => done(code ?? (signal === 'SIGINT' ? 130 : signal === 'SIGTERM' ? 143 : 1)));
+    });
+}
 export function sleep(ms, signal) {
     return new Promise((resolve) => {
         if (signal?.aborted || ms <= 0) {
@@ -232,6 +255,8 @@ export function realIo() {
     const controller = new AbortController();
     for (const name of ['SIGINT', 'SIGTERM', 'SIGHUP'])
         process.on(name, () => {
+            if (handedTo)
+                return handedTo(name);
             if (controller.signal.aborted)
                 process.exit(130);
             controller.abort();
@@ -250,6 +275,7 @@ export function realIo() {
         ask,
         run: runProgram,
         exec: execProgram,
+        handOver,
         openBrowser,
         readStdin,
         lines: () => lines(controller.signal, () => controller.abort()),

package/dist/main.js

@@ -4,6 +4,8 @@ import { DEFAULT_APP } from "./apps/ids.js";
 import { appModule } from "./apps/registry.js";
 import { commandOf, HOOK_COMMANDS, parseArgs, USAGE, UsageError } from "./args.js";
 import { bridge } from "./bridge.js";
+import { channel } from "./channel.js";
+import { claudeWithChannel } from "./claude.js";
 import { PlainError } from "./errors.js";
 import { hold } from "./hold.js";
 import { init, status, uninstall } from "./init.js";
@@ -93,6 +95,10 @@ async function run(io, command, hook = { fallback: '' }) {
             return mcpHeaders(io, command);
         case 'mcp':
             return bridge(io, command);
+        case 'channel':
+            return channel(io, command);
+        case 'claude':
+            return claudeWithChannel(io, command.args);
         case 'herdr':
             return (await import("./herdr/command.js")).herdr(io, command);
         case 'machine':

package/dist/permission.js

@@ -7,8 +7,8 @@ import { DEFAULT_ORIGIN } from "./args.js";
 import { McpFailure, mcpClient, SIGN_IN_ERROR, ToolRefused } from "./bridge.js";
 import { sessionLink } from "./confirm.js";
 import { connectionMachine, readCredential } from "./credentials.js";
-import { configDir, PERMISSION_FOLDER, readJson, withLock, writeWhole } from "./files.js";
-import { cut, redactCommand, redactText, redactUrl, shortPath } from "./redact.js";
+import { claudeDir, configDir, PERMISSION_FOLDER, readJson, withLock, writeWhole } from "./files.js";
+import { BLANK, cut, redactCommand, redactText, redactUrl, shortPath } from "./redact.js";
 import { machineOf } from "./remote.js";
 export const GRACE_MS = 10_000;
 export const TITLE_MAX = 90;
@@ -24,7 +24,9 @@ export const isPromptApp = (app) => PROMPT_APPS.includes(app);
 export const waitingFor = (app) => `${APP_NAMES[app]} is waiting for your OK`;
 export const isPermissionCard = (title) => typeof title === 'string' &&
     PROMPT_APPS.some((app) => title.startsWith(waitingFor(app)) ||
-        title.startsWith(`${APP_NAMES[app]} is waiting for your answer`));
+        title.startsWith(`${APP_NAMES[app]} is waiting for your answer`) ||
+        title.startsWith(`Allow ${APP_NAMES[app]} `) ||
+        title.startsWith(`Allow a subagent of ${APP_NAMES[app]}`));
 export const DEFAULT_NAME = 'Claude Code';
 const defaultName = (app) => APP_NAMES[app];
 const LEASE_STALE_MS = 120_000;
@@ -172,7 +174,10 @@ async function change(io, session, edit) {
     });
 }
 const alive = (state, now) => Boolean(state.worker && now - state.worker.at < LEASE_STALE_MS);
-const seen = (prompt) => !prompt.quiet || prompt.shown !== undefined || prompt.waited !== undefined;
+const seen = (prompt) => !prompt.quiet ||
+    prompt.shown !== undefined ||
+    prompt.waited !== undefined ||
+    prompt.relay !== undefined;
 const unchecked = (prompt) => !seen(prompt) && !prompt.notice;
 function claim(state, now) {
     if (alive(state, now))
@@ -217,6 +222,27 @@ function reasonOf(app, input) {
     return reason || null;
 }
 const wentOn = (agent, now) => (prompt) => Boolean(prompt.quiet) && (prompt.agent ?? '') === agent && prompt.at <= now - BATCH_MS;
+function closeCards(state, settled, how) {
+    const cards = settled.flatMap((prompt) => (prompt.card ? [{ ...prompt.card, how }] : []));
+    if (cards.length)
+        state.closing = [...(state.closing ?? []), ...cards];
+}
+function keepNewest(state) {
+    closeCards(state, state.prompts.slice(0, -MAX_PROMPTS), 'answered');
+    state.prompts = state.prompts.slice(-MAX_PROMPTS);
+}
+const ADOPT_MS = 30_000;
+function adopt(state, prompt) {
+    const own = state.prompts.find((each) => each.relay?.own &&
+        each.tool === prompt.tool &&
+        Math.abs(prompt.at - each.relay.at) <= ADOPT_MS);
+    if (!own?.relay)
+        return false;
+    const { at: _at, quiet: _quiet, ...hook } = prompt;
+    Object.assign(own, hook);
+    delete own.relay.own;
+    return true;
+}
 async function asked(io, origin, input, app) {
     if (io.platform === 'win32')
         return;
@@ -273,10 +299,12 @@ async function asked(io, origin, input, app) {
         const kept = app === 'claude-code'
             ? next.prompts.filter((each) => !wentOn(agent, now)(each))
             : next.prompts;
+        closeCards(next, next.prompts.filter((each) => !kept.includes(each)), 'answered');
         next.prompts = kept;
-        if (!next.prompts.some((each) => each.key === prompt.key))
+        const adopted = app === 'claude-code' ? adopt(next, prompt) : false;
+        if (!adopted && !next.prompts.some((each) => each.key === prompt.key))
             next.prompts.push(prompt);
-        next.prompts = next.prompts.slice(-MAX_PROMPTS);
+        keepNewest(next);
         delete next.settled;
         next.at = now;
         worker = claim(next, now);
@@ -299,10 +327,11 @@ async function settle(io, session, which, how) {
         const left = state.prompts.filter((prompt) => !which(prompt));
         if (left.length === state.prompts.length)
             return state;
+        closeCards(state, state.prompts.filter((prompt) => !left.includes(prompt)), how);
         state.prompts = left;
         state.settled = how;
         state.at = now;
-        if (!state.card && left.length === 0)
+        if (!state.card && !state.closing?.length && left.length === 0)
             return alive(state, now) ? state : null;
         worker = claim(state, now);
         return state;
@@ -322,7 +351,11 @@ async function ran(io, input, app) {
         return;
     const exact = before.prompts.some((prompt) => prompt.key === key);
     const movedOn = wentOn(agent, io.now());
-    await settle(io, where.session, (prompt) => prompt.key === key || (app === 'codex' ? !exact && prompt.tool === tool : movedOn(prompt)), 'answered');
+    await settle(io, where.session, (prompt) => prompt.key === key ||
+        (app === 'codex'
+            ? !exact && prompt.tool === tool
+            : movedOn(prompt) ||
+                (!exact && Boolean(prompt.relay?.own) && prompt.tool === tool && !agent)), 'answered');
 }
 export async function endPrompts(io, session) {
     try {
@@ -447,7 +480,7 @@ export async function permissionHook(io, options) {
 const dueOf = (prompt, grace) => Math.min(prompt.quiet ? (prompt.waited ?? Number.POSITIVE_INFINITY) : prompt.at + grace, prompt.shown ?? Number.POSITIVE_INFINITY);
 const shownOf = (prompts) => (prompts.filter((prompt) => !prompt.notice).at(-1) ?? prompts.at(-1));
 export function planFor(state, now, grace, quietGrace = QUIET_GRACE_MS) {
-    const plan = cardPlan(state, now, grace);
+    const plan = relayPlan(state, now, grace, cardPlan(state, now, grace));
     const pending = state.prompts.filter(unchecked);
     if (pending.length === 0)
         return plan;
@@ -460,8 +493,26 @@ export function planFor(state, now, grace, quietGrace = QUIET_GRACE_MS) {
         return { kind: 'wait', ms: Math.min(plan.ms, check) };
     return plan;
 }
+function relayPlan(state, now, grace, then) {
+    const closing = state.closing?.[0];
+    if (closing)
+        return { kind: 'close', card: closing };
+    const waiting = state.prompts.filter((prompt) => prompt.relay && !prompt.card && !prompt.failed);
+    if (waiting.length === 0)
+        return then;
+    const dueAt = (prompt) => Math.min(Math.min(prompt.at, prompt.relay.at) + grace, prompt.shown ?? Number.POSITIVE_INFINITY);
+    const first = waiting.reduce((soonest, prompt) => dueAt(prompt) < dueAt(soonest) ? prompt : soonest);
+    const due = dueAt(first) - now;
+    if (due <= 0)
+        return { kind: 'relay', prompt: first };
+    if (then.kind === 'done')
+        return { kind: 'wait', ms: due };
+    if (then.kind === 'wait')
+        return { kind: 'wait', ms: Math.min(then.ms, due) };
+    return then;
+}
 function cardPlan(state, now, grace) {
-    const prompts = state.prompts.filter(seen);
+    const prompts = state.prompts.filter((prompt) => seen(prompt) && !prompt.relay);
     if (prompts.length === 0)
         return state.card ? { kind: 'cancel' } : { kind: 'done' };
     if (state.card) {
@@ -481,7 +532,7 @@ function graceOf(env) {
     const given = Number(env.PENDINGYOU_PERMISSION_GRACE_MS);
     return Number.isInteger(given) && given >= 0 ? given : GRACE_MS;
 }
-async function computerOf(io, origin, app) {
+export async function computerOf(io, origin, app) {
     const named = await connectionMachine(io, origin, app).catch(() => null);
     return cut(named ?? (machineOf(io.host) || 'this computer'), 60);
 }
@@ -835,6 +886,16 @@ function cardWords(io, state, prompt, name, machine) {
         },
     };
 }
+function contextOf(state, prompt) {
+    const app = appOf(state);
+    return {
+        background: `${APP_NAMES[app]} asked in its terminal; this card stands in for that dialog.`,
+        trace: [{ state: 'paused', text: prompt.title }],
+        filesTouched: [],
+        tried: [],
+        links: state.link ? [{ label: `The ${APP_NAMES[app]} session`, url: state.link }] : [],
+    };
+}
 async function record(io, session, worker, edit) {
     let ours = false;
     await change(io, session, (state) => {
@@ -859,9 +920,11 @@ async function post(io, client, state, prompt, worker) {
         kind: 'action',
         title: prompt.title,
         ...cardWords(io, state, prompt, name, machine),
+        context: contextOf(state, prompt),
         blocking: false,
         urgency: 'now',
         askedFirst: { where: 'terminal', askedAt: new Date(prompt.at).toISOString() },
+        permissionPrompt: { app: appOf(state), relay: false },
     });
     const requestId = idOf(result, 'requestId', 'req_');
     const version = typeof result.version === 'number' ? result.version : 1;
@@ -875,6 +938,89 @@ async function post(io, client, state, prompt, worker) {
     if (!kept)
         await withdraw(io, client, card, state, 'answered').catch(() => { });
 }
+export const ALLOW = 'allow';
+export const DENY = 'deny';
+export const IN_TERMINAL = 'terminal';
+export function relayTitle(state, prompt, name) {
+    const app = appOf(state);
+    const who = name === defaultName(app) ? APP_NAMES[app] : `${APP_NAMES[app]} (${name})`;
+    const subject = byAgent(state, prompt) ? `a subagent of ${who}` : who;
+    const doing = prompt.doing.startsWith('to ')
+        ? prompt.doing
+        : `to use ${toolName(prompt.tool ?? '')}`;
+    return cut(`Allow ${subject} ${doing}?`, TITLE_MAX);
+}
+async function postRelay(io, client, state, prompt, worker) {
+    const relay = prompt.relay;
+    const app = appOf(state);
+    const name = await nameOf(io, state);
+    await client.call('whoami', { name });
+    const areaId = state.areaId ?? (await areaFor(io, client, state, name));
+    const machine = await computerOf(io, state.origin, app);
+    const title = relayTitle(state, prompt, name);
+    const who = name === defaultName(app) ? APP_NAMES[app] : `${APP_NAMES[app]} (${name})`;
+    const where = `in ${tilde(io, state.cwd)} on ${machine}`;
+    const asker = byAgent(state, prompt)
+        ? `A subagent${prompt.agentType ? ` (${prompt.agentType})` : ''} of ${who}, ${where},`
+        : `${who} ${where}`;
+    const wants = prompt.doing.startsWith('to ')
+        ? `wants your OK ${prompt.doing}`
+        : `wants your OK to use ${toolName(prompt.tool ?? '')}`;
+    const why = relay.description ? ` It says: “${relay.description}”.` : '';
+    const answer = relay.unserializable
+        ? `Part of it couldn’t be shown, so only Deny is here; to allow it, answer in ${APP_NAMES[app]} on ${machine}.`
+        : `Allow or Deny here, or answer in ${APP_NAMES[app]} on ${machine}: the first answer wins.`;
+    const session = createHash('sha256').update(state.session).digest('hex').slice(0, 24);
+    const result = await client.call('post_request', {
+        idempotencyKey: `${app}-relay:${session}:${relay.id}:${relay.at}`,
+        areaId,
+        session: { label: name, machine, cwd: cut(tilde(io, state.cwd), 300) },
+        kind: 'choice',
+        intent: 'approve',
+        title,
+        summary: cut(`${asker} ${wants}.${why} ${answer}`, 400),
+        options: relay.unserializable
+            ? [
+                { id: DENY, label: 'Deny' },
+                { id: IN_TERMINAL, label: `I’ll answer in ${APP_NAMES[app]}` },
+            ]
+            : [
+                { id: ALLOW, label: 'Allow', detail: 'This call only. Nothing is allowed after it.' },
+                { id: DENY, label: 'Deny' },
+            ],
+        artifacts: [
+            {
+                kind: 'code',
+                title: prompt.tool === 'Bash' ? 'The command' : `${toolName(prompt.tool ?? '')}’s input`,
+                ref: `permission-${relay.id}`,
+                lang: relay.lang,
+                lines: relay.lines,
+            },
+        ],
+        context: { ...contextOf(state, prompt), trace: [{ state: 'paused', text: title }] },
+        blocking: false,
+        urgency: 'now',
+        askedFirst: { where: 'terminal', askedAt: new Date(prompt.at).toISOString() },
+        permissionPrompt: { app, relay: true },
+    });
+    const requestId = idOf(result, 'requestId', 'req_');
+    const version = typeof result.version === 'number' ? result.version : 1;
+    if (!requestId)
+        throw new McpFailure(-32000, 'Pending You posted no card.');
+    const card = { requestId, version, key: prompt.key, name };
+    const id = promptId(prompt);
+    let kept = false;
+    const ours = await record(io, state.session, worker, (state) => {
+        const now = state.prompts.find((each) => promptId(each) === id && each.relay?.id === relay.id);
+        if (!now)
+            return;
+        now.card = card;
+        state.areaId = areaId;
+        kept = true;
+    });
+    if (!ours || !kept)
+        await withdraw(io, client, card, state, 'answered').catch(() => { });
+}
 async function stillOpen(client, card) {
     const now = await client.call('get_request', { requestId: card.requestId, name: card.name });
     const open = ['pending', 'snoozed', 'delegated'].includes(text(now.status)) && now.turn !== 'agent';
@@ -974,7 +1120,7 @@ async function letGo(io, session, worker, grace) {
             return state;
         }
         delete state.worker;
-        return state.prompts.length === 0 && !state.card ? null : state;
+        return state.prompts.length === 0 && !state.card && !state.closing?.length ? null : state;
     });
     return done;
 }
@@ -1027,6 +1173,17 @@ export async function permissionWorker(io, options) {
                     await post(io, client, state, plan.prompt, worker);
                 else if (plan.kind === 'update')
                     await update(io, client, state, plan.prompt, worker);
+                else if (plan.kind === 'relay')
+                    await postRelay(io, client, state, plan.prompt, worker);
+                else if (plan.kind === 'close') {
+                    const card = plan.card;
+                    await withdraw(io, client, card, state, card.how);
+                    await record(io, session, worker, (state) => {
+                        state.closing = state.closing?.filter((each) => each.requestId !== card.requestId);
+                        if (!state.closing?.length)
+                            delete state.closing;
+                    });
+                }
                 else {
                     const card = state.card;
                     await withdraw(io, client, card, state, state.settled ?? 'answered');
@@ -1046,8 +1203,17 @@ export async function permissionWorker(io, options) {
                 if (failures >= BACKOFF_MS.length) {
                     failures = 0;
                     await record(io, session, worker, (state) => {
-                        if (plan.kind === 'post')
-                            state.prompts = state.prompts.map((prompt) => ({ ...prompt, failed: true }));
+                        if (plan.kind === 'relay') {
+                            const id = promptId(plan.prompt);
+                            state.prompts = state.prompts.map((prompt) => promptId(prompt) === id ? { ...prompt, failed: true } : prompt);
+                        }
+                        else if (plan.kind === 'close') {
+                            state.closing = state.closing?.filter((each) => each.requestId !== plan.card.requestId);
+                            if (!state.closing?.length)
+                                delete state.closing;
+                        }
+                        else if (plan.kind === 'post')
+                            state.prompts = state.prompts.map((prompt) => prompt.relay ? prompt : { ...prompt, failed: true });
                         else if (plan.kind === 'update' && state.card)
                             state.card = { ...state.card, key: plan.prompt.key };
                         else
@@ -1064,6 +1230,123 @@ export async function permissionWorker(io, options) {
         await client?.close().catch(() => { });
     }
 }
+export const RELAY_MATCH_MS = 5000;
+function fit(prompt, heard) {
+    if (prompt.relay || prompt.notice || prompt.tool !== heard.tool)
+        return null;
+    if (Math.abs(prompt.at - heard.relay.at) > RELAY_MATCH_MS)
+        return null;
+    const input = heard.relay.lines.join(' ').replace(/\s+/g, ' ');
+    return prompt.what
+        .split(BLANK)
+        .map((part) => part.replace(/\s+/g, ' ').trim())
+        .filter((part) => part.length >= 3 && input.includes(part)).length;
+}
+function bestFit(prompts, heard) {
+    let best = null;
+    for (const prompt of prompts) {
+        const score = fit(prompt, heard);
+        if (score === null)
+            continue;
+        const apart = Math.abs(prompt.at - heard.relay.at);
+        if (!best ||
+            score > best.score ||
+            (score === best.score && apart < Math.abs(best.prompt.at - heard.relay.at)))
+            best = { prompt, score };
+    }
+    return best?.prompt ?? null;
+}
+async function sessionsFrom(io, first) {
+    const names = await readdir(folderOf(io)).catch(() => []);
+    const others = names
+        .filter((name) => name.endsWith('.json'))
+        .map((name) => name.slice(0, -'.json'.length))
+        .filter((session) => SESSION.test(session) && session !== first);
+    return first ? [first, ...others] : others;
+}
+const transcriptOf = (io, cwd, session) => join(claudeDir(io), 'projects', cwd.replace(/[^A-Za-z0-9]/g, '-'), `${session}.jsonl`);
+export async function recordRelay(io, origin, heard, options) {
+    if (io.platform === 'win32')
+        return null;
+    if ((await readCredential(io, origin, CLAUDE))?.kind !== 'connection')
+        return null;
+    for (const session of await sessionsFrom(io, options.session)) {
+        const before = await load(io, session);
+        if (!before || !bestFit(before.prompts, heard))
+            continue;
+        let worker = null;
+        let matched = false;
+        const state = await change(io, session, (state) => {
+            const prompt = state ? bestFit(state.prompts, heard) : null;
+            if (!state || !prompt)
+                return state;
+            prompt.relay = heard.relay;
+            delete prompt.failed;
+            matched = true;
+            delete state.settled;
+            worker = claim(state, io.now());
+            return state;
+        });
+        if (!matched || !state)
+            continue;
+        if (worker)
+            startWorker(io, state.origin, session, worker);
+        return session;
+    }
+    if (!options.last)
+        return null;
+    const session = options.session ?? `channel-${io.ppid ?? process.pid}`;
+    const now = io.now();
+    const prompt = {
+        key: promptKey(heard.tool, { relay: heard.relay.id }),
+        tool: heard.tool.slice(0, 100),
+        ...heard.words,
+        at: heard.relay.at,
+        relay: { ...heard.relay, own: true },
+    };
+    let worker = null;
+    await change(io, session, (state) => {
+        const next = state ?? {
+            version: 1,
+            origin,
+            session,
+            cwd: options.cwd,
+            ...(options.session ? { transcript: transcriptOf(io, options.cwd, options.session) } : {}),
+            prompts: [],
+            at: now,
+        };
+        if (next.prompts.some((each) => each.relay?.id === heard.relay.id))
+            return next;
+        next.prompts.push(prompt);
+        keepNewest(next);
+        delete next.settled;
+        next.at = now;
+        worker = claim(next, now);
+        return next;
+    });
+    if (worker)
+        startWorker(io, origin, session, worker);
+    return session;
+}
+export async function relayedPrompt(io, session, id) {
+    const state = await load(io, session);
+    const prompt = state?.prompts.find((each) => each.relay?.id === id);
+    return state && prompt ? { state, prompt } : null;
+}
+export async function answeredOnCard(io, session, id) {
+    await change(io, session, (state) => {
+        if (!state)
+            return null;
+        const left = state.prompts.filter((prompt) => prompt.relay?.id !== id);
+        if (left.length === state.prompts.length)
+            return state;
+        state.prompts = left;
+        state.at = io.now();
+        if (left.length === 0 && !state.card && !state.closing?.length && !alive(state, io.now()))
+            return null;
+        return state;
+    });
+}
 export async function removePermissionFiles(io) {
     const folder = folderOf(io);
     const there = await stat(folder).then(() => true, () => false);

package/dist/redact.js

@@ -234,6 +234,12 @@ export function cut(text, max = SUMMARY_MAX) {
 export function redactText(text, max = SUMMARY_MAX) {
     return cut(tidy(redactTokens(redactSchemes(redactHeaders(redactUrls(text))))), max);
 }
+export function maskSecrets(text) {
+    return text
+        .split('\n')
+        .map((line) => redactTokens(redactFlags(redactNamedValues(redactSchemes(redactHeaders(redactUrls(line)))))))
+        .join('\n');
+}
 const INLINE_CODE = /(?:^|[\s;&|(`$/])(?:(?:ba|z|da|k)?sh|fish|python[0-9.]*|node(?:js)?|deno|bun|ruby|perl|php|osascript|pwsh|powershell|lua|Rscript)\b[^;&|]*?\s(?:-c|-e|-E|--eval|-p|--print|-r|-Command|-command|-EncodedCommand)(?=\s|=|$)/i;
 const TAKES_SECRET = /\bsudo\s+(?:-\w+\s+)*-S\b|--password-stdin|\b(?:ch)?passwd\b|\bhtpasswd\b|\bsecurity\s+(?:add|set|import)-|\bsecrets?\s+(?:set|put|add|create|edit)\b|\bvault\s+(?:kv\s+)?(?:put|write)\b|\bkubectl\s+create\s+secret\b|\bop\s+(?:item|read|run|inject)\b|\bssh-add\b|\bgpg\b|\bpass\s+(?:insert|edit)\b|\bbase64\s+(?:-d|-D|--decode)\b/i;
 export function unsafeCommand(command) {

package/dist/version.js

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

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

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

package/mod/README.md

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

package/package.json

@@ -1,9 +1,16 @@
 {
   "name": "pendingyou",
-  "version": "0.32.2",
+  "version": "0.33.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",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/recordplane/pendingyou-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/recordplane/pendingyou-cli/issues"
+  },
   "type": "module",
   "bin": {
     "pendingyou": "dist/cli.js"
@@ -32,6 +39,7 @@
     "prepublishOnly": "pnpm run build && pnpm run test",
     "test": "vitest run",
     "typecheck": "tsc -p tsconfig.json",
-    "sdk": "node scripts/sdk.ts"
+    "sdk": "node scripts/sdk.ts",
+    "sync:repo": "node scripts/sync.ts"
   }
 }