@kammcs/buildit-mcp 0.9.0 → 0.11.0

package/dist/tools/ask.js

@@ -13,29 +13,34 @@
  *   usual (questions in the app turned off, no channel session, questions
  *   it can't read, or a post that failed).
  *
- * Each question is its own card, in order, in the same thread, as Claude
- * Code lists choices: its full text (Markdown), then a choice labelled with
- * its header, whose options carry their descriptions (the app shows them as
- * rows, the label beside its details), multi-select where the question
- * allows several, then a multi-line "Other" field for an answer of the
- * person's own; a choice or Other text is enough. Nothing is cut below the
- * card schema's limits. The answers come back together once every card is
- * answered. Answers are once-only, private to the owner, and confirmed;
- * accepting one closes its card. The cards close at their deadline on the server too, and when the
- * wait ends here for any reason.
+ * The questions (1 to 4) are one card, so the app can show them stacked,
+ * one at a time, then a review and Send: per question, its text (Markdown)
+ * as one text element of the body, in order, and a pair of inputs `qn` (a
+ * choice labelled with its header, whose options carry their descriptions,
+ * multi-select where the question allows several) and `qn_other` (a
+ * multi-line "Other" field for an answer of the person's own); one Send.
+ * Every question needs a choice or Other text. The structure is what the
+ * app recognises (no marker key: older apps refuse unknown keys), and an
+ * older app draws it as a plain form it can still answer. A card over the
+ * schema's limits has its longest texts shortened. Answers are once-only
+ * and confirmed; accepting the answer closes the card. In the direct
+ * message the answer is private to the owner; in an item's thread everyone
+ * there sees it once it is sent (a server that doesn't take that gets the
+ * private card instead). The card closes at its deadline on the server
+ * too, and when the wait ends here for any reason.
  */
 import { createHash } from 'node:crypto';
 import { z } from 'zod';
 import { ApiError } from '../api/client.js';
 import { answerSessionResponse, closeSessionCard, postSessionMessage } from '../channel/api.js';
 import { NOT_THE_CHANNEL } from '../channel/lock.js';
-import { isUuid, itemThreadId, resolveThread } from '../channel/threads.js';
-import { isItemWorker, workerEntry } from '../channel/workers.js';
+import { DM_AND_THREAD, dmThread, isItemThread, isUuid, itemThreadId, resolveThread, } from '../channel/threads.js';
+import { isItemWorker, isRequestWorker, workerEntry } from '../channel/workers.js';
 import { CardInbox, eventMessageId } from '../channel/waiters.js';
 import { ToolInputError } from '../errors.js';
 import { defineTool } from '../toolsets/registry.js';
 import { sanitizeLabel, wrapUntrusted } from '../untrusted.js';
-/** The longest question this reads (it is split over text elements of 2,000). */
+/** The longest question this reads (it is cut to 2,000 on the card). */
 const QUESTION_READ_MAX = 20_000;
 /** The longest description this reads (it is cut to 2,000 on the card). */
 const DESCRIPTION_READ_MAX = 10_000;
@@ -111,12 +116,13 @@ const WORDS = {
         'sr-Cyrl': '{agent} пита',
         'sr-Latn': '{agent} pita',
     },
-    of: {
-        en: 'Question {n} of {total}',
-        'es-419': 'Pregunta {n} de {total}',
-        'fr-CA': 'Question {n} sur {total}',
-        'sr-Cyrl': 'Питање {n} од {total}',
-        'sr-Latn': 'Pitanje {n} od {total}',
+    // N is 2 to 4 (Serbian: "2 питања", "4 питања").
+    questions: {
+        en: '{total} questions',
+        'es-419': '{total} preguntas',
+        'fr-CA': '{total} questions',
+        'sr-Cyrl': '{total} питања',
+        'sr-Latn': '{total} pitanja',
     },
     asks: {
         en: '{agent} asks:',
@@ -125,6 +131,13 @@ const WORDS = {
         'sr-Cyrl': '{agent} пита:',
         'sr-Latn': '{agent} pita:',
     },
+    asks_n: {
+        en: '{agent} asks {total} questions:',
+        'es-419': '{agent} hace {total} preguntas:',
+        'fr-CA': '{agent} pose {total} questions :',
+        'sr-Cyrl': '{agent} поставља {total} питања:',
+        'sr-Latn': '{agent} postavlja {total} pitanja:',
+    },
 };
 /** The card's language from a locale tag such as "fr-CA" or "sr-Cyrl-RS"; English when unknown. */
 export function cardLocale(tag) {
@@ -139,11 +152,8 @@ export function cardLocale(tag) {
         return t.includes('cyrl') ? 'sr-Cyrl' : 'sr-Latn';
     return 'en';
 }
-function word(key, locale, agent = '', n = 0, total = 0) {
-    return WORDS[key][locale]
-        .replace('{agent}', agent)
-        .replace('{n}', String(n))
-        .replace('{total}', String(total));
+function word(key, locale, agent = '', total = 0) {
+    return WORDS[key][locale].replace('{agent}', agent).replace('{total}', String(total));
 }
 // ---------------------------------------------------------------------------
 // Cleaning text for the card
@@ -190,38 +200,10 @@ export function cleanText(text, max = Number.POSITIVE_INFINITY) {
         .trim();
     return Number.isFinite(max) ? cutTo(kept, max) : kept;
 }
-/**
- * Splits text over pieces of at most `max` code points, at a line break or
- * a space in the second half of each piece where there is one.
- */
-export function splitText(text, max) {
-    const pieces = [];
-    let rest = Array.from(text);
-    while (rest.length > max) {
-        const window = rest.slice(0, max);
-        let at = -1;
-        for (const sep of ['\n', ' ']) {
-            const i = window.lastIndexOf(sep);
-            if (i >= max / 2) {
-                at = i;
-                break;
-            }
-        }
-        const end = at < 0 ? max : at;
-        const piece = rest.slice(0, end).join('').trim();
-        if (piece !== '')
-            pieces.push(piece);
-        rest = rest.slice(at < 0 ? end : end + 1);
-    }
-    const last = rest.join('').trim();
-    if (last !== '')
-        pieces.push(last);
-    return pieces;
-}
 // ---------------------------------------------------------------------------
 // The card
 // ---------------------------------------------------------------------------
-/** The card schema's limits that the question cards use. */
+/** The card schema's limits that the question card uses. */
 export const CARD_MAX_BYTES = 16_384;
 export const CARD_MAX_ELEMENTS = 25;
 const TEXT_MAX = 2000;
@@ -230,33 +212,45 @@ const OTHER_MAX = 2000;
 const PRIVATE_MAX_BYTES = 2048;
 /** A card may stay open at most this long. */
 const CLOSES_MAX_S = 86_400;
-function responses(closesAt) {
+/** Shrinking cuts descriptions down to this before it cuts question texts. */
+const SHRINK_FLOOR = 200;
+/** Nothing is cut shorter than this. */
+const SHRINK_MIN = 20;
+/** The card's `responses`: once-only and confirmed, private or shared once sent. */
+export function cardResponses(closesAt, shared = false) {
     return {
         mode: 'once',
-        visibility: 'private',
-        results: 'hidden',
+        visibility: shared ? 'shared' : 'private',
+        results: shared ? 'on_close' : 'hidden',
         guests: false,
         confirm: true,
         closes_at: closesAt,
     };
 }
-/** The option-id → label map, cut to fit; undefined when it can't fit. */
-function privateMap(q) {
+/** The option-id → label map of every question, cut to fit; undefined when it can't fit. */
+function privateMap(questions) {
     for (const max of [80, 40, 20, 10]) {
         const value = {
             v: 1,
-            map: {
-                q1: Object.fromEntries(q.options.map((o, j) => [`o${j + 1}`, cleanLine(o.label, max)])),
-            },
+            map: Object.fromEntries(questions.map((q, i) => [
+                `q${i + 1}`,
+                Object.fromEntries(q.options.map((o, j) => [`o${j + 1}`, cleanLine(o.label, max)])),
+            ])),
         };
         if (Buffer.byteLength(JSON.stringify(value), 'utf8') <= PRIVATE_MAX_BYTES)
             return value;
     }
     return undefined;
 }
-/** The message body (the fallback, and the push): "<agent> asks: <question>". */
-function fallbackText(q, ctx) {
-    return cutTo(`${word('asks', ctx.locale, ctx.agent)} ${cleanLine(q.question, 3800)}`, 4000);
+/**
+ * The message body (the fallback, and the push): "<agent> asks: <question>",
+ * or with several "<agent> asks N questions: <the first question>".
+ */
+function fallbackText(questions, ctx) {
+    const lead = questions.length > 1
+        ? word('asks_n', ctx.locale, ctx.agent, questions.length)
+        : word('asks', ctx.locale, ctx.agent);
+    return cutTo(`${lead} ${cleanLine(questions[0]?.question ?? '', 3800)}`, 4000);
 }
 /** The card's size as the schema counts it: its JSON without `private`, and its elements. */
 export function cardSize(card) {
@@ -275,17 +269,12 @@ const fits = (card) => {
     const size = cardSize(card);
     return size.bytes <= CARD_MAX_BYTES && size.elements <= CARD_MAX_ELEMENTS;
 };
-/**
- * The card for question n of total, nothing cut below the schema's limits:
- * its text, its choice, Other, Send. Neither input is required: a choice or
- * Other text is enough (checked when the answer comes).
- */
-function formCard(q, n, total, ctx) {
-    const body = splitText(cleanText(q.question), TEXT_MAX).map((text) => ({ type: 'text', text }));
-    const inputs = [
+/** Question n's pair of inputs: its choice (`qn`) and its Other field (`qn_other`). */
+function questionInputs(q, n, ctx) {
+    return [
         {
             type: 'choice',
-            id: 'q1',
+            id: `q${n}`,
             label: cleanLine(q.header, 150),
             ...(q.multiSelect === true ? { multiple: true } : {}),
             required: false,
@@ -300,7 +289,7 @@ function formCard(q, n, total, ctx) {
         },
         {
             type: 'text_input',
-            id: 'q1_other',
+            id: `q${n}_other`,
             label: word('other', ctx.locale),
             placeholder: word('own_answer', ctx.locale),
             multiline: true,
@@ -308,56 +297,80 @@ function formCard(q, n, total, ctx) {
             required: false,
         },
     ];
-    const priv = privateMap(q);
+}
+/**
+ * The card for a question set: exactly one text element per question, in
+ * order (cut at 2,000 with "…"), then each question's pair of inputs, one
+ * Send. Neither input of a pair is required: the answer is checked when it
+ * comes (every question needs a choice or Other text).
+ */
+function formCard(questions, ctx) {
+    const body = questions.map((q) => ({ type: 'text', text: cleanText(q.question, TEXT_MAX) }));
+    const priv = privateMap(questions);
     return {
         v: 1,
         header: {
             title: cleanLine(word('asks_title', ctx.locale, ctx.agent), 150),
-            ...(total > 1 ? { subtitle: word('of', ctx.locale, '', n, total) } : {}),
+            ...(questions.length > 1
+                ? { subtitle: word('questions', ctx.locale, '', questions.length) }
+                : {}),
         },
-        ...(body.length > 0 ? { body } : {}),
-        inputs,
+        body,
+        inputs: questions.flatMap((q, i) => questionInputs(q, i + 1, ctx)),
         actions: [{ type: 'submit', label: word('send', ctx.locale) }],
-        responses: responses(ctx.closesAt),
+        responses: cardResponses(ctx.closesAt, ctx.shared === true),
         ...(priv ? { private: priv } : {}),
     };
 }
+/** The longest of these texts over `min` code points, if any. */
+function longestOver(texts, min) {
+    let best;
+    let bestN = min;
+    for (const t of texts) {
+        const n = codePoints(t.get());
+        if (n > bestN) {
+            best = t;
+            bestN = n;
+        }
+    }
+    return best;
+}
 /**
- * The last resort for one question that alone is over the card's limits
- * (a very long question with long descriptions): the longest text, a
- * description or a piece of the question, is cut by a fifth (with "…")
- * until the card fits; question pieces past the element limit go first.
+ * The last resort for a card over the schema's limits (16 KB without
+ * `private`, 25 elements): the longest description is cut by a fifth (with
+ * "…") until the card fits, down to 200 characters; then the longest
+ * question text; then either, down to 20. Elements past the limit can't
+ * happen (at most 4 × 3 + 1), but text elements past it would go first.
  */
 function shrink(card) {
     const out = structuredClone(card);
     const body = (out.body ?? []);
     while (cardSize(out).elements > CARD_MAX_ELEMENTS && body.length > 1)
         body.pop();
-    const texts = () => [
-        ...body.map((b) => ({ get: () => b.text, set: (v) => (b.text = v) })),
-        ...(out.inputs ?? []).flatMap((input) => (input.options ?? [])
-            .filter((o) => o.description !== undefined)
-            .map((o) => ({ get: () => o.description ?? '', set: (v) => (o.description = v) }))),
-    ];
-    for (let i = 0; i < 200 && !fits(out); i++) {
-        const longest = texts().reduce((a, b) => (codePoints(b.get()) > codePoints(a.get()) ? b : a));
-        const n = codePoints(longest.get());
-        if (n <= 20)
+    const questions = body.map((b) => ({
+        get: () => b.text,
+        set: (v) => (b.text = v),
+    }));
+    const descriptions = (out.inputs ?? []).flatMap((input) => (input.options ?? [])
+        .filter((o) => o.description !== undefined)
+        .map((o) => ({ get: () => o.description ?? '', set: (v) => (o.description = v) })));
+    for (let i = 0; i < 1000 && !fits(out); i++) {
+        const longest = longestOver(descriptions, SHRINK_FLOOR) ??
+            longestOver(questions, SHRINK_FLOOR) ??
+            longestOver([...descriptions, ...questions], SHRINK_MIN);
+        if (longest === undefined)
             break;
-        longest.set(cutTo(longest.get(), Math.floor(n * 0.8)));
+        longest.set(cutTo(longest.get(), Math.floor(codePoints(longest.get()) * 0.8)));
     }
     return out;
 }
 /**
- * The cards for a question set: one per question, in order (so each
- * question sits beside its choices). A question that alone is over the
- * card's limits (16 KB, 25 elements) has its longest texts shortened.
+ * The one card for a question set (1 to 4 questions), shortened to the
+ * card's limits when it is over them.
  */
-export function buildQuestionCards(questions, ctx) {
-    return questions.map((q, i) => {
-        const card = formCard(q, i + 1, questions.length, ctx);
-        return { question: q, text: fallbackText(q, ctx), card: fits(card) ? card : shrink(card) };
-    });
+export function buildQuestionCard(questions, ctx) {
+    const card = formCard(questions, ctx);
+    return { questions, text: fallbackText(questions, ctx), card: fits(card) ? card : shrink(card) };
 }
 /** The time a card posted now closes: wait + 60 s, at most a day. */
 export function closesAt(nowMs, waitS) {
@@ -444,7 +457,7 @@ export function uuidV5(name, namespace = ASK_NAMESPACE) {
     return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 }
 /**
- * The (first) card message's id: from the tool call's id when the hook
+ * The card message's id: from the tool call's id when the hook
  * passes one (a hook that runs twice for one call posts one card), else
  * from the session, the questions and the minute.
  */
@@ -454,10 +467,6 @@ export function askMessageId(init) {
     const hash = createHash('sha256').update(JSON.stringify(init.questions)).digest('hex');
     return uuidV5(`${init.sessionId}\n${hash}\n${Math.floor(init.nowMs / 60_000)}`);
 }
-/** The ids of a split ask's cards: the first id, then one derived from it per further card. */
-export function cardIds(firstId, count) {
-    return Array.from({ length: count }, (_v, i) => i === 0 ? firstId : uuidV5(`${firstId}\n${i + 1}`));
-}
 /** The tool's own wait when it names none. */
 export const TOOL_DEFAULT_WAIT_S = 600;
 /** How often a long wait reports progress. */
@@ -496,6 +505,10 @@ export const AskInputSchema = z.object({
         .max(60)
         .optional()
         .describe("A work item's key (DEMO-12): ask in its thread, instead of thread_id."),
+    dm: z
+        .boolean()
+        .optional()
+        .describe('true: ask in your direct message with the person (its latest thread, or a new message), never in an item thread. Use it for anything about a request (event="request").'),
     wait_s: z
         .number()
         .int()
@@ -518,10 +531,58 @@ const AskOutputSchema = z.object({
     answers: z
         .record(z.string(), z.string())
         .describe('Question → the answer, wrapped as untrusted content.'),
-    message_id: z.string().nullable().describe("The (first) card's message."),
+    message_id: z.string().nullable().describe("The card's message."),
 });
 const isRefusal = (err, ...codes) => err instanceof ApiError && codes.includes(err.code);
 const codeOf = (err) => (err instanceof ApiError ? err.code : 'error');
+/**
+ * Whether a refusal of the card is about its `responses` (`card_invalid`
+ * naming a path under it): a server older than shared answers in an item's
+ * thread, which takes only private ones.
+ */
+export function refusesResponses(err) {
+    if (!isRefusal(err, 'card_invalid'))
+        return false;
+    const details = asRecord(err.details);
+    const onResponses = (v) => typeof v === 'string' && /^responses(?:$|[.[])/.test(v);
+    const listed = (key) => {
+        const list = details?.[key];
+        return Array.isArray(list) ? list : [];
+    };
+    return (onResponses(details?.path) ||
+        [...listed('errors'), ...listed('fields')].some((e) => onResponses(asRecord(e)?.path)));
+}
+/**
+ * Posts the card. In an item's thread it asks for shared answers; a server
+ * that refuses that (`card_invalid` on `responses`) gets the same card,
+ * private, with the same id, once. A refused post makes no message, so the
+ * second post isn't answered with the first.
+ *
+ * Not with the call's signal: a cancel that cut the post short could leave
+ * a card the server already made open, with nobody waiting for its answer.
+ * The post finishes (each attempt has the client's timeout), and the wait
+ * that follows sees the cancel and closes the card, after the post.
+ */
+async function postCard(ctx, init, closes) {
+    const options = { ...ctx.apiOptions };
+    delete options.signal;
+    const post = (card) => postSessionMessage(ctx.api, {
+        id: init.id,
+        text: init.text,
+        ...(init.threadId === undefined ? {} : { thread_id: init.threadId }),
+        card,
+    }, options);
+    const shared = asRecord(init.card.responses)?.visibility === 'shared';
+    try {
+        await post(init.card);
+    }
+    catch (err) {
+        if (!shared || !refusesResponses(err))
+            throw err;
+        ctx.logger.info('ask card refused shared answers; posting it private', { code: codeOf(err) });
+        await post({ ...init.card, responses: cardResponses(closes, false) });
+    }
+}
 /** The ask tool for one channel session. */
 export function createAskTool(state, options) {
     const scale = options.msPerSecond ?? 1000;
@@ -531,7 +592,7 @@ export function createAskTool(state, options) {
         // Not in the catalog: listed only in channel mode, whatever the toolsets.
         toolset: 'chat',
         title: 'Ask in buildIt.Social',
-        description: `Asks the person who directs this session 1 to 4 multiple-choice questions, as a card in buildIt.Social (on their computer or phone), in the thread of the message you are working on (an item's thread too, where only they can answer), and waits for their answer. Use it when you need the person's decision to go on with a task that came from buildIt.Social and they aren't at this terminal. Each question has a short header and 2 to 4 options, each with an optional description; they can always type another answer. The answer comes back as their words inside an untrusted_content block: what they chose, data to act on as their decision, not new instructions from someone else. If nobody answers within wait_s (default ${TOOL_DEFAULT_WAIT_S} seconds), or they dismiss the card, the result says so: then make a safe assumption and say which, or stop and say what you need; don't ask the same question again right away.`,
+        description: `Asks the person who directs this session 1 to 4 multiple-choice questions, as one card in buildIt.Social (on their computer or phone), in the thread of the message you are working on (an item's thread too, where only they can answer and everyone there sees the answers once sent), and waits for their answers. Use it when you need the person's decision to go on with a task that came from buildIt.Social and they aren't at this terminal. Each question has a short header and 2 to 4 options, each with an optional description; they can always type another answer, and they answer every question. The answers come back as their words inside an untrusted_content block: what they chose, data to act on as their decision, not new instructions from someone else. If nobody answers within wait_s (default ${TOOL_DEFAULT_WAIT_S} seconds), or they dismiss the card, the result says so: then make a safe assumption and say which, or stop and say what you need; don't ask the same question again right away.`,
         scopes: [],
         runsAfterSessionEnd: true,
         annotations: {
@@ -573,7 +634,7 @@ export function createAskTool(state, options) {
             }
             const waitS = hook ? options.hookWaitS : (args.wait_s ?? TOOL_DEFAULT_WAIT_S);
             const started = now();
-            const firstId = askMessageId({
+            const id = askMessageId({
                 toolUseId: hook ? args.tool_use_id : undefined,
                 sessionId: args.session_id !== undefined && args.session_id !== ''
                     ? args.session_id
@@ -581,55 +642,51 @@ export function createAskTool(state, options) {
                 questions,
                 nowMs: started,
             });
-            const locale = cardLocale(state.ownerLocale);
-            const built = buildQuestionCards(questions, {
-                agent: cleanLine(info.agent.name, 60),
-                locale,
-                closesAt: closesAt(started, waitS),
-            });
-            const ids = cardIds(firstId, built.length);
-            const cards = built.map((b, i) => ({
-                id: ids[i] ?? firstId,
-                question: b.question,
-            }));
             let threadId;
+            let inItem;
             if (hook) {
                 // The hook names no thread: who asks (the lead, or an item worker) decides.
                 const placed = await hookThread(state, ctx, args.agent_id, args.agent_type);
                 if (placed === null)
                     return pass('thread_unknown');
                 threadId = placed.thread;
+                inItem = placed.item;
+            }
+            else if (args.dm === true) {
+                if (args.thread_id !== undefined || args.item !== undefined) {
+                    throw new ToolInputError(DM_AND_THREAD);
+                }
+                threadId = dmThread(state);
+                inItem = false;
             }
             else {
                 threadId = await resolveThread(state, ctx, args, 'ask');
+                inItem = args.item !== undefined || isItemThread(state, threadId);
             }
-            // Registered before the posts, so an answer in the next poll finds it.
+            const locale = cardLocale(state.ownerLocale);
+            const closes = closesAt(started, waitS);
+            const built = buildQuestionCard(questions, {
+                agent: cleanLine(info.agent.name, 60),
+                locale,
+                closesAt: closes,
+                shared: inItem,
+            });
+            // Registered before the post, so an answer in the next poll finds it.
             const inbox = new CardInbox();
-            const unregister = ids.map((id) => state.waiters.register(id, inbox, threadId));
+            const unregister = state.waiters.register(id, inbox, threadId);
             let progress;
             try {
-                for (const [i, b] of built.entries()) {
-                    try {
-                        await postSessionMessage(ctx.api, {
-                            id: ids[i] ?? firstId,
-                            text: b.text,
-                            ...(threadId === undefined ? {} : { thread_id: threadId }),
-                            card: b.card,
-                        }, ctx.apiOptions);
-                    }
-                    catch (err) {
-                        ctx.logger.info('ask card not posted', { code: codeOf(err), card: i + 1 });
-                        // The cards already posted can't be answered on their own: close them.
-                        for (const id of ids.slice(0, i))
-                            await closeCard(ctx, id);
-                        if (hook)
-                            return pass('post_failed');
-                        throw err;
-                    }
-                    if (i === 0)
-                        state.typing?.stop(threadId);
+                try {
+                    await postCard(ctx, { id, text: built.text, threadId, card: built.card }, closes);
                 }
-                ctx.logger.info('ask card posted', { message_id: firstId, cards: built.length });
+                catch (err) {
+                    ctx.logger.info('ask card not posted', { code: codeOf(err) });
+                    if (hook)
+                        return pass('post_failed');
+                    throw err;
+                }
+                state.typing?.stop(threadId);
+                ctx.logger.info('ask card posted', { message_id: id, questions: questions.length });
                 if (ctx.progress !== undefined) {
                     const report = ctx.progress;
                     let beats = 0;
@@ -638,11 +695,12 @@ export function createAskTool(state, options) {
                         void report(`Waiting for the person's answer in buildIt.Social (${Math.round((beats * PROGRESS_EVERY_S) / 60)} min).`).catch(() => undefined);
                     }, PROGRESS_EVERY_S * scale);
                 }
-                const outcome = await waitForAnswers({
+                const outcome = await waitForAnswer({
                     ctx,
                     inbox,
                     memory: state.waiters,
-                    cards,
+                    id,
+                    questions,
                     locale,
                     deadline: started + waitS * scale,
                     now,
@@ -652,7 +710,7 @@ export function createAskTool(state, options) {
                     hook,
                     questions: parsedOriginal(args.questions),
                     order: questions.map((q) => q.question),
-                    messageId: firstId,
+                    messageId: id,
                     minutes,
                     owner: info.owner.name,
                 });
@@ -660,8 +718,7 @@ export function createAskTool(state, options) {
             finally {
                 if (progress !== undefined)
                     clearInterval(progress);
-                for (const off of unregister)
-                    off();
+                unregister();
                 inbox.drain();
             }
         },
@@ -671,7 +728,9 @@ export function createAskTool(state, options) {
  * Where the hook's question goes (channel/workers.ts): the main agent's
  * (no agent_id or agent_type) in the direct message, its latest thread
  * (undefined: a new message there); an item worker's in its item's thread,
- * from the lead's table; anything else is null (the terminal asks).
+ * from the lead's table; a request worker's in the direct message too (a
+ * request is private); anything else is null (the terminal asks). `item`
+ * says whether the thread is an item's.
  */
 async function hookThread(state, ctx, agentId, agentType) {
     // An empty field, or one Claude Code didn't fill in, is absent.
@@ -682,18 +741,22 @@ async function hookThread(state, ctx, agentId, agentType) {
     const id = clean(agentId);
     const type = clean(agentType);
     if (id === '' && type === '')
-        return { thread: state.lastDmThread };
+        return { thread: state.lastDmThread, item: false };
+    // A request worker asks in the direct message, never in an item's thread.
+    if (isRequestWorker(type))
+        return { thread: dmThread(state), item: false };
     if (id === '' || !isItemWorker(type) || state.folder === undefined)
         return null;
     const entry = workerEntry(state.folder, id);
     if (entry === undefined)
         return null;
-    if (entry.thread_id !== undefined && isUuid(entry.thread_id))
-        return { thread: entry.thread_id };
+    if (entry.thread_id !== undefined && isUuid(entry.thread_id)) {
+        return { thread: entry.thread_id, item: true };
+    }
     if (entry.item === undefined)
         return null;
     try {
-        return { thread: await itemThreadId(entry.item, ctx) };
+        return { thread: await itemThreadId(entry.item, ctx), item: true };
     }
     catch {
         return null;
@@ -722,8 +785,8 @@ async function closeCard(ctx, messageId) {
         ctx.logger.info('ask card not closed', { code: codeOf(err) });
     }
 }
-/** Why a card closed before its answer, as the result says it. */
-function closedReason(closedBy, split) {
+/** Why the card closed before its answer, as the result says it. */
+function closedReason(closedBy) {
     if (closedBy === 'time')
         return 'timeout';
     if (closedBy === 'session_ended')
@@ -731,83 +794,55 @@ function closedReason(closedBy, split) {
     // The session was taken off the item: its channel notice says to stop.
     if (closedBy === 'unassigned')
         return 'closed';
-    // One of several cards closed: the ask as a whole was dismissed.
-    if (split || closedBy === 'owner')
+    if (closedBy === 'owner')
         return 'dismissed';
     return 'closed';
 }
 /**
- * Takes the cards' events until every card has an answer, a card closes
- * before its answer, or the wait ends; then closes the cards still open.
- * A card answered before (the hook can run twice for one question, the
- * second time after the first accepted the answer) counts with the answers
- * remembered for it; one that closed before without an answer ends the ask.
+ * Takes the card's events until it has an answer for every question, it
+ * closes before that, or the wait ends (then it is closed). A card answered
+ * before (the hook can run twice for one call, the second time after the
+ * first accepted the answer) returns the answers remembered for it; one that
+ * closed before without an answer ends the ask the same way.
  */
-async function waitForAnswers(init) {
-    const { ctx, inbox, memory, cards, locale } = init;
-    const answered = new Map();
-    const closeOpen = async () => {
-        for (const card of cards)
-            if (!answered.has(card.id))
-                await closeCard(ctx, card.id);
-    };
-    const complete = () => answered.size === cards.length
-        ? {
-            status: 'answered',
-            answers: Object.assign({}, ...cards.map((c) => answered.get(c.id))),
-        }
-        : undefined;
-    for (const card of cards) {
-        const known = memory.answersOf(card.id);
-        if (known !== undefined)
-            answered.set(card.id, known);
-    }
-    const already = complete();
-    if (already !== undefined)
-        return already;
-    for (const card of cards) {
-        const by = answered.has(card.id) ? undefined : memory.closedBy(card.id);
-        if (by !== undefined) {
-            answered.set(card.id, {});
-            await closeOpen();
-            return { status: 'no_answer', reason: closedReason(by, cards.length > 1) };
-        }
+async function waitForAnswer(init) {
+    const { ctx, inbox, memory, id, questions, locale } = init;
+    const answered = (answers) => ({ status: 'answered', answers });
+    const known = memory.answersOf(id);
+    if (known !== undefined)
+        return answered(known);
+    const closedBefore = memory.closedBy(id);
+    if (closedBefore !== undefined) {
+        return { status: 'no_answer', reason: closedReason(closedBefore) };
     }
     for (;;) {
         const next = await inbox.next(init.deadline, ctx.signal, init.now);
         if (next === 'timeout') {
-            await closeOpen();
+            await closeCard(ctx, id);
             return { status: 'no_answer', reason: 'timeout' };
         }
         if (next === 'aborted') {
-            await closeOpen();
+            await closeCard(ctx, id);
             return { status: 'no_answer', reason: 'closed' };
         }
         if (next === 'session_ended')
             return { status: 'no_answer', reason: 'session_ended' };
-        // The session was taken off the item whose thread it asked in: the server closed the cards.
+        // The session was taken off the item whose thread it asked in: the server closed the card.
         if (next === 'closed')
             return { status: 'no_answer', reason: 'closed' };
         const { event, done } = next;
         try {
-            const card = cards.find((c) => c.id === eventMessageId(event));
-            // An answered card's own close (accepting closes it), or another card's event.
-            if (card === undefined || answered.has(card.id))
+            if (eventMessageId(event) !== id)
                 continue;
             if (event.type === 'card.closed') {
                 // Another call for the same card may have accepted its answer.
-                const known = memory.answersOf(card.id);
-                if (known !== undefined) {
-                    answered.set(card.id, known);
-                    const outcome = complete();
-                    if (outcome !== undefined)
-                        return outcome;
-                    continue;
-                }
-                const by = event.data.closed_by;
-                answered.set(card.id, {});
-                await closeOpen();
-                return { status: 'no_answer', reason: closedReason(by, cards.length > 1) };
+                const remembered = memory.answersOf(id);
+                if (remembered !== undefined)
+                    return answered(remembered);
+                return {
+                    status: 'no_answer',
+                    reason: closedReason(event.data.closed_by),
+                };
             }
             if (event.type !== 'card.response')
                 continue;
@@ -816,7 +851,8 @@ async function waitForAnswers(init) {
             const revision = response?.revision;
             if (typeof responseId !== 'string' || typeof revision !== 'number')
                 continue;
-            const decoded = decodeAnswer([card.question], response?.answer);
+            // Every question needs a choice or Other text.
+            const decoded = decodeAnswer(questions, response?.answer);
             if (decoded.kind === 'reject') {
                 await reject(ctx, responseId, revision, decoded.note, locale);
                 continue;
@@ -827,24 +863,17 @@ async function waitForAnswers(init) {
             }
             catch (err) {
                 if (isRefusal(err, 'response_changed', 'card_closed')) {
-                    const known = memory.answersOf(card.id);
-                    if (known === undefined)
-                        continue;
-                    answered.set(card.id, known);
-                    const outcome = complete();
-                    if (outcome !== undefined)
-                        return outcome;
+                    const remembered = memory.answersOf(id);
+                    if (remembered !== undefined)
+                        return answered(remembered);
                     continue;
                 }
                 // The person answered; the answer stands even if it couldn't be marked.
                 ctx.logger.info('ask answer not marked accepted', { code: codeOf(err) });
-                await closeCard(ctx, card.id);
+                await closeCard(ctx, id);
             }
-            memory.rememberAnswers(card.id, decoded.answers);
-            answered.set(card.id, decoded.answers);
-            const outcome = complete();
-            if (outcome !== undefined)
-                return outcome;
+            memory.rememberAnswers(id, decoded.answers);
+            return answered(decoded.answers);
         }
         finally {
             done();