@songsid/agend 2.3.0-beta.8 → 2.3.0

package/dist/needs-you-hub.d.ts

@@ -1,7 +1,11 @@
 import type { ChannelAdapter } from "./channel/types.js";
-import { type DeliveryInput, type InstanceInput, type NeedsYouItem, type PromptInput, type WorldPlace } from "./needs-you.js";
+import { type DeliveryInput, type InstanceInput, type NeedsYouItem, type PromptInput, type TaskInput, type WorldPlace } from "./needs-you.js";
 import { type LiveTarget } from "./needs-you-live.js";
 export declare const NEEDS_ACK_PREFIX = "needs-ack:";
+/** A Send back or Answer prompt waits this long for its reply (monotonic). */
+export declare const TASK_REPLY_TTL_MS: number;
+/** Send back / Answer prompts open at once, being sent or waiting for their reply, over every card and person (#2306 review). */
+export declare const TASK_REPLY_MAX = 32;
 /** awaiting_input pings (DM, browser) only once it has lasted this long; the list itself is never delayed (§6.3). */
 export declare const AWAITING_PING_MIN_MS = 5000;
 /** An Acknowledge button's capability lapses this long after it was minted, whether or not a renewal replaced it. */
@@ -27,6 +31,15 @@ export interface NeedsYouHubContext {
     worlds(): NeedsYouWorld[];
     /** Where a world's fleet notices go (its General), or null. */
     noticeTarget(world: string): LiveTarget | null;
+    /** #2352: an instance's own channel (its topic in its world's group, or its ClassicBot room), or null. */
+    laneTarget?(instance: string): LiveTarget | null;
+    /**
+     * #2355 review: where a card's buttons belong NOW, read from the board (not from the last render): `{ lane }` (no lane:
+     * General), or null when the card no longer waits for the person (the board answers a move by its version).
+     */
+    taskRoute?(code: string): {
+        lane?: string;
+    } | null;
     /** An instance's own thread/topic id, for its link. */
     instanceTopic(instance: string): string | undefined;
     isFleetAdmin(userId: string, world: string): boolean;
@@ -34,6 +47,16 @@ export interface NeedsYouHubContext {
     emitSse(event: string, data: unknown): void;
     /** outbox.acknowledge: true when this call acknowledged it; throws on a write error. */
     acknowledge(deliveryId: string, by: string): boolean;
+    /** Task board cards waiting for the person (#2246 step 3); none when the board is not open. */
+    tasks?(): TaskInput[];
+    /**
+     * The person's move on a card from the chat: confirm it, send it back with `text` (the reason), or answer its blocked
+     * question with `text`. Checked against the version the button showed; the answer is said to the clicker.
+     */
+    taskAction?(action: TaskAction): {
+        ok: boolean;
+        message: string;
+    };
     settings(): {
         liveMessage: boolean;
         dm: boolean;
@@ -42,16 +65,44 @@ export interface NeedsYouHubContext {
     t(key: string, ...args: Array<string | number>): string;
     log(level: "info" | "warn" | "debug", message: string, extra?: Record<string, unknown>): void;
 }
+export type TaskVerb = "confirm" | "back" | "answer";
+export interface TaskAction {
+    verb: TaskVerb;
+    code: string;
+    version: number;
+    /** The reason (back) or the answer (answer). */
+    text?: string;
+    /** The person, as the platform names them. */
+    by: {
+        platform: string;
+        userId: string;
+        username?: string;
+    };
+}
+/** A reply to a message, as the inbound handler sees it (InboundMessage's fields). */
+export interface ReplyMessage {
+    adapterId: string;
+    chatId: string;
+    threadId?: string;
+    replyTo?: string;
+    messageId: string;
+    userId: string;
+    username?: string;
+    text: string;
+}
 export interface AckCallback {
     callbackData: string;
     chatId: string;
     threadId?: string;
     messageId: string;
     userId?: string;
+    username?: string;
     ack?(notice?: string): void;
 }
 /** What the web receives: the items without their chat coordinates. */
 export type WebNeedsItem = Omit<NeedsYouItem, "promptAt">;
+/** #2352: a live message's key — its world (General, as before #2352) or `<world>#lane:<instance>` (a lane's channel). */
+export declare function liveKey(world: string, lane: string | null): string;
 export declare class NeedsYouHub {
     private readonly ctx;
     private items;
@@ -62,6 +113,16 @@ export declare class NeedsYouHub {
      *  moved place gets a new renderer, and the old one can no longer publish. */
     private readonly live;
     private readonly acks;
+    /** Send back / Answer prompts waiting for the clicker's reply, by `${world}|${chatId}|${messageId}`. */
+    /** Pending replies by where their prompt is (`<chatId>|<messageId>`), whichever bot receives the reply. */
+    private readonly replies;
+    /** Prompts on their way: reserved before the send, released when it is posted or fails (#2306 review). */
+    private readonly asking;
+    /**
+     * #2341 review r2: replies already taken, by `<chatId>|<messageId>`, until the prompt's TTL — so another bot's copy of
+     * the same message (a shared group) is dropped by the inbound handler, not handed to an agent as input.
+     */
+    private readonly taken;
     private readonly dmSeen;
     private readonly dmLastAt;
     /** Per world: the ids waiting to be DMed, and the one timer that will send them. */
@@ -84,7 +145,12 @@ export declare class NeedsYouHub {
     private pointerPath;
     private readPointers;
     private writePointer;
+    /** A line's words: why it waits — and for a card, which card and what it asks or lacks (the chat shows no detail). */
     private lineTitle;
+    /** #2352: a lane can carry a list here: its instance is this world's now, and has a channel of its own. */
+    private laneUsable;
+    /** Where a list (General, or a lane's) is posted now, or null. */
+    private listTarget;
     private makeLive;
     private mintAcks;
     private revokeAcks;
@@ -94,6 +160,37 @@ export declare class NeedsYouHub {
      * never edited from here — that would strip the current keyboard of the same message.
      */
     handleCallback(data: AckCallback, adapterId: string): boolean;
+    /**
+     * #2352: a card still routes to this lane (or, for no lane, to General) — asked of the board now (#2355 review: a
+     * project's lead can change with the card's version unchanged, and the last render may not have seen it yet). One
+     * that no longer waits for the person is left to the board, which answers by its version.
+     */
+    private stillInLane;
+    /** #2355 review: a list's place (its lane's channel, or General) is still where this button or prompt is. */
+    private placeStill;
+    /** A prompt for this reservation still waits for its reply. */
+    private pendingFor;
+    /** Prompts still waiting for their reply (lapsed ones go). */
+    private livePending;
+    /**
+     * The card's instance is still this world's, the world still the same connection in the same place, and its notice
+     * place still where the prompt is: else a reply there is not this world's to take (#2306 review — an instance that
+     * moved to another world, a replaced connection, a new notice room).
+     */
+    private stillHere;
+    /** Post the prompt for a Send back's reason or an answer, and wait for the clicker's reply to it. */
+    private askForReply;
+    /**
+     * An inbound message that replies to one of our Send back / Answer prompts, by the admin who clicked: its text is
+     * the reason or the answer, and the message goes no further (true). Anything else — another message, another
+     * person, a lapsed prompt — is not ours (false) and flows on as usual.
+     */
+    handleReply(msg: ReplyMessage): boolean;
+    /**
+     * #2341 review r2: this message (another bot's copy of it) was already taken as a prompt's answer. The inbound handler
+     * asks it first and drops the copy: it is neither a second answer nor an agent's input.
+     */
+    wasTakenReply(chatId: string, messageId: string | undefined): boolean;
     /** The web's Acknowledge: any item (the web is global, §5.0). `principal` is "web:<session handle>" or "cli". */
     webAcknowledge(itemId: string, principal: string): {
         status: 200 | 400 | 404 | 409 | 500;

package/dist/needs-you-hub.js

@@ -2,7 +2,13 @@
  * #1386: the fleet side of "Needs you". One derivation (needs-you.ts), recomputed on change, rendered to:
  * - each world's live message in its General and, optionally, its admins' DMs — only that world's items (§5.0, §5);
  * - the web, globally: SSE `needs` and a `needs` field on /ui/poll (§6).
- * Plus Acknowledge for delivery items, from a world's live message (its admins, its items) or from the web (any).
+ * Plus Acknowledge for delivery items, from a world's live message (its admins, its items) or from the web (any); and
+ * for task board cards (#2246 step 3), Confirm, Send back and Answer from the live message — the two that need words
+ * ask for them as a reply to a prompt the bot posts, which only the admin who clicked may answer.
+ *
+ * #2352: a card with a lane (the instance that handed it out, else its project's lead) is listed in that instance's own
+ * channel instead — one live message per lane, the same renderer, its buttons and prompts bound to that message and
+ * place. A world's General keeps everything else.
  *
  * The Acknowledge capabilities live in this hub's own registry, not in the fleet's prompt map: the map's walkers
  * (per-instance clear, shutdown retire, prompt expiry) edit the message an entry points at, and the live message must
@@ -14,11 +20,15 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { writeFileAtomic } from "./backend/kiro-engine-ledger.js";
 import { isMessageEditLoss } from "./channel/message-edit-errors.js";
-import { deriveNeedsYou, itemsForWorld, renderLiveMessage, renderSignature, messageLink, instanceLink, } from "./needs-you.js";
+import { deriveNeedsYou, itemsForWorld, itemsForLane, lanesOf, renderLiveMessage, renderSignature, messageLink, instanceLink, } from "./needs-you.js";
 import { GroupMembership, topicUrl } from "./topic-link.js";
-import { NeedsYouLiveMessage, canonicalTarget } from "./needs-you-live.js";
+import { NeedsYouLiveMessage, canonicalTarget, samePlace } from "./needs-you-live.js";
 export const NEEDS_ACK_PREFIX = "needs-ack:";
-const ACK_RE = /^needs-ack:([0-9a-f]{32}):ack$/;
+const ACK_RE = /^needs-ack:([0-9a-f]{32}):(ack|confirm|back|answer)$/;
+/** A Send back or Answer prompt waits this long for its reply (monotonic). */
+export const TASK_REPLY_TTL_MS = 10 * 60_000;
+/** Send back / Answer prompts open at once, being sent or waiting for their reply, over every card and person (#2306 review). */
+export const TASK_REPLY_MAX = 32;
 const BACKSTOP_MS = 10_000;
 const ATTENTION_WINDOW_MS = 24 * 60 * 60_000;
 /** awaiting_input pings (DM, browser) only once it has lasted this long; the list itself is never delayed (§6.3). */
@@ -30,6 +40,11 @@ export const ACK_TTL_MS = 15 * 60_000;
 function placeKey(place) {
     return `${place.type}|${place.groupId ?? ""}`;
 }
+/** #2352: a live message's key — its world (General, as before #2352) or `<world>#lane:<instance>` (a lane's channel). */
+export function liveKey(world, lane) {
+    return lane ? `${world}#lane:${lane}` : world;
+}
+const LANE_SEP = "#lane:";
 export class NeedsYouHub {
     ctx;
     items = [];
@@ -40,6 +55,16 @@ export class NeedsYouHub {
      *  moved place gets a new renderer, and the old one can no longer publish. */
     live = new Map();
     acks = new Map();
+    /** Send back / Answer prompts waiting for the clicker's reply, by `${world}|${chatId}|${messageId}`. */
+    /** Pending replies by where their prompt is (`<chatId>|<messageId>`), whichever bot receives the reply. */
+    replies = new Map();
+    /** Prompts on their way: reserved before the send, released when it is posted or fails (#2306 review). */
+    asking = new Set();
+    /**
+     * #2341 review r2: replies already taken, by `<chatId>|<messageId>`, until the prompt's TTL — so another bot's copy of
+     * the same message (a shared group) is dropped by the inbound handler, not handed to an agent as input.
+     */
+    taken = new Map();
     dmSeen = new Map();
     dmLastAt = new Map();
     /** Per world: the ids waiting to be DMed, and the one timer that will send them. */
@@ -75,6 +100,9 @@ export class NeedsYouHub {
         if (this.stopped)
             return;
         const now = this.ctx.now();
+        for (const [key, r] of this.replies)
+            if (this.ctx.mono() >= r.deadline)
+                this.replies.delete(key);
         let deliveries = [];
         try {
             deliveries = this.ctx.deliveries(new Date(now - ATTENTION_WINDOW_MS).toISOString());
@@ -82,7 +110,14 @@ export class NeedsYouHub {
         catch (err) {
             this.ctx.log("warn", "Needs you: could not read the delivery outbox", { err: String(err?.message ?? err) });
         }
-        this.items = deriveNeedsYou({ prompts: this.ctx.prompts(), instances: this.ctx.instances(), deliveries, ownerOf: i => this.ctx.ownerOf(i) });
+        let tasks = [];
+        try {
+            tasks = this.ctx.tasks?.() ?? [];
+        }
+        catch (err) {
+            this.ctx.log("warn", "Needs you: could not read the task board", { err: String(err?.message ?? err) });
+        }
+        this.items = deriveNeedsYou({ prompts: this.ctx.prompts(), instances: this.ctx.instances(), deliveries, tasks, ownerOf: i => this.ctx.ownerOf(i) });
         const webSig = renderSignature(this.items, now);
         if (webSig !== this.webSignature) {
             this.webSignature = webSig;
@@ -91,20 +126,30 @@ export class NeedsYouHub {
         const settings = this.ctx.settings();
         const worlds = this.ctx.worlds();
         const worldIds = new Set(worlds.map(w => w.id));
-        for (const [id, pinned] of this.live) {
-            const current = worlds.find(w => w.id === id);
+        for (const [key, pinned] of this.live) {
+            const current = worlds.find(w => w.id === pinned.world);
             if (!settings.liveMessage || !current) {
-                this.live.delete(id);
-                this.worldSignature.delete(id);
+                this.live.delete(key);
+                this.worldSignature.delete(key);
+                this.worldSeen.delete(key);
                 void pinned.renderer.disable();
             }
             else if (current.adapter !== pinned.adapter || placeKey(current.place) !== pinned.placeKey) {
                 // Another adapter (or place) under the same id: the old renderer stops without touching anything — its adapter
                 // may be gone — and a new one picks up from the persisted pointer.
-                this.live.delete(id);
-                this.worldSignature.delete(id);
+                this.live.delete(key);
+                this.worldSignature.delete(key);
+                this.worldSeen.delete(key);
                 pinned.renderer.abandon();
             }
+            else if (pinned.lane !== null && !this.laneUsable(pinned.lane, pinned.world)) {
+                // #2352: the lane is gone from this world (its instance removed or moved, its channel gone): its message says
+                // so, without buttons, and is forgotten. A lane that is merely empty stays, saying nothing waits.
+                this.live.delete(key);
+                this.worldSignature.delete(key);
+                this.worldSeen.delete(key);
+                void pinned.renderer.disable(this.ctx.t("needs.live_moved"));
+            }
         }
         if (!settings.dm)
             for (const id of [...this.dmPending.keys()])
@@ -114,25 +159,39 @@ export class NeedsYouHub {
                 this.cancelDms(id);
         const seeding = !this.seeded;
         this.seeded = true;
+        const saved = settings.liveMessage ? Object.keys(this.readPointers()) : [];
         for (const world of worlds) {
             const mine = itemsForWorld(this.items, world.id);
-            if (seeding) {
-                this.worldSeen.set(world.id, new Set(mine.map(i => i.id)));
+            if (seeding)
                 this.dmSeen.set(world.id, new Set(mine.map(i => i.id)));
-            }
-            const seen = this.worldSeen.get(world.id) ?? new Set();
-            const fresh = mine.filter(i => !seen.has(i.id));
-            this.worldSeen.set(world.id, new Set(mine.map(i => i.id)));
             if (settings.liveMessage) {
-                let pinned = this.live.get(world.id);
-                if (!pinned) {
-                    pinned = { renderer: this.makeLive(world), adapter: world.adapter, placeKey: placeKey(world.place) };
-                    this.live.set(world.id, pinned);
-                }
-                const sig = renderSignature(mine, now);
-                if (sig !== this.worldSignature.get(world.id)) {
-                    this.worldSignature.set(world.id, sig);
-                    pinned.renderer.changed(fresh.length > 0);
+                // General, every lane with cards now, and every lane whose message is still out there (from before a restart,
+                // or emptied since): those render too, so a stale list never keeps its old lines.
+                const lanes = new Set(lanesOf(this.items, world.id));
+                for (const k of saved)
+                    if (k.startsWith(world.id + LANE_SEP))
+                        lanes.add(k.slice(world.id.length + LANE_SEP.length));
+                for (const [, pinned] of this.live)
+                    if (pinned.world === world.id && pinned.lane !== null)
+                        lanes.add(pinned.lane);
+                for (const lane of [null, ...[...lanes].filter(l => this.laneUsable(l, world.id))]) {
+                    const key = liveKey(world.id, lane);
+                    const listed = itemsForLane(this.items, world.id, lane);
+                    if (seeding)
+                        this.worldSeen.set(key, new Set(listed.map(i => i.id)));
+                    const seen = this.worldSeen.get(key) ?? new Set();
+                    const fresh = listed.filter(i => !seen.has(i.id));
+                    this.worldSeen.set(key, new Set(listed.map(i => i.id)));
+                    let pinned = this.live.get(key);
+                    if (!pinned) {
+                        pinned = { renderer: this.makeLive(world, lane), adapter: world.adapter, placeKey: placeKey(world.place), world: world.id, lane };
+                        this.live.set(key, pinned);
+                    }
+                    const sig = renderSignature(listed, now);
+                    if (sig !== this.worldSignature.get(key)) {
+                        this.worldSignature.set(key, sig);
+                        pinned.renderer.changed(fresh.length > 0);
+                    }
                 }
             }
             if (settings.dm)
@@ -172,27 +231,42 @@ export class NeedsYouHub {
             this.ctx.log("warn", "Needs you: could not save where the live message is", { world, err: String(err?.message ?? err) });
         }
     }
-    lineTitle(item) { return this.ctx.t(`needs.reason.${item.reason}`); }
-    makeLive(world) {
+    /** A line's words: why it waits — and for a card, which card and what it asks or lacks (the chat shows no detail). */
+    lineTitle(item) {
+        const reason = this.ctx.t(`needs.reason.${item.reason}`);
+        return item.type === "task" && item.detail ? `${reason}: ${item.detail}` : reason;
+    }
+    /** #2352: a lane can carry a list here: its instance is this world's now, and has a channel of its own. */
+    laneUsable(lane, world) {
+        return this.ctx.ownerOf(lane) === world && !!this.ctx.laneTarget?.(lane);
+    }
+    /** Where a list (General, or a lane's) is posted now, or null. */
+    listTarget(world, lane) {
+        if (!lane)
+            return this.ctx.noticeTarget(world);
+        return this.laneUsable(lane, world) ? this.ctx.laneTarget(lane) : null;
+    }
+    makeLive(world, lane) {
         const ctx = this.ctx;
-        const owner = Symbol(world.id);
+        const key = liveKey(world.id, lane);
+        const owner = Symbol(key);
         return new NeedsYouLiveMessage({
-            world: world.id,
+            world: key,
             now: () => ctx.mono(),
             setTimer: (fn, ms) => ctx.setTimer(fn, ms),
             clearTimer: h => ctx.clearTimer(h),
-            target: () => { const t = ctx.noticeTarget(world.id); return t ? canonicalTarget(t) : null; },
+            target: () => { const t = this.listTarget(world.id, lane); return t ? canonicalTarget(t) : null; },
             enabled: () => ctx.settings().liveMessage,
             stopping: () => ctx.stopping() || this.stopped,
             // The same world means the same adapter object and place it was built for, not just the same id.
             worldExists: () => ctx.worlds().some(w => w.id === world.id && w.adapter === world.adapter && placeKey(w.place) === placeKey(world.place)),
             content: () => {
-                const mine = itemsForWorld(this.items, world.id);
+                const mine = itemsForLane(this.items, world.id, lane);
                 const lines = mine.map(item => ({
                     item, title: this.lineTitle(item),
                     link: item.promptAt ? messageLink(world.place, item.promptAt) : instanceLink(world.place, ctx.instanceTopic(item.instance)),
                 }));
-                const rendered = renderLiveMessage(lines, ctx.now(), (k, ...a) => ctx.t(k, ...a));
+                const rendered = renderLiveMessage(lines, ctx.now(), (k, ...a) => ctx.t(k, ...a), lane ? "needs.live_header_lane" : "needs.live_header");
                 return { empty: mine.length === 0, ...rendered };
             },
             post: async (target, text, choices) => {
@@ -206,25 +280,36 @@ export class NeedsYouHub {
             },
             isEditLoss: isMessageEditLoss,
             remove: async (pointer) => { await world.adapter.deleteMessage?.(pointer.chatId, pointer.messageId, pointer.threadId); },
-            loadPointer: () => this.readPointers()[world.id] ?? null,
-            savePointer: pointer => this.writePointer(world.id, pointer),
-            mintAcks: (generation, place, items) => this.mintAcks(world.id, owner, generation, place, items),
+            loadPointer: () => this.readPointers()[key] ?? null,
+            savePointer: pointer => this.writePointer(key, pointer),
+            mintAcks: (generation, place, items) => this.mintAcks(world.id, owner, generation, place, items, lane),
             revokeAcks: () => this.revokeAcks(owner),
             log: (message, extra) => ctx.log("info", `Needs you: ${message}`, extra),
             text: { stopped: ctx.t("needs.live_stopped"), off: ctx.t("needs.live_off") },
         });
     }
-    mintAcks(world, owner, generation, place, items) {
+    mintAcks(world, owner, generation, place, items, lane = null) {
         const minted = [];
-        const choices = items.filter(i => i.deliveryId).map(item => {
+        const mint = (item, verb, label) => {
             const nonce = randomBytes(16).toString("hex");
             const entry = {
                 world, owner, generation, deadline: this.ctx.mono() + ACK_TTL_MS, chatId: place.chatId, ...(place.threadId !== undefined ? { threadId: place.threadId } : {}),
-                ...(place.messageId ? { messageId: place.messageId } : {}), deliveryId: item.deliveryId, instance: item.instance,
+                ...(place.messageId ? { messageId: place.messageId } : {}), verb, instance: item.instance, ...(lane ? { lane } : {}),
+                ...(item.deliveryId ? { deliveryId: item.deliveryId } : {}), ...(item.card ? { card: { ...item.card } } : {}),
             };
             this.acks.set(nonce, entry);
             minted.push(entry);
-            return { id: `${NEEDS_ACK_PREFIX}${nonce}:ack`, label: this.ctx.t("needs.ack_button", item.instance) };
+            return { id: `${NEEDS_ACK_PREFIX}${nonce}:${verb}`, label };
+        };
+        const choices = items.flatMap(item => {
+            if (item.deliveryId)
+                return [mint(item, "ack", this.ctx.t("needs.ack_button", item.instance))];
+            if (item.type !== "task" || !item.card)
+                return [];
+            const code = item.card.code;
+            return item.reason === "task_review"
+                ? [mint(item, "confirm", this.ctx.t("needs.task_confirm_button", code)), mint(item, "back", this.ctx.t("needs.task_back_button", code))]
+                : [mint(item, "answer", this.ctx.t("needs.task_answer_button", code))];
         });
         return { choices, bind: pointer => { for (const e of minted)
                 e.messageId = pointer.messageId; } };
@@ -244,7 +329,8 @@ export class NeedsYouHub {
         if (!data.callbackData.startsWith(NEEDS_ACK_PREFIX))
             return false;
         const m = ACK_RE.exec(data.callbackData);
-        const entry = m ? this.acks.get(m[1]) : undefined;
+        const found = m ? this.acks.get(m[1]) : undefined;
+        const entry = found && found.verb === m[2] ? found : undefined;
         if (entry && this.ctx.mono() >= entry.deadline)
             this.acks.delete(m[1]);
         // Unknown, revoked, lapsed — or not yet bound to the message its post returned: no authority yet.
@@ -263,13 +349,193 @@ export class NeedsYouHub {
             data.ack?.(this.ctx.t("buttons.admin_only"));
             return true;
         }
-        // §5.0: the item must still belong to this world.
-        if (this.ctx.ownerOf(entry.instance) !== adapterId) {
+        // §5.0: the item must still belong to this world — for a laned card, its lane's world (#2352).
+        if (this.ctx.ownerOf(entry.lane ?? entry.instance) !== adapterId) {
             data.ack?.(this.ctx.t("needs.ack_not_this_world"));
             return true;
         }
+        // #2352: and a card must still wait where this button showed it (its lead or dispatcher changed: elsewhere now).
+        // #2355 review: read now — the card's route (a lead changed) and the list's place (a lane's topic moved or went).
+        if (entry.card && (!this.stillInLane(entry.card.code, entry.lane) || !this.placeStill(adapterId, entry.lane, entry.chatId, entry.threadId))) {
+            data.ack?.(this.ctx.t("needs.task_moved"));
+            return true;
+        }
         const platform = this.ctx.worlds().find(w => w.id === adapterId)?.place.type ?? "chat";
-        data.ack?.(this.ctx.t(`needs.ack_${this.acknowledge(entry.deliveryId, `${platform}:${data.userId}`)}`));
+        if (entry.verb === "ack") {
+            data.ack?.(this.ctx.t(`needs.ack_${this.acknowledge(entry.deliveryId, `${platform}:${data.userId}`)}`));
+            return true;
+        }
+        const card = entry.card;
+        const by = { platform, userId: data.userId, ...(data.username ? { username: data.username } : {}) };
+        if (entry.verb === "confirm") {
+            const outcome = this.ctx.taskAction?.({ verb: "confirm", code: card.code, version: card.version, by }) ?? { ok: false, message: this.ctx.t("needs.task_board_closed") };
+            data.ack?.(outcome.message);
+            this.poke();
+            return true;
+        }
+        // Send back and Answer take words: a prompt the clicker answers by replying to it (handleReply). One prompt per
+        // world, card, person and verb at a time, reserved before the send (#2306 review): a second press while one is on
+        // its way or still waits is told so, and the prompts open over everything are capped.
+        const askKey = `${adapterId}|${card.code}|${data.userId}|${entry.verb}`;
+        if (this.asking.has(askKey) || this.pendingFor(askKey)) {
+            data.ack?.(this.ctx.t("needs.task_reply_already", card.code));
+            return true;
+        }
+        if (this.asking.size + this.livePending() >= TASK_REPLY_MAX) {
+            data.ack?.(this.ctx.t("needs.task_reply_busy"));
+            return true;
+        }
+        this.asking.add(askKey);
+        data.ack?.(this.ctx.t("needs.task_reply_asked"));
+        void this.askForReply(entry, entry.verb, by, askKey);
+        return true;
+    }
+    /**
+     * #2352: a card still routes to this lane (or, for no lane, to General) — asked of the board now (#2355 review: a
+     * project's lead can change with the card's version unchanged, and the last render may not have seen it yet). One
+     * that no longer waits for the person is left to the board, which answers by its version.
+     */
+    stillInLane(code, lane) {
+        if (this.ctx.taskRoute) {
+            const route = this.ctx.taskRoute(code);
+            return route === null || (route.lane ?? undefined) === lane;
+        }
+        const now = this.items.find(i => i.type === "task" && i.card?.code === code);
+        return !now || (now.lane ?? undefined) === lane;
+    }
+    /** #2355 review: a list's place (its lane's channel, or General) is still where this button or prompt is. */
+    placeStill(world, lane, chatId, threadId) {
+        const target = this.listTarget(world, lane);
+        return !!target && samePlace(target, { chatId, ...(threadId !== undefined ? { threadId } : {}) });
+    }
+    /** A prompt for this reservation still waits for its reply. */
+    pendingFor(askKey) {
+        const now = this.ctx.mono();
+        for (const r of this.replies.values())
+            if (r.askKey === askKey && now < r.deadline)
+                return true;
+        return false;
+    }
+    /** Prompts still waiting for their reply (lapsed ones go). */
+    livePending() {
+        const now = this.ctx.mono();
+        for (const [key, r] of this.replies)
+            if (now >= r.deadline)
+                this.replies.delete(key);
+        return this.replies.size;
+    }
+    /**
+     * The card's instance is still this world's, the world still the same connection in the same place, and its notice
+     * place still where the prompt is: else a reply there is not this world's to take (#2306 review — an instance that
+     * moved to another world, a replaced connection, a new notice room).
+     */
+    stillHere(p) {
+        if (this.ctx.ownerOf(p.lane ?? p.instance) !== p.world)
+            return false;
+        const now = this.ctx.worlds().find(w => w.id === p.world);
+        if (!now || now.adapter !== p.adapter || placeKey(now.place) !== p.placeKey)
+            return false;
+        // #2352: the card still waits in this lane, and the lane's (or General's) place is still where the prompt is.
+        if (p.code !== undefined && !this.stillInLane(p.code, p.lane))
+            return false;
+        return this.placeStill(p.world, p.lane, p.chatId, p.threadId);
+    }
+    /** Post the prompt for a Send back's reason or an answer, and wait for the clicker's reply to it. */
+    async askForReply(entry, verb, by, askKey) {
+        const card = entry.card;
+        try {
+            const world = this.ctx.worlds().find(w => w.id === entry.world);
+            if (!world || this.stopped)
+                return;
+            const target = { world: entry.world, instance: entry.instance, ...(entry.lane ? { lane: entry.lane } : {}), code: card.code,
+                adapter: world.adapter, placeKey: placeKey(world.place), chatId: entry.chatId, ...(entry.threadId !== undefined ? { threadId: entry.threadId } : {}) };
+            // #2355 review: and again before the prompt goes out — the card's route and the place as they are now.
+            if (!this.stillHere(target))
+                return;
+            const who = by.username ? ` (@${by.username})` : "";
+            const text = this.ctx.t(verb === "back" ? "needs.task_back_prompt" : "needs.task_answer_prompt", card.code, who, Math.round(TASK_REPLY_TTL_MS / 60_000));
+            const sent = await world.adapter.sendText(entry.chatId, text, entry.threadId !== undefined ? { threadId: entry.threadId } : undefined);
+            // While it was on its way the fleet may have stopped, or the card's instance, the connection or the room moved.
+            if (this.stopped || !this.stillHere(target))
+                return;
+            const pending = {
+                ...target, askKey, messageId: sent.messageId,
+                userId: by.userId, ...(by.username ? { username: by.username } : {}), verb, code: card.code, version: card.version,
+                deadline: this.ctx.mono() + TASK_REPLY_TTL_MS,
+            };
+            this.replies.set(`${entry.chatId}|${sent.messageId}`, pending);
+        }
+        catch (err) {
+            this.ctx.log("warn", "Needs you: could not ask for a reply", { code: card.code, err: String(err?.message ?? err) });
+        }
+        finally {
+            this.asking.delete(askKey);
+        }
+    }
+    /**
+     * An inbound message that replies to one of our Send back / Answer prompts, by the admin who clicked: its text is
+     * the reason or the answer, and the message goes no further (true). Anything else — another message, another
+     * person, a lapsed prompt — is not ours (false) and flows on as usual.
+     */
+    handleReply(msg) {
+        if (!msg.replyTo)
+            return false;
+        // #2306 review: found by where the prompt is, whichever bot received the reply (in a shared Discord guild a
+        // sibling bot's copy may come first), and judged by the prompt's world — its admins, its instance, its connection
+        // and room as they are now — so the answer is taken once, and only with that world's authority.
+        const key = `${msg.chatId}|${msg.replyTo}`;
+        const pending = this.replies.get(key);
+        if (!pending)
+            return false;
+        if (this.ctx.mono() >= pending.deadline) {
+            this.replies.delete(key);
+            return false;
+        }
+        if (msg.userId !== pending.userId || (pending.threadId !== undefined && msg.threadId !== undefined && msg.threadId !== pending.threadId))
+            return false;
+        if (!this.ctx.isFleetAdmin(msg.userId, pending.world))
+            return false;
+        if (!this.stillHere(pending)) {
+            this.replies.delete(key);
+            return false;
+        }
+        this.replies.delete(key);
+        if (msg.messageId) {
+            this.taken.set(`${msg.chatId}|${msg.messageId}`, this.ctx.mono() + TASK_REPLY_TTL_MS);
+            for (const [k, until] of this.taken)
+                if (this.taken.size > 256 || this.ctx.mono() >= until)
+                    this.taken.delete(k);
+                else
+                    break;
+        }
+        const text = msg.text.trim();
+        const world = this.ctx.worlds().find(w => w.id === pending.world);
+        const platform = world?.place.type ?? "chat";
+        const outcome = text
+            ? this.ctx.taskAction?.({ verb: pending.verb, code: pending.code, version: pending.version, text,
+                by: { platform, userId: msg.userId, ...(msg.username ? { username: msg.username } : {}) } }) ?? { ok: false, message: this.ctx.t("needs.task_board_closed") }
+            : { ok: false, message: this.ctx.t("needs.task_reply_empty", pending.code) };
+        this.poke();
+        if (world) {
+            void world.adapter.sendText(msg.chatId, outcome.message, { ...(msg.threadId !== undefined ? { threadId: msg.threadId } : {}), replyTo: msg.messageId })
+                .catch(err => this.ctx.log("warn", "Needs you: could not answer a reply", { code: pending.code, err: String(err?.message ?? err) }));
+        }
+        return true;
+    }
+    /**
+     * #2341 review r2: this message (another bot's copy of it) was already taken as a prompt's answer. The inbound handler
+     * asks it first and drops the copy: it is neither a second answer nor an agent's input.
+     */
+    wasTakenReply(chatId, messageId) {
+        if (!messageId)
+            return false;
+        const until = this.taken.get(`${chatId}|${messageId}`);
+        if (until === undefined)
+            return false;
+        if (this.ctx.mono() >= until) {
+            this.taken.delete(`${chatId}|${messageId}`);
+            return false;
+        }
         return true;
     }
     /** The web's Acknowledge: any item (the web is global, §5.0). `principal` is "web:<session handle>" or "cli". */
@@ -392,6 +658,9 @@ export class NeedsYouHub {
             this.cancelDms(id);
         await Promise.all([...this.live.values()].map(p => p.renderer.retire()));
         this.acks.clear();
+        this.replies.clear();
+        this.asking.clear();
+        this.taken.clear();
     }
 }
 //# sourceMappingURL=needs-you-hub.js.map