toolroll 0.5.0

package/dist/teammate-desk.js

@@ -0,0 +1,154 @@
+/**
+ * A teammate's desk (v96): its own flow, where anything asked of it directly
+ * lands as a card — a message to it by name in a chat app ("@rosa, where's
+ * order 2201?", or "Rosa: …"), or one of its routines ("every weekday at
+ * 9:00: …") — and its answer goes back to whoever asked.
+ *
+ * The desk is an ordinary flow its manager owns and can redraw. The teammate
+ * handles each card there within its rules and tools (asking first when they
+ * say to), writes its answer, and picks where the card goes: Done, a code
+ * change (the Build zone files an ordinary task that a person approves as
+ * usual), or its manager. Nothing here gives it more than its rules do.
+ */
+import { flowCardHref, flowDefinitionOf } from "./flow-engine.js";
+import { flowFromSteps } from "./flows.js";
+import { addFlowTriggerTo, removeFlowTrigger, runScheduleNow, scheduleFromWords, triggerConfigOf } from "./flow-triggers.js";
+import { describeSchedule, parseSchedule } from "./routine.js";
+import { labelOf, nameOf } from "./teammate-admin.js";
+/** The zone on a desk where the teammate handles what it's asked. */
+export const DESK_ZONE = "handle";
+const DESK_INSTRUCTIONS = "Someone asked you this directly, or it's one of your routines. Do what they ask within your rules, using your tools when it needs them, and write your answer to them in \"text\": it goes back to whoever asked. Pick Done when you've answered, Needs a code change when what they want is a change to this project's code (it's filed as a task for a person to approve), and Needs a person when it's beyond you.";
+/** Its desk, when it has one. */
+export function deskOf(store, mate) {
+    const flow = mate.deskFlow === null ? null : store.getFlow(mate.deskFlow);
+    return flow !== null && flow.state === "active" ? flow : null;
+}
+/** Its desk, made the first time it's needed: owned by its manager, drawn like any flow. */
+export function ensureDesk(store, mate, now) {
+    const had = deskOf(store, mate);
+    if (had !== null)
+        return had;
+    const name = nameOf(mate);
+    const person = `For ${mate.manager}`.slice(0, 60);
+    const definition = flowFromSteps([
+        { id: DESK_ZONE, title: "Requests", kind: "teammate", teammate: mate.handle, reply: true, instructions: DESK_INSTRUCTIONS,
+            routes: [{ answer: "Done", goesTo: "Done" }, { answer: "Needs a code change", goesTo: "Build it" }, { answer: "Needs a person", goesTo: person }], ifFails: person },
+        { id: "build", title: "Build it", kind: "task", planning: "auto", next: "Done" },
+        { id: "person", title: person, kind: "inbox" },
+        { id: "done", title: "Done", kind: "done" },
+    ], null);
+    const id = store.createFlow({ repo: mate.repo, name: `${name}'s desk`.slice(0, 80), definitionJson: JSON.stringify(definition), by: mate.manager }, now);
+    store.setTeammateDesk(mate.id, id);
+    return store.getFlow(id);
+}
+/** Who a desk card's answer goes to: the person who asked (when they can see the project), else its manager. */
+export function askerOf(store, flow, card, mate) {
+    return store.accountOf(card.createdBy) !== null && store.accountCanAccess(card.createdBy, flow.repo) ? card.createdBy : mate.manager;
+}
+/** The answer a teammate wrote, back to whoever asked, under its name. Once per visit. */
+export function replyToAsker(store, flow, card, mate, text, now) {
+    const to = askerOf(store, flow, card, mate);
+    store.enqueueNotification({ dedupeKey: `teammate-reply:${card.id}:${card.entry}`, kind: "teammate-reply", recipient: to, subject: `${labelOf(mate)}: ${card.title}`.slice(0, 200),
+        body: text.slice(0, 3500), link: flowCardHref(flow.id, card.id), source: { project: flow.repo } }, now);
+}
+/** "@rosa …", "@rosa, …", "Rosa: …" or "Rosa, …": the teammate a message is addressed to, and what it says. */
+export function addressedTo(text) {
+    const at = /^\s*@([\p{L}\p{N}][\p{L}\p{N}-]{0,31})[\s,:]+([\s\S]*\S[\s\S]*)$/u.exec(text);
+    if (at !== null)
+        return { name: at[1], said: at[2].trim() };
+    const named = /^\s*([\p{L}][\p{L}\p{N}-]{0,31})\s*[,:]\s+([\s\S]*\S[\s\S]*)$/u.exec(text);
+    return named === null ? null : { name: named[1], said: named[2].trim() };
+}
+/**
+ * A message in someone's chat with Toolroll, addressed to a teammate
+ * by name, becomes a card on its desk; null when it isn't addressed to one of
+ * the teammates in their projects (it goes to the lead as usual).
+ */
+export function messageTeammate(store, from, text, now) {
+    const addressed = addressedTo(text);
+    if (addressed === null)
+        return null;
+    const wanted = addressed.name.toLowerCase();
+    const mate = store.teammates(from.repos).find(one => one.handle === wanted || nameOf(one).toLowerCase() === wanted);
+    if (mate === undefined || !store.accountCanAccess(from.who, mate.repo))
+        return null;
+    const name = nameOf(mate);
+    if (mate.state !== "active")
+        return { said: `${name} is paused, so nothing was passed on. Resume ${name} on its page, or ask the lead.` };
+    const desk = ensureDesk(store, mate, now);
+    const definition = flowDefinitionOf(desk);
+    const zone = definition?.stages.find(one => one.id === DESK_ZONE) ?? definition?.stages.find(one => one.id === definition.start);
+    if (zone === undefined)
+        return { said: `${name}'s desk can't take cards right now.` };
+    const said = addressed.said.slice(0, 4000);
+    const firstLine = said.split("\n")[0].trim();
+    const title = firstLine.length <= 100 ? firstLine : `${firstLine.slice(0, 99)}…`;
+    const card = store.addFlowCard({ flow: desk.id, title, description: said === title ? null : said, stage: zone.id, by: from.who, source: { kind: "message", label: `${from.via} message`, url: null } }, now);
+    store.setFlowCardWatcher(card, from.who, true, now);
+    return { said: `${name} has it. The answer comes here when it's done.`, link: { label: "Open the card", path: flowCardHref(desk.id, card) } };
+}
+/** Its routines: the schedules on its desk that start in its zone. */
+export function routinesOf(store, mate) {
+    const desk = deskOf(store, mate);
+    if (desk === null)
+        return [];
+    return store.flowTriggers(desk.id).flatMap(trigger => {
+        const config = triggerConfigOf(trigger);
+        if (config?.kind !== "schedule" || config.script !== undefined || trigger.state === "removed")
+            return [];
+        return [{ id: trigger.id, schedule: config.schedule, text: config.title, state: trigger.state, lastAt: trigger.lastAt, lastOutcome: trigger.lastOutcome, nextAt: trigger.nextAt }];
+    });
+}
+/** This computer's time zone: what a routine's time means when it names none. */
+export const localZone = () => { try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+}
+catch {
+    return "UTC";
+} };
+/** A routine's schedule as kept: a calendar time with no zone is this computer's time, not UTC. */
+export function routineSchedule(words) {
+    const read = scheduleFromWords(words);
+    // A zone the person named, UTC included, stays theirs.
+    if (read === null || read.startsWith("every:") || read.includes("@") || /\b(utc|gmt)$/i.test(words.trim()))
+        return read;
+    return scheduleFromWords(`${words.trim()} ${localZone()}`) ?? read;
+}
+/** A routine: on this schedule ("weekdays 09:00", "daily 17:00 Europe/London", "every 2 hours"), a card on its desk saying what to do. */
+export function addRoutine(store, mate, schedule, text, by, now, dir) {
+    const what = text.replace(/\s+/g, " ").trim();
+    if (what === "")
+        return { ok: false, said: "Say what it should do each time." };
+    if (what.length > 200)
+        return { ok: false, said: "Keep a routine to 200 characters; put detail in its soul file." };
+    if (routinesOf(store, mate).length >= 10)
+        return { ok: false, said: "A teammate has at most 10 routines." };
+    const kept = routineSchedule(schedule);
+    if (kept === null)
+        return { ok: false, said: "Say the schedule like “weekdays 09:00”, “daily 17:00”, “monday 09:00” or “every 2 hours”." };
+    const desk = ensureDesk(store, mate, now);
+    const made = addFlowTriggerTo(store, desk, { kind: "schedule", schedule: kept, title: what, zone: DESK_ZONE }, by, now, dir);
+    return made.ok ? { ok: true, said: `${nameOf(mate)} will do that ${describeSchedule(parseSchedule(kept))}. Its answer goes to ${mate.manager}.` } : { ok: false, said: made.message };
+}
+function routineOf(store, mate, id) {
+    const desk = deskOf(store, mate);
+    const trigger = desk === null ? null : store.flowTriggers(desk.id).find(one => one.id === id) ?? null;
+    return trigger !== null && trigger.state !== "removed" ? trigger : null;
+}
+export function removeRoutine(store, mate, id, now, dir) {
+    const trigger = routineOf(store, mate, id);
+    if (trigger === null)
+        return { ok: false, said: "That routine is already gone." };
+    removeFlowTrigger(store, trigger, now, dir);
+    return { ok: true, said: "Removed. It won't do that any more." };
+}
+/** Try a routine now: its card lands on the desk at once. */
+export function runRoutine(store, mate, id, by, now) {
+    const trigger = routineOf(store, mate, id);
+    if (trigger === null)
+        return { ok: false, said: "That routine is gone." };
+    if (mate.state !== "active")
+        return { ok: false, said: `${nameOf(mate)} is paused. Resume it first.` };
+    const ran = runScheduleNow(store, trigger, by, now);
+    return ran.ok ? { ok: true, said: `${nameOf(mate)} is on it. The answer goes to ${mate.manager}.` } : ran;
+}

package/dist/teammate-memory.d.ts

@@ -0,0 +1,64 @@
+import type { Store, TeammateCallRow, TeammateMemoryRow, TeammateRow } from "./store.js";
+export declare const MEMORY_CHARS = 300;
+/** Facts a teammate keeps on its own: past this, its oldest are forgotten. What people told it is never dropped this way. */
+export declare const MEMORY_CAP = 300;
+/** Approvals in a row of one action before the teammate suggests loosening its rule. */
+export declare const SUGGEST_AFTER = 5;
+export declare const ACCEPT = "accept", DISMISS = "dismiss";
+type Done = {
+    ok: true;
+    said: string;
+} | {
+    ok: false;
+    said: string;
+};
+/** The words a text is about: lower case, four letters or more, no filler. */
+export declare function wordsOf(text: string): string[];
+/** Two lines about the same thing: most of their words are shared. */
+export declare function similar(a: string, b: string): boolean;
+/** A memory as it may be kept: one line, plain, short, no secrets. */
+export declare function cleanMemory(text: string): {
+    ok: true;
+    text: string;
+} | {
+    ok: false;
+    said: string;
+};
+/** Keep one thing: from a person (what they told it), or from the teammate itself on a turn. The same words twice are kept once. */
+export declare function remember(store: Store, mate: TeammateRow, text: string, from: {
+    source: TeammateMemoryRow["source"];
+    card?: number | null;
+    by: string;
+}, now: Date): Done & {
+    id?: number;
+};
+/** Something a person tells a teammate (the page's "Tell Maya something", or the lead): kept in its memory, read by every turn while it's among the latest ten. */
+export declare function tellTeammate(store: Store, mate: TeammateRow, note: string, by: string, now: Date): Done;
+export declare function editMemory(store: Store, mate: TeammateRow, id: number, text: string, by: string, now: Date): Done;
+export declare function forgetMemory(store: Store, mate: TeammateRow, id: number, by: string, now: Date): Done;
+/** Memories whose text holds every word searched for. */
+export declare function searchMemories(store: Store, mate: TeammateRow, query: string): TeammateMemoryRow[];
+/**
+ * What one turn reads: what its people told it lately (oldest first), and
+ * what it kept that fits the card — the facts sharing most of the card's
+ * words, then its newest — up to eight.
+ */
+export declare function memoriesFor(store: Store, mate: TeammateRow, cardText: string, now: Date): {
+    told: TeammateMemoryRow[];
+    kept: TeammateMemoryRow[];
+};
+/** A limit a person would pick: rounded up to a round number. */
+export declare const roundUp: (value: number) => number;
+/**
+ * After a person approves an ask-first call: when they have approved this
+ * action enough times in a row since it last suggested anything about it,
+ * the teammate suggests the rule that would have let it make them all.
+ */
+export declare function considerSuggestion(store: Store, mate: TeammateRow, approved: TeammateCallRow, now: Date): number | null;
+/** Its manager answers a suggestion: accept changes the one rule (if it is still what it was), anything else leaves it; their words are remembered. */
+export declare function answerSuggestion(store: Store, mate: TeammateRow, suggestion: number, answer: {
+    choice: string | null;
+    text: string | null;
+    by: string;
+}, now: Date): Done;
+export {};

package/dist/teammate-memory.js

@@ -0,0 +1,196 @@
+/**
+ * What a teammate remembers (v95), and how it learns from its people.
+ *
+ * Memory is short facts, each a line: what its people told it ("this week,
+ * offer free shipping instead of a refund" — v92's notes), and what it kept
+ * from its own turns ("Sam prefers email to phone"). Every turn reads what
+ * its people said lately, and what it kept that fits the card. People search,
+ * edit and forget any of it on the teammate's page or through the lead.
+ *
+ * Learning: when its manager approves the same ask-first tool action again
+ * and again (five in a row, none denied), the teammate suggests loosening
+ * that one rule — "You approved my last 5 refunds (amount 55 to 70): may I
+ * make them on my own up to 75?" — as a question its manager accepts or
+ * not, in their chat app or on its page. Accepting changes only that rule,
+ * and only if it is still what it was when suggested.
+ */
+import { scanForSecrets } from "./evidence.js";
+import { notifyPeople } from "./flow-people.js";
+import { labelOf, nameOf } from "./teammate-admin.js";
+import { defaultRule, numberFields, setToolRules } from "./teammate-tools.js";
+export const MEMORY_CHARS = 300;
+/** Facts a teammate keeps on its own: past this, its oldest are forgotten. What people told it is never dropped this way. */
+export const MEMORY_CAP = 300;
+/** Approvals in a row of one action before the teammate suggests loosening its rule. */
+export const SUGGEST_AFTER = 5;
+export const ACCEPT = "accept", DISMISS = "dismiss";
+const STOP = new Set("about after again also been before being could does doing from have here into just like more most much must only other over same some such than that their them then there these they this those through very want were what when where which while will with would your yours please thanks thank hello".split(" "));
+/** The words a text is about: lower case, four letters or more, no filler. */
+export function wordsOf(text) {
+    return [...new Set(text.toLowerCase().normalize("NFKD").split(/[^\p{L}\p{N}]+/u).filter(one => one.length >= 4 && !STOP.has(one)))].slice(0, 60);
+}
+/** Two lines about the same thing: most of their words are shared. */
+export function similar(a, b) {
+    const left = new Set(wordsOf(a)), right = new Set(wordsOf(b));
+    if (left.size === 0 || right.size === 0)
+        return false;
+    const shared = [...left].filter(one => right.has(one)).length;
+    return shared / new Set([...left, ...right]).size >= 0.6;
+}
+/** A memory as it may be kept: one line, plain, short, no secrets. */
+export function cleanMemory(text) {
+    const line = text.replace(/[\u0000-\u001f\u007f]+/g, " ").replace(/\s+/g, " ").trim();
+    if (line === "")
+        return { ok: false, said: "Write what it should remember." };
+    if (line.length > MEMORY_CHARS)
+        return { ok: false, said: `Keep a memory to ${MEMORY_CHARS} characters; put lasting rules in its soul file.` };
+    if (scanForSecrets(line).length > 0)
+        return { ok: false, said: "That looks like a key or password. Keep secrets out of a teammate's memory." };
+    return { ok: true, text: line };
+}
+/** Keep one thing: from a person (what they told it), or from the teammate itself on a turn. The same words twice are kept once. */
+export function remember(store, mate, text, from, now) {
+    const clean = cleanMemory(from.source === "teammate" ? text.slice(0, MEMORY_CHARS) : text);
+    if (!clean.ok)
+        return clean;
+    const same = store.teammateMemories(mate.id).find(one => one.text.toLowerCase() === clean.text.toLowerCase());
+    if (same !== undefined)
+        return { ok: true, said: `${nameOf(mate)} already remembers that.`, id: same.id };
+    // Saying nearly the same thing again on the same card (another turn of the same visit) refreshes what it kept instead of adding a second line.
+    if (from.source === "teammate" && from.card !== undefined && from.card !== null) {
+        const near = store.teammateMemories(mate.id, { source: "teammate" }).find(one => one.card === from.card && similar(one.text, clean.text));
+        if (near !== undefined) {
+            store.editTeammateMemory(near.id, clean.text, from.by, now);
+            return { ok: true, said: `${nameOf(mate)} already remembers that.`, id: near.id };
+        }
+    }
+    const id = store.addTeammateMemory({ teammate: mate.id, text: clean.text, source: from.source, card: from.card ?? null, by: from.by }, now);
+    if (from.source === "teammate")
+        for (const old of store.teammateMemories(mate.id, { source: "teammate" }).slice(MEMORY_CAP))
+            store.forgetTeammateMemory(old.id, "limit", now);
+    return { ok: true, said: `${nameOf(mate)} will remember that.`, id };
+}
+/** Something a person tells a teammate (the page's "Tell Maya something", or the lead): kept in its memory, read by every turn while it's among the latest ten. */
+export function tellTeammate(store, mate, note, by, now) {
+    const kept = remember(store, mate, note, { source: "person", by }, now);
+    return kept.ok ? { ok: true, said: `${nameOf(mate)} will keep that in mind.` } : kept;
+}
+export function editMemory(store, mate, id, text, by, now) {
+    const memory = store.teammateMemory(id);
+    if (memory === null || memory.teammate !== mate.id)
+        return { ok: false, said: "It doesn't remember that any more." };
+    const clean = cleanMemory(text);
+    if (!clean.ok)
+        return clean;
+    store.editTeammateMemory(id, clean.text, by, now);
+    return { ok: true, said: "Saved." };
+}
+export function forgetMemory(store, mate, id, by, now) {
+    const memory = store.teammateMemory(id);
+    if (memory === null || memory.teammate !== mate.id)
+        return { ok: false, said: "It doesn't remember that any more." };
+    store.forgetTeammateMemory(id, by, now);
+    return { ok: true, said: `${nameOf(mate)} forgot it.` };
+}
+/** Memories whose text holds every word searched for. */
+export function searchMemories(store, mate, query) {
+    const words = query.toLowerCase().split(/[^\p{L}\p{N}$]+/u).filter(one => one.length >= 2);
+    return store.teammateMemories(mate.id, { words, limit: 100 });
+}
+/**
+ * What one turn reads: what its people told it lately (oldest first), and
+ * what it kept that fits the card — the facts sharing most of the card's
+ * words, then its newest — up to eight.
+ */
+export function memoriesFor(store, mate, cardText, now) {
+    const told = store.teammateMemories(mate.id, { source: "person", limit: 10 }).reverse();
+    const own = store.teammateMemories(mate.id, { source: "teammate", limit: MEMORY_CAP });
+    const words = wordsOf(cardText);
+    const scored = own.map(one => ({ one, score: words.filter(word => one.text.toLowerCase().includes(word)).length })).filter(one => one.score > 0)
+        .sort((a, b) => b.score - a.score || b.one.id - a.one.id).slice(0, 6).map(one => one.one);
+    const kept = [...scored, ...own.filter(one => !scored.includes(one))].slice(0, 8);
+    store.markTeammateMemoriesUsed(kept.map(one => one.id), now);
+    return { told, kept };
+}
+const numberOf = (value) => typeof value === "number" && Number.isFinite(value) ? value
+    : typeof value === "string" && /^\s*\$?\d+(\.\d+)?\s*$/.test(value) ? Number(value.replace(/[$\s]/g, "")) : null;
+/** A limit a person would pick: rounded up to a round number. */
+export const roundUp = (value) => { const step = value < 20 ? 1 : value < 100 ? 5 : value < 1000 ? 25 : 100; return Math.ceil(value / step) * step; };
+/**
+ * After a person approves an ask-first call: when they have approved this
+ * action enough times in a row since it last suggested anything about it,
+ * the teammate suggests the rule that would have let it make them all.
+ */
+export function considerSuggestion(store, mate, approved, now) {
+    const grant = store.teammateGrant(mate.id, approved.tool);
+    const info = grant?.actions.find(one => one.name === approved.action);
+    if (grant === null || info === undefined)
+        return null;
+    const rule = grant.rules[approved.action] ?? defaultRule(info);
+    if (rule.use === "never" || (rule.use === "free" && rule.limit === undefined))
+        return null;
+    const earlier = store.teammateSuggestionsFor(mate.id, approved.tool, approved.action);
+    if (earlier.some(one => one.state === "open"))
+        return null;
+    const since = earlier[0]?.createdAt ?? "";
+    const run = [];
+    for (const call of store.teammateCallsOf(mate.id, 400).filter(one => one.tool === approved.tool && one.action === approved.action && one.rule === "ask" && one.decidedBy !== null && (one.decidedAt ?? "") > since)) {
+        if (call.state === "denied")
+            break;
+        run.push(call);
+    }
+    if (run.length < SUGGEST_AFTER)
+        return null;
+    // The number the rule is limited on (or, with none, the one every approved call gave).
+    const field = rule.limit?.field ?? numberFields(info).find(name => run.every(call => numberOf(call.input[name]) !== null)) ?? null;
+    const values = field === null ? [] : run.map(call => numberOf(call.input[field])).filter((one) => one !== null);
+    let suggested, range = "";
+    if (field !== null && values.length === run.length) {
+        const over = roundUp(Math.max(...values));
+        if (rule.limit !== undefined && over <= rule.limit.over)
+            return null;
+        suggested = { use: "free", limit: { field, over } };
+        const low = Math.min(...values), high = Math.max(...values);
+        range = ` (${field} ${low === high ? low : `${low} to ${high}`})`;
+    }
+    else {
+        suggested = { use: "free" };
+    }
+    const card = store.getFlowCard(approved.card);
+    if (card === null)
+        return null;
+    const said = suggested.limit === undefined
+        ? `You approved my last ${run.length} ${approved.action} calls on ${approved.tool}. May I make them on my own from now on?`
+        : `You approved my last ${run.length} ${approved.action} calls on ${approved.tool}${range}. May I make them on my own up to ${suggested.limit.field} ${suggested.limit.over}, and ask you above that?`;
+    const id = store.addTeammateSuggestion({ teammate: mate.id, tool: approved.tool, action: approved.action, rule: suggested, was: rule, evidence: run.map(one => one.id), said }, now);
+    const question = store.openTeammateQuestion({ teammate: mate.id, card: card.id, entry: approved.entry, question: said, options: [{ id: ACCEPT, label: "Yes, change it" }, { id: DISMISS, label: "Not now" }], askedOf: mate.manager, suggestion: id }, now);
+    if (question === null)
+        return id;
+    notifyPeople(store, card, [mate.manager], null, { key: `teammate-q:${question}`, attention: false, subject: `${labelOf(mate)} suggests a rule change`,
+        body: `${said}\n\nThis changes only that one rule; you can change it back on ${nameOf(mate)}'s page.` }, now);
+    return id;
+}
+/** Its manager answers a suggestion: accept changes the one rule (if it is still what it was), anything else leaves it; their words are remembered. */
+export function answerSuggestion(store, mate, suggestion, answer, now) {
+    const offered = store.teammateSuggestion(suggestion);
+    if (offered === null || offered.state !== "open")
+        return { ok: false, said: "That suggestion was already answered." };
+    if (answer.choice === ACCEPT) {
+        const grant = store.teammateGrant(mate.id, offered.tool);
+        const current = grant === null ? null : grant.rules[offered.action] ?? null;
+        const { undo: _undo, ...compared } = current ?? { use: "never" };
+        if (current === null || JSON.stringify(compared) !== JSON.stringify((({ undo: _was, ...rest }) => rest)(offered.was))) {
+            store.decideTeammateSuggestion(offered.id, "stale", null, now);
+            return { ok: false, said: "Its rules changed since it suggested this, so nothing was changed." };
+        }
+        const changed = setToolRules(store, mate, offered.tool, { [offered.action]: { use: offered.rule.use, limit: offered.rule.limit ?? null, undo: current.undo ?? "" } }, answer.by, now);
+        if (!changed.ok)
+            return changed;
+        store.decideTeammateSuggestion(offered.id, "accepted", answer.by, now);
+        return { ok: true, said: `Changed. ${nameOf(mate)} makes ${offered.action} calls on its own ${offered.rule.limit === undefined ? "from now on" : `up to ${offered.rule.limit.field} ${offered.rule.limit.over}`}.` };
+    }
+    store.decideTeammateSuggestion(offered.id, "dismissed", answer.by, now);
+    if (answer.text !== null && answer.text.trim() !== "")
+        remember(store, mate, `About ${offered.action} on ${offered.tool}: ${answer.text.trim()}`.slice(0, MEMORY_CHARS), { source: "person", by: answer.by }, now);
+    return { ok: true, said: "Left as it is." };
+}

package/dist/teammate-question.d.ts

@@ -0,0 +1,59 @@
+import type { ChatBinding, ChatContent, ChatEvent, ChatState } from "./chat-delivery-state.js";
+import type { Store, TelegramBinding, TeammateQuestionRow } from "./store.js";
+import type { InlineButton } from "./telegram-mate.js";
+/** The key notifyPeople gives a teammate's question: flow-card:<card>:teammate-q:<question>:<person>. */
+export declare const TEAMMATE_Q_KEY: RegExp;
+export declare const IN_WORDS = "Answer in words";
+/** The question a notice is about, while it is still open. */
+export declare function openQuestionOf(store: Store, dedupeKey: string): TeammateQuestionRow | null;
+/** Buttons for the question, minted before the send (for the person it asks only); `place` stamps the message they land on. */
+export declare function telegramQuestionButtons(store: Store, binding: TelegramBinding, question: TeammateQuestionRow, now: Date): {
+    keyboard: InlineButton[][];
+    tokens: string[];
+} | null;
+export type QuestionTapEffect = {
+    kind: "ack";
+    text: string;
+} | {
+    kind: "edit";
+    text: string;
+} | {
+    kind: "prompt";
+    text: string;
+    placeholder: string;
+    question: number;
+};
+/** A tapped question button, inside the update's transaction. */
+export declare function applyTelegramQuestionTap(store: Store, binding: TelegramBinding, action: NonNullable<ReturnType<Store["getTelegramQuestionAction"]>>, message: {
+    text: string;
+}, now: Date): QuestionTapEffect[];
+/** A reply to the "answer in words" prompt, inside the update's transaction. */
+export declare function applyTelegramQuestionReply(store: Store, binding: TelegramBinding, prompt: NonNullable<ReturnType<Store["telegramQuestionPrompt"]>>, text: string, now: Date): string | null;
+/** A question notice as chat parts (the buttons on the last), or null when it isn't one, isn't for this person, or was answered. */
+export declare function questionParts(store: Store, notification: {
+    dedupeKey: string;
+    subject: string;
+    body: string;
+    link: string | null;
+}, binding: ChatBinding): ChatContent[] | null;
+/** The live buttons on one part, in the order they were minted. */
+export declare function chatQuestionButtons(state: ChatState, part: number, now: Date): Array<{
+    token: string;
+    label: string;
+    words: boolean;
+}>;
+/** A tapped question button, inside the action's transaction; false when the token isn't one. */
+export declare function applyChatQuestionTap(options: {
+    store: Store;
+    state: ChatState;
+    label: string;
+}, event: ChatEvent, binding: ChatBinding, token: string, now: Date): boolean;
+/** The person's message while an "answer in words" prompt is open: the answer. false when none is open. */
+export declare function answerChatQuestionPrompt(options: {
+    store: Store;
+    state: ChatState;
+    label: string;
+}, event: ChatEvent, binding: ChatBinding, input: {
+    text: string;
+    originalLength?: number;
+}, now: Date): boolean;

package/dist/teammate-question.js

@@ -0,0 +1,175 @@
+/**
+ * A teammate's question, answered in the chat app (v93).
+ *
+ * When a teammate asks its person something ("Refund all $200, or half?"),
+ * the notice reaches them in their chat app under the teammate's name, with
+ * one button per option and one to answer in their own words. A tap answers
+ * at once; "Answer in words" opens a prompt: on Telegram, a reply to it; in
+ * Slack, Discord and Teams, their next message in their chat with Standing
+ * Orders ("cancel" leaves it). Either way the answer goes through the same
+ * door as the card's own panel (answerTeammateQuestion): once, and only from
+ * the person it was asked of. Answered anywhere, every button retires.
+ */
+import { randomBytes } from "node:crypto";
+import { answerTeammateQuestion } from "./teammate-work.js";
+import { labelOf } from "./teammate-admin.js";
+/** The key notifyPeople gives a teammate's question: flow-card:<card>:teammate-q:<question>:<person>. */
+export const TEAMMATE_Q_KEY = /^flow-card:[1-9][0-9]{0,14}:teammate-q:([1-9][0-9]{0,14}):/;
+export const IN_WORDS = "Answer in words";
+const PROMPT_MS = 30 * 60_000;
+const ANSWER_CHARS = 2000;
+/** The question a notice is about, while it is still open. */
+export function openQuestionOf(store, dedupeKey) {
+    const match = TEAMMATE_Q_KEY.exec(dedupeKey);
+    const question = match === null ? null : store.teammateQuestion(Number(match[1]));
+    return question !== null && question.state === "open" ? question : null;
+}
+const who = (store, question) => { const mate = store.getTeammate(question.teammate); return mate === null ? "Your teammate" : labelOf(mate).split(" · ")[0]; };
+/** Everyone else's buttons retire once a question is answered anywhere. */
+function retireEverywhere(store, question, now, state) {
+    store.retireTelegramQuestion(question, now);
+    state?.prepare("UPDATE chat_question_action SET consumed=? WHERE question=? AND consumed IS NULL").run(now.toISOString(), question);
+    state?.prepare("UPDATE chat_question_prompt SET consumed=? WHERE question=? AND consumed IS NULL").run(now.toISOString(), question);
+}
+// ---- Telegram ----------------------------------------------------------------------
+/** Buttons for the question, minted before the send (for the person it asks only); `place` stamps the message they land on. */
+export function telegramQuestionButtons(store, binding, question, now) {
+    if (binding.approver !== question.askedOf)
+        return null;
+    const choices = [...question.options.map(one => ({ token: randomBytes(16).toString("hex"), choice: one.id, label: one.label })), { token: randomBytes(16).toString("hex"), choice: null, label: `✏️ ${IN_WORDS}` }];
+    store.createTelegramQuestionActions({ binding: binding.id, chatId: binding.chatId, question: question.id }, choices, now);
+    const rows = [];
+    const options = choices.filter(one => one.choice !== null);
+    for (let at = 0; at < options.length; at += 2)
+        rows.push(options.slice(at, at + 2).map(one => ({ text: one.label.slice(0, 60), callback_data: one.token })));
+    rows.push([{ text: choices.at(-1).label, callback_data: choices.at(-1).token }]);
+    return { keyboard: rows, tokens: choices.map(one => one.token) };
+}
+/** A tapped question button, inside the update's transaction. */
+export function applyTelegramQuestionTap(store, binding, action, message, now) {
+    if (action.consumedAt !== null || action.expiresAt <= now.toISOString())
+        return [{ kind: "ack", text: "That was already answered, or these buttons are too old." }];
+    const question = store.teammateQuestion(action.question);
+    if (question === null || question.state !== "open") {
+        store.retireTelegramQuestion(action.question, now);
+        return [{ kind: "ack", text: "That was already answered." }];
+    }
+    if (action.choice === null)
+        return [{ kind: "ack", text: "Send your answer" }, { kind: "prompt", question: question.id, placeholder: "Your answer",
+                text: `Your answer to ${who(store, question)}: “${question.question}” Reply to this message.` }];
+    const answered = answerTeammateQuestion(store, question.id, { choice: action.choice, text: null, by: binding.approver, via: "telegram" }, now);
+    if (!answered.ok)
+        return [{ kind: "ack", text: answered.said.slice(0, 190) }];
+    retireEverywhere(store, question.id, now);
+    const label = question.options.find(one => one.id === action.choice)?.label ?? action.choice;
+    return [{ kind: "ack", text: "Answered" }, { kind: "edit", text: `${message.text}\n\n✅ You answered: ${label}. ${answered.said}`.slice(0, 4000) }];
+}
+/** A reply to the "answer in words" prompt, inside the update's transaction. */
+export function applyTelegramQuestionReply(store, binding, prompt, text, now) {
+    if (prompt.binding !== binding.id)
+        return null;
+    const said = text.trim();
+    if (said === "")
+        return "Send the answer itself as a reply.";
+    if (said.length > ANSWER_CHARS)
+        return `Keep it under ${ANSWER_CHARS.toLocaleString("en-US")} characters.`;
+    const answered = answerTeammateQuestion(store, prompt.question, { choice: null, text: said, by: binding.approver, via: "telegram" }, now);
+    retireEverywhere(store, prompt.question, now);
+    return answered.ok ? `✅ ${answered.said}` : answered.said;
+}
+// ---- Slack, Discord, Teams ---------------------------------------------------------
+/** A question notice as chat parts (the buttons on the last), or null when it isn't one, isn't for this person, or was answered. */
+export function questionParts(store, notification, binding) {
+    const question = openQuestionOf(store, notification.dedupeKey);
+    if (question === null || question.askedOf !== binding.approver)
+        return null;
+    return [{ text: `${notification.subject}\n\n${notification.body}`.replace(/[\u0000-\u0008\u000b-\u001f\u007f]/g, "").slice(0, 3000),
+            question: { id: question.id, choices: [...question.options.map(one => ({ choice: one.id, label: one.label })), { choice: null, label: IN_WORDS }] },
+            ...(notification.link === null ? {} : { link: { label: "Open", path: notification.link } }) }];
+}
+/** The live buttons on one part, in the order they were minted. */
+export function chatQuestionButtons(state, part, now) {
+    const row = state.prepare("SELECT payload FROM chat_part WHERE id=?").get(part);
+    const content = row === undefined ? null : JSON.parse(String(row["payload"]));
+    const labels = new Map((content?.question?.choices ?? []).map(one => [one.choice ?? "", one.label]));
+    return state.prepare("SELECT token,choice FROM chat_question_action WHERE part=? AND consumed IS NULL AND expires>? ORDER BY rowid").all(part, now.toISOString())
+        .map(one => ({ token: String(one.token), label: (labels.get(one.choice ?? "") ?? IN_WORDS).slice(0, 75), words: one.choice === null }));
+}
+/** Show the tapped notice again with the answer, and without its buttons. */
+function repaint(state, part, event, line) {
+    const row = state.prepare("SELECT payload FROM chat_part WHERE id=?").get(part);
+    const before = row === undefined ? { text: "" } : JSON.parse(String(row["payload"]));
+    const content = { text: `${before.text}\n\n${line}`.slice(0, 3400), edit: event.ts, ...(before.link === undefined ? {} : { link: before.link }), ...(before.channel === undefined ? {} : { channel: before.channel }) };
+    state.prepare("UPDATE chat_part SET payload=?,state='pending',next_at=NULL WHERE id=?").run(JSON.stringify(content), part);
+}
+/** A tapped question button, inside the action's transaction; false when the token isn't one. */
+export function applyChatQuestionTap(options, event, binding, token, now) {
+    const { store, state } = options;
+    const action = state.prepare("SELECT a.*,p.message,e.binding AS owner,e.channel FROM chat_question_action a JOIN chat_part p ON p.id=a.part JOIN chat_event e ON e.id=p.event WHERE a.token=?").get(token);
+    if (action === undefined)
+        return false;
+    const say = (text) => state.plan(event.id, [{ text }], now);
+    // Bound to the person, the chat and the exact message the button rode.
+    if (Number(action["owner"]) !== binding.id || action["channel"] !== event.channel || action["message"] !== event.ts) {
+        say("That button expired or was already used.");
+        return true;
+    }
+    const questionId = Number(action["question"]), part = Number(action["part"]);
+    const question = store.teammateQuestion(questionId);
+    if (action["consumed"] !== null || String(action["expires"]) <= now.toISOString() || question === null || question.state !== "open") {
+        retireEverywhere(store, questionId, now, state);
+        repaint(state, part, event, "This was already answered.");
+        state.finish(event.id);
+        return true;
+    }
+    if (action["choice"] === null) {
+        // One open prompt per person, across flow decisions and questions: the newest is the one the next message answers.
+        state.prepare("UPDATE chat_question_prompt SET consumed=? WHERE binding=? AND consumed IS NULL").run(now.toISOString(), binding.id);
+        state.prepare("UPDATE chat_flow_prompt SET consumed=? WHERE binding=? AND consumed IS NULL").run(now.toISOString(), binding.id);
+        state.prepare("INSERT INTO chat_question_prompt(binding,question,created,expires) VALUES(?,?,?,?)").run(binding.id, questionId, now.toISOString(), new Date(now.getTime() + PROMPT_MS).toISOString());
+        say(`Your next message here is your answer to ${who(store, question)}: “${question.question}” Send “cancel” to leave it.`);
+        return true;
+    }
+    const answered = answerTeammateQuestion(store, questionId, { choice: String(action["choice"]), text: null, by: binding.approver, via: options.label.toLowerCase() }, now);
+    if (!answered.ok) {
+        say(answered.said);
+        return true;
+    }
+    retireEverywhere(store, questionId, now, state);
+    const label = question.options.find(one => one.id === action["choice"])?.label ?? String(action["choice"]);
+    repaint(state, part, event, `✅ You answered: ${label}. ${answered.said}`);
+    state.finish(event.id);
+    return true;
+}
+/** The person's message while an "answer in words" prompt is open: the answer. false when none is open. */
+export function answerChatQuestionPrompt(options, event, binding, input, now) {
+    const { store, state } = options;
+    if (event.channel !== binding.channel)
+        return false;
+    return store.transact(() => {
+        const prompt = state.prepare("SELECT * FROM chat_question_prompt WHERE binding=? AND consumed IS NULL AND expires>? ORDER BY id DESC LIMIT 1").get(binding.id, now.toISOString());
+        if (prompt === undefined)
+            return false;
+        const id = Number(prompt["id"]), questionId = Number(prompt["question"]);
+        const say = (text) => state.plan(event.id, [{ text }], now);
+        const said = input.text.trim();
+        if (/^cancel\.?$/i.test(said)) {
+            state.prepare("UPDATE chat_question_prompt SET consumed=? WHERE id=?").run(now.toISOString(), id);
+            say("Left it unanswered. The buttons on the message still work.");
+            return true;
+        }
+        if (said === "") {
+            say("Send the answer itself, or “cancel”.");
+            return true;
+        }
+        // A message the chat cut short is never taken as part of an answer.
+        if ((input.originalLength ?? 0) > input.text.length || said.length > ANSWER_CHARS) {
+            say(`That's too long to take from here. Keep it under ${ANSWER_CHARS.toLocaleString("en-US")} characters, or answer on the card.`);
+            return true;
+        }
+        const answered = answerTeammateQuestion(store, questionId, { choice: null, text: said, by: binding.approver, via: options.label.toLowerCase() }, now);
+        retireEverywhere(store, questionId, now, state);
+        say(answered.ok ? `✅ ${answered.said}` : answered.said);
+        return true;
+    });
+}