pendingyou 0.13.0 → 0.14.0

package/dist/apps/codex-wake.js

@@ -1,88 +1,79 @@
-// 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 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/<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';
 import { getJson, SignInNeeded, Unavailable } from "../api.js";
 import { DEFAULT_ORIGIN } from "../args.js";
-import { readCredential } from "../credentials.js";
+import { connectionMachine, 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 { clip, delegatedOf, isClosed } from "../format.js";
+import { chooseThread, goesBy, HANDED_FOR_MS, handedCard, handedMessage, namesAnotherComputer, } from "../handed.js";
+import { macName, tailscaleName } from "../remote.js";
+import { claimHanded, markHanded, momentOf, releaseHanded, wasHanded } from "../state.js";
 import { findCodex } from "./codex-app.js";
-/** How long a turn's record, and a thread untouched, are kept. */
+import { APP_IDS } from "./ids.js";
 const KEEP_TURN_MS = 24 * 60 * 60_000;
 const KEEP_THREAD_MS = 7 * 24 * 60 * 60_000;
-/** The most of one card's words a turn keeps, to match an ask against (stopcheck.ts). */
 const CARD_WORDS = 20_000;
-/** How long a listener waits on one thread, at most, and how often it renews its lease. */
 export const LISTEN_MS = 8 * 60 * 60_000;
 const LONG_POLL_SECONDS = 25;
-/** A lease untouched for this long belongs to a listener that died. */
 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}$/;
-/** 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 HANDED = '_handed';
+const NAMES = 5;
+const MCP_CARD_TOOL = /^mcp__([A-Za-z0-9_]*pendingyou[A-Za-z0-9_]*)__(post_request|update_request|reply_in_thread|cancel_request|answer_delegated|hand_back)$/i;
 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,
+    opencode: /^([A-Za-z0-9_-]*pendingyou[A-Za-z0-9_-]*)_(post_request|update_request|reply_in_thread|cancel_request|answer_delegated|hand_back)$/i,
     pi: MCP_CARD_TOOL,
 };
-/** The card tool a call was, for an app whose hooks read them; null for any other tool. */
+const HELPER_CALLS = new Set(['answer_delegated', 'hand_back']);
 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);
+function threadOf(value) {
+    if (!isObject(value) || typeof value.at !== 'number' || !Number.isFinite(value.at))
+        return null;
+    const names = Array.isArray(value.names)
+        ? value.names.filter((name) => typeof name === 'string' && name.trim() !== '')
+        : [];
+    return {
+        origin: typeof value.origin === 'string' ? value.origin : DEFAULT_ORIGIN,
+        cards: isObject(value.cards) ? value.cards : {},
+        at: value.at,
+        ...(names.length ? { names: names.slice(-NAMES) } : {}),
+        ...(typeof value.cwd === 'string' && value.cwd ? { cwd: value.cwd } : {}),
+    };
+}
 async function load(io, app) {
     const file = await readJson(statePath(io, app)).catch(() => null);
+    const threads = {};
+    if (isObject(file?.threads))
+        for (const [id, value] of Object.entries(file.threads)) {
+            const thread = threadOf(value);
+            if (thread)
+                threads[id] = thread;
+        }
     return {
         version: 1,
-        threads: isObject(file?.threads) ? file.threads : {},
+        threads,
         turns: isObject(file?.turns) ? file.turns : {},
     };
 }
-/** Changes the state under its lock, dropping what's old. */
+const mayBeHanded = (thread, now) => Boolean(thread.names?.length) && now - thread.at < HANDED_FOR_MS;
+const listenable = (thread, now) => thread !== undefined && (Object.keys(thread.cards).length > 0 || mayBeHanded(thread, now));
 async function change(io, app, edit) {
     const path = statePath(io, app);
     return withLock(path, io, async () => {
@@ -93,13 +84,12 @@ async function change(io, app, edit) {
             if (!(now - turn.at < KEEP_TURN_MS))
                 delete state.turns[id];
         for (const [id, thread] of Object.entries(state.threads))
-            if (!(now - thread.at < KEEP_THREAD_MS) || Object.keys(thread.cards).length === 0)
+            if (!(now - thread.at < KEEP_THREAD_MS) || !listenable(thread, now))
                 delete state.threads[id];
         await writeWhole(path, `${JSON.stringify(state, null, 2)}\n`, { secret: true });
         return state;
     });
 }
-/** A tool's answer as Codex hands it to PostToolUse (a CallToolResult): its JSON object, or null. */
 export function resultOf(response) {
     if (!isObject(response) || response.isError === true)
         return null;
@@ -118,7 +108,6 @@ export function resultOf(response) {
     }
     return null;
 }
-/** Every string a call carried (a card's title, summary, steps…), up to `max` characters: what a card says. */
 export function wordsIn(value, max = CARD_WORDS) {
     const found = [];
     let left = max;
@@ -140,16 +129,16 @@ export function wordsIn(value, max = CARD_WORDS) {
     return found.join('\n');
 }
 const text = (value, max) => typeof value === 'string' && value.trim() ? value.trim().slice(0, max) : undefined;
-/** The agent's name on a call: `name`, or post_request's `session.label`. */
 function nameOf(input) {
     const session = isObject(input.session) ? input.session : null;
     return text(input.name, 120) ?? text(session?.label, 120);
 }
-/**
- * `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.
- */
+function withName(thread, name) {
+    if (!name)
+        return thread;
+    const names = (thread.names ?? []).filter((each) => !goesBy([each], name));
+    return { ...thread, names: [...names, name].slice(-NAMES) };
+}
 export async function posted(io, options) {
     const { app } = options;
     try {
@@ -164,36 +153,38 @@ export async function posted(io, options) {
         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 cwd = text(input.cwd, 1000);
         const now = io.now();
-        const state = await change(io, app, (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);
                 record.at = now;
                 state.turns[turn] = record;
             }
-            if (!requestId)
-                return;
-            const waiting = state.threads[thread] ?? { origin: options.origin, cards: {}, at: now };
-            const reopen = isObject(args.reopen) ? args.reopen : null;
-            if (call === 'cancel_request')
-                delete waiting.cards[requestId];
-            // A reply that leaves it the agent's turn (an answer to their message) isn't waiting on them.
-            else if (call !== 'reply_in_thread' || reopen || output?.turn === 'you') {
-                const before = waiting.cards[requestId];
-                const name = nameOf(args) ?? before?.name;
-                const title = text(args.title, 400) ?? text(reopen?.title, 400) ?? before?.title;
-                waiting.cards[requestId] = {
-                    ...(name ? { name } : {}),
-                    ...(title ? { title } : {}),
-                    at: now,
-                };
+            const waiting = withName(state.threads[thread] ?? { origin: options.origin, cards: {}, at: now }, nameOf(args));
+            if (requestId && !HELPER_CALLS.has(call)) {
+                const reopen = isObject(args.reopen) ? args.reopen : null;
+                if (call === 'cancel_request')
+                    delete waiting.cards[requestId];
+                else if (call !== 'reply_in_thread' || reopen || output?.turn === 'you') {
+                    const before = waiting.cards[requestId];
+                    const name = nameOf(args) ?? before?.name;
+                    const title = text(args.title, 400) ?? text(reopen?.title, 400) ?? before?.title;
+                    waiting.cards[requestId] = {
+                        ...(name ? { name } : {}),
+                        ...(title ? { title } : {}),
+                        at: now,
+                    };
+                }
             }
+            if (cwd)
+                waiting.cwd = cwd;
             waiting.origin = options.origin;
             waiting.at = now;
             state.threads[thread] = waiting;
         });
-        if (app === 'codex' && Object.keys(state.threads[thread]?.cards ?? {}).length > 0)
+        if (app === 'codex')
             await keepListening(io, options.origin, thread);
         return 0;
     }
@@ -201,48 +192,118 @@ export async function posted(io, options) {
         return 0;
     }
 }
-/** Whether this turn put something in front of the person, the words of each card, and whether it was nudged. */
+export async function touchThread(io, app, thread, cwd) {
+    try {
+        if (!THREAD.test(thread) || !(await load(io, app)).threads[thread])
+            return;
+        const now = io.now();
+        await change(io, app, (state) => {
+            const known = state.threads[thread];
+            if (!known)
+                return;
+            known.at = now;
+            if (cwd)
+                known.cwd = cwd;
+        });
+    }
+    catch { }
+}
+export async function threadNames(io, app, thread) {
+    if (!thread)
+        return [];
+    return (await load(io, app).catch(() => null))?.threads[thread]?.names ?? [];
+}
+export async function markHandedTurn(io, turn, app) {
+    const now = io.now();
+    await change(io, app, (state) => {
+        state.turns[turn] = { ...(state.turns[turn] ?? { cards: [] }), at: now, delegated: true };
+    });
+}
+async function candidates(io, app) {
+    const now = io.now();
+    const found = [];
+    for (const [thread, record] of Object.entries((await load(io, app)).threads)) {
+        if (!listenable(record, now))
+            continue;
+        found.push({
+            thread,
+            names: record.names ?? [],
+            ...(record.cwd ? { cwd: record.cwd } : {}),
+            at: record.at,
+            live: app === 'codex' || (await listening(io, app, thread)),
+        });
+    }
+    return found;
+}
+export async function hearsOnly(io, origin, app) {
+    const credential = await readCredential(io, origin, app).catch(() => null);
+    return credential !== null && credential.kind !== 'connection';
+}
+export async function computerNames(io, origin, options) {
+    const names = [io.host];
+    for (const app of APP_IDS) {
+        const machine = await connectionMachine(io, origin, app).catch(() => null);
+        if (machine)
+            names.push(machine);
+    }
+    const mac = await macName({ run: io.run, platform: io.platform ?? 'linux' }).catch(() => null);
+    if (mac)
+        names.push(mac);
+    if (options.tailscale) {
+        const tailscale = await tailscaleName(io).catch(() => null);
+        if (tailscale)
+            names.push(tailscale);
+    }
+    return names;
+}
+async function elsewhereFor(io, origin, app) {
+    if (!(await hearsOnly(io, origin, app)))
+        return () => false;
+    const names = await computerNames(io, origin, { tailscale: true });
+    return (heard) => namesAnotherComputer(heard.machine, names);
+}
+export async function sessionFor(io, app, heard) {
+    return chooseThread(heard, await candidates(io, app), { home: io.home });
+}
 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;
+    return record
+        ? {
+            cards: Array.isArray(record.cards) ? record.cards : [],
+            nudged: record.nudged === true,
+            delegated: record.delegated === true,
+        }
+        : null;
 }
-/** Remembers that the Stop check asked this turn to go on: at most once a turn. */
 export async function markNudged(io, turn, app = 'codex') {
     const now = io.now();
     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, app, thread) {
     return stat(leasePath(io, app, thread)).then((info) => Date.now() - info.mtimeMs < LEASE_STALE_MS, () => false);
 }
-/**
- * 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 (!THREAD.test(thread))
             return;
-        const cards = (await load(io, 'codex')).threads[thread]?.cards ?? {};
-        if (Object.keys(cards).length === 0 || (await listening(io, 'codex', thread)))
+        const { threads } = await load(io, 'codex');
+        const now = io.now();
+        const own = Object.keys(threads[thread]?.cards ?? {}).length > 0;
+        const handed = Object.values(threads).some((each) => mayBeHanded(each, now));
+        if (!own && !handed)
             return;
         if (!(await readCredential(io, origin, 'codex')))
             return;
-        io.background([
-            'listen',
-            '--app',
-            'codex',
-            '--thread',
-            thread,
-            ...(origin === DEFAULT_ORIGIN ? [] : ['--origin', origin]),
-        ]);
+        const at = origin === DEFAULT_ORIGIN ? [] : ['--origin', origin];
+        if (own && !(await listening(io, 'codex', thread)))
+            io.background(['listen', '--app', 'codex', '--thread', thread, ...at]);
+        if (handed && !(await listening(io, 'codex', HANDED)))
+            io.background(['listen', '--app', 'codex', '--handed', ...at]);
     }
     catch { }
 }
-/** What happened to a card and what to do, in the words the Claude Code wake mod uses (wake.ts's line). */
 function line(heard, card) {
     const titled = `“${clip(card.title ?? heard.title, 80)
         .text.replaceAll('“', '‘')
@@ -271,7 +332,6 @@ function line(heard, card) {
     }
 }
 const capital = (sentence) => sentence.charAt(0).toUpperCase() + sentence.slice(1);
-/** The message that wakes the thread: every card that needs it, and what to do with each; null when none does. */
 export function wakeMessage(ready) {
     const lines = ready.flatMap(({ heard, card }) => {
         const said = line(heard, card);
@@ -293,10 +353,6 @@ export function wakeMessage(ready) {
         ...(reopen ? [reopen.trim()] : []),
     ].join('\n');
 }
-/**
- * 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, app, thread) {
     const path = leasePath(io, app, thread);
     await mkdir(join(path, '..'), { recursive: true, mode: 0o700 });
@@ -312,7 +368,6 @@ async function takeLease(io, app, thread) {
         return null;
     }
 }
-/** Renews the lease while it's still this listener's (`id`); false once another listener has taken it. */
 async function renew(io, app, thread, id) {
     const path = leasePath(io, app, thread);
     if ((await readFile(path, 'utf8').catch(() => null)) !== id)
@@ -321,10 +376,6 @@ async function renew(io, app, thread, id) {
     await utimes(path, now, now).catch(() => { });
     return true;
 }
-/**
- * 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) => {
@@ -333,10 +384,6 @@ function byCodexQueue(io, thread) {
         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;
@@ -385,12 +432,32 @@ function byPlugin(io, gone) {
         }
     };
 }
-/**
- * `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.
- */
+async function handedHere(io, options, requests) {
+    const { origin, app, thread } = options;
+    const ready = requests.filter((heard) => heard.ready && delegatedOf(heard) && !options.elsewhere(heard));
+    if (ready.length === 0)
+        return [];
+    const sessions = await candidates(io, app);
+    const mine = [];
+    for (const heard of ready) {
+        const moment = momentOf(heard);
+        if (await wasHanded(io, origin, heard.requestId, moment))
+            continue;
+        if (chooseThread(heard, sessions, { home: io.home }) !== thread)
+            continue;
+        if (!(await claimHanded(io, origin, heard.requestId, moment)))
+            continue;
+        mine.push({
+            heard,
+            card: handedCard(heard, delegatedOf(heard)),
+        });
+    }
+    return mine;
+}
+async function giveBack(io, origin, list) {
+    for (const { heard } of list)
+        await releaseHanded(io, origin, heard.requestId, momentOf(heard)).catch(() => { });
+}
 export async function listen(io, options) {
     const { origin, app, thread } = options;
     const lease = await takeLease(io, app, thread);
@@ -403,13 +470,16 @@ export async function listen(io, options) {
     io.signal.addEventListener('abort', stop, { once: true });
     const signal = controller.signal;
     const deliver = app === 'codex' ? byCodexQueue(io, thread) : byPlugin(io, stop);
+    const takes = app !== 'codex';
+    const elsewhere = takes ? await elsewhereFor(io, origin, app) : () => false;
     try {
         const started = io.now();
         let since;
         let failures = 0;
         while (io.now() - started < LISTEN_MS && !signal.aborted) {
-            const cards = (await load(io, app)).threads[thread]?.cards ?? {};
-            if (Object.keys(cards).length === 0)
+            const record = (await load(io, app)).threads[thread];
+            const cards = record?.cards ?? {};
+            if (!record || (Object.keys(cards).length === 0 && !(takes && mayBeHanded(record, io.now()))))
                 return 0;
             if (!(await renew(io, app, thread, lease)))
                 return 0;
@@ -431,7 +501,6 @@ export async function listen(io, options) {
             catch (error) {
                 if (error instanceof SignInNeeded || signal.aborted)
                     return 0;
-                // Renewed first: no pause here outlasts the lease.
                 if (!(await renew(io, app, thread, lease)))
                     return 0;
                 await io.sleep(BACKOFF_MS[Math.min(failures++, BACKOFF_MS.length - 1)], signal);
@@ -444,28 +513,34 @@ export async function listen(io, options) {
             const done = [];
             for (const heard of requests) {
                 const card = cards[heard.requestId];
-                if (!card || !heard.ready)
+                if (!card || !heard.ready || delegatedOf(heard))
                     continue;
-                // 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
                     ready.push({ heard, card });
             }
+            const gone = () => change(io, app, (state) => {
+                delete state.threads[thread];
+            });
             const message = wakeMessage(ready);
             if (message) {
-                // 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];
-                    });
+                    await gone();
                     return 0;
                 }
                 await markHanded(io, origin, ready.map(({ heard }) => ({ requestId: heard.requestId, moment: momentOf(heard) })));
             }
+            const handed = takes ? await handedHere(io, { origin, app, thread, elsewhere }, requests) : [];
+            const asked = handedMessage(handed.map(({ card }) => card));
+            if (asked &&
+                !(await deliver(asked, handed.map(({ heard }) => heard.requestId)))) {
+                await giveBack(io, origin, handed);
+                await gone();
+                return 0;
+            }
             for (const { heard } of ready)
                 done.push(heard.requestId);
-            // Closed cards nobody needs telling about go too.
             for (const heard of requests)
                 if (cards[heard.requestId] && isClosed(heard) && !done.includes(heard.requestId))
                     done.push(heard.requestId);
@@ -483,8 +558,101 @@ export async function listen(io, options) {
     }
     finally {
         io.signal.removeEventListener('abort', stop);
-        // Only its own: a listener that took over keeps the thread.
         if ((await readFile(leasePath(io, app, thread), 'utf8').catch(() => null)) === lease)
             await rm(leasePath(io, app, thread), { force: true }).catch(() => { });
     }
 }
+export async function listenHanded(io, options) {
+    const { origin, app } = options;
+    if (app !== 'codex')
+        return 0;
+    const lease = await takeLease(io, app, HANDED);
+    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;
+    let program = null;
+    const queue = async (thread, 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;
+    };
+    const elsewhere = await elsewhereFor(io, origin, app);
+    try {
+        const started = io.now();
+        let since;
+        let failures = 0;
+        while (io.now() - started < LISTEN_MS && !signal.aborted) {
+            const now = io.now();
+            if (!Object.values((await load(io, app)).threads).some((each) => mayBeHanded(each, now)))
+                return 0;
+            if (!(await renew(io, app, HANDED, lease)))
+                return 0;
+            const query = new URLSearchParams({
+                source: app,
+                limit: '20',
+                wait: String(LONG_POLL_SECONDS),
+            });
+            if (since)
+                query.set('since', since);
+            let requests;
+            try {
+                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 || signal.aborted)
+                    return 0;
+                if (!(await renew(io, app, HANDED, lease)))
+                    return 0;
+                await io.sleep(BACKOFF_MS[Math.min(failures++, BACKOFF_MS.length - 1)], signal);
+                continue;
+            }
+            for (const heard of requests)
+                if (!since || heard.changedAt > since)
+                    since = heard.changedAt;
+            const sessions = requests.some((heard) => delegatedOf(heard)) ? await candidates(io, app) : [];
+            const byThread = new Map();
+            for (const heard of requests) {
+                const delegated = delegatedOf(heard);
+                if (!delegated || !heard.ready || elsewhere(heard))
+                    continue;
+                const moment = momentOf(heard);
+                if (await wasHanded(io, origin, heard.requestId, moment))
+                    continue;
+                const thread = chooseThread(heard, sessions, { home: io.home });
+                if (!thread || !(await claimHanded(io, origin, heard.requestId, moment)))
+                    continue;
+                byThread.set(thread, [
+                    ...(byThread.get(thread) ?? []),
+                    { heard, card: handedCard(heard, delegated) },
+                ]);
+            }
+            for (const [thread, list] of byThread) {
+                const message = handedMessage(list.map(({ card }) => card));
+                if (message && (await queue(thread, message)))
+                    continue;
+                await giveBack(io, origin, list);
+                await change(io, app, (state) => {
+                    delete state.threads[thread];
+                });
+                since = undefined;
+            }
+            if (io.now() - started > PATIENT_AFTER_MS)
+                await io.sleep(PATIENT_PAUSE_MS, signal);
+        }
+        return 0;
+    }
+    finally {
+        io.signal.removeEventListener('abort', stop);
+        if ((await readFile(leasePath(io, app, HANDED), 'utf8').catch(() => null)) === lease)
+            await rm(leasePath(io, app, HANDED), { force: true }).catch(() => { });
+    }
+}