toolroll 0.9.97 → 0.9.99

package/dist/telegram.js

@@ -18,6 +18,7 @@
  * BotFather token plus `bridge telegram unpair` is the recovery, and both
  * are one command.
  */
+import { recordTypedStart, typedStartCard, typedYes } from "./typed-start.js";
 import { telegramCardMessage } from "./card-render.js";
 import { flowDoneCard } from "./flow-result-card.js";
 import { applyTelegramQuestionReply, applyTelegramQuestionTap, openQuestionOf, telegramQuestionButtons } from "./subagent-question.js";
@@ -352,6 +353,8 @@ export const MAX_POLL_SECONDS = 25;
 const FOLLOW_BACKOFF_MS = [1_000, 2_000, 4_000, 8_000, 16_000, 30_000];
 /** A cycle that returned instantly with nothing is padded to this — a scripted or broken server must not spin the loop hot. */
 const FOLLOW_IDLE_FLOOR_MS = 1_000;
+/** While a long poll is open, how often the follower looks for a message due to go out (live-wakeups.md). */
+const DELIVERY_CHECK_MS = 1_000;
 /** v98: how often the bridge checks Telegram still pushes to us; how long pushes may keep failing before it asks
  * for updates itself; and how long it asks before trying pushes again. */
 const PUSH_CHECK_MS = 60_000, PUSH_GIVE_UP_MS = 5 * 60_000, PUSH_RETRY_MS = 15 * 60_000, PUSH_IDLE_MS = 2_000;
@@ -532,6 +535,8 @@ export async function followBridge(store, options) {
             const startedAt = Date.now();
             const report = { sent: 0, answered: 0, paired: 0, ignored: 0, backlog: false, problems: [] };
             await managePush(report);
+            // What this cycle's delivery below covers: anything newer may end the long poll early.
+            const deliveredThrough = newestNotificationIdOf(store);
             if (options.deliver !== false) {
                 await deliverOutbox(store, botId, transport, owner, clock, report, options.readProjects, options.canDeliver, options.conversation?.phoneOrigin, options.conversation?.evidenceRoot);
                 await deliverTeam(store, botId, transport, clock, report, options.readProjects, options.canDeliver, options.conversation?.phoneOrigin);
@@ -547,7 +552,43 @@ export async function followBridge(store, options) {
                 report.pushed = pushed;
             if (!pushing()) {
                 // While a turn is running, poll briefly so its reply is sent within a second or two of being written.
-                await drainUpdates(store, botId, transport, owner, lease.generation, lease.cursor, clock, report, inFlight === null ? pollSeconds : 1, signal, options.readProjects, options.conversation);
+                const seconds = inFlight === null ? pollSeconds : 1;
+                // A DELIVERY WAKE (live-wakeups.md): while the long poll is open, a message written for this bot since this
+                // cycle began delivering ends the poll, once per cycle, so it goes out now instead of after the poll. Same
+                // owner, same generation, one connection; the cursor moves only past updates already processed.
+                const poll = new AbortController();
+                const endPoll = () => poll.abort();
+                if (signal.aborted)
+                    poll.abort();
+                else
+                    signal.addEventListener("abort", endPoll, { once: true });
+                let woke = false;
+                const checker = options.deliver !== false && seconds > 1
+                    ? setInterval(() => {
+                        if (woke || poll.signal.aborted)
+                            return;
+                        let due = false;
+                        try {
+                            due = telegramOutboxDue(store, botId, deliveredThrough, clock());
+                        }
+                        catch {
+                            due = false;
+                        }
+                        if (!due)
+                            return;
+                        woke = true;
+                        poll.abort();
+                    }, options.deliveryCheckMs ?? DELIVERY_CHECK_MS)
+                    : null;
+                checker?.unref?.();
+                try {
+                    await drainUpdates(store, botId, transport, owner, lease.generation, lease.cursor, clock, report, seconds, poll.signal, options.readProjects, options.conversation, () => woke && !signal.aborted);
+                }
+                finally {
+                    if (checker !== null)
+                        clearInterval(checker);
+                    signal.removeEventListener("abort", endPoll);
+                }
                 // A push address nobody here wants any more (the public address was removed): take it down, so asking works again.
                 if (report.webhookActive === true && push === null)
                     await transport("deleteWebhook", { drop_pending_updates: false }, signal);
@@ -587,7 +628,8 @@ export async function followBridge(store, options) {
             const took = Date.now() - startedAt;
             // While Telegram pushes (v98) there is no long poll to wait on: a pushed update waits at most this long.
             const floor = pushing() ? PUSH_IDLE_MS : FOLLOW_IDLE_FLOOR_MS;
-            if (!signal.aborted && report.sent === 0 && report.answered === 0 && (report.chatAnswered ?? 0) === 0 && took < floor) {
+            // A delivery wake goes straight back round to send: no padding.
+            if (!signal.aborted && report.deliveryWake !== true && report.sent === 0 && report.answered === 0 && (report.chatAnswered ?? 0) === 0 && took < floor) {
                 // While Telegram pushes, a push kept by this process's hook ends the idle at once.
                 await (pushing() ? idle(floor - took) : wait(floor - took));
             }
@@ -1484,7 +1526,9 @@ function taskOf(store, decision) {
     const run = store.getRun(decision.run);
     return run === null ? "?" : store.externalIdFor(run.taskRef) ?? "?";
 }
-async function drainUpdates(store, botId, transport, owner, generation, cursor, clock, report, pollSeconds = 0, signal, readProjects, conversation) {
+async function drainUpdates(store, botId, transport, owner, generation, cursor, clock, report, pollSeconds = 0, signal, readProjects, conversation, 
+/** True when the poll was ended on purpose for a delivery: an answer that failed then is that abort, not the wire. */
+deliveryWake) {
     const context = { store, botId, transport, clock, report, readProjects, conversation, projects: null };
     let offset = cursor + 1;
     for (let page = 0; page < PAGE_BUDGET; page++) {
@@ -1495,6 +1539,12 @@ async function drainUpdates(store, botId, transport, owner, generation, cursor,
             allowed_updates: ["message", "callback_query"],
         }, signal);
         if (!answer.ok) {
+            // Ended on purpose so a due message goes out now: no problem, no backoff; the next cycle asks again from the
+            // same cursor, so nothing is lost.
+            if (deliveryWake?.() === true) {
+                report.deliveryWake = true;
+                return;
+            }
             const said = answer.description ?? "failed";
             // v98: another program asked Telegram for this bot's updates, and Telegram ended our
             // request in its favour. Nothing is lost: an update is only gone once someone
@@ -1723,7 +1773,14 @@ function applyMessage(context, update, effects) {
             return;
         // Replies to decisions retain their existing note meaning, even if the
         // note starts with a slash. New read commands are direct messages only.
-        if (message.reply_to_message === undefined && applyPhoneRead(context, update, effects))
+        // A bare "start" as the very next message after a Start card is that card's yes (docs/plans/one-step-chat.md C5),
+        // not the help command. Only the routing is decided here, by the same ids the message path reads again when it
+        // records the yes; "/start", and "start" anywhere else, stay help.
+        const yesSeat = message.reply_to_message === undefined && chat.type === "private" && typeof message.text === "string" && typedYes(message.text)
+            && context.conversation !== undefined && context.readProjects !== undefined ? store.liveTelegramBindingFor(botId, String(from.id)) : null;
+        const answersStartCard = yesSeat !== null && String(chat.id) === yesSeat.chatId
+            && typedStartCard(store, { binding: yesSeat.id, chatId: yesSeat.chatId, approver: yesSeat.approver }, { id: String(message.message_id), replyTo: null }) !== null;
+        if (message.reply_to_message === undefined && !answersStartCard && applyPhoneRead(context, update, effects))
             return;
         // A reply to a decision message this bot sent is a note, exactly as
         // before. Everything else that is ordinary text talks to the shared
@@ -1902,10 +1959,19 @@ function applyConversation(context, update, effects) {
         report.ignored++;
         return;
     }
-    store.enqueueTelegramConversation({
-        binding, updateId: update.update_id, messageId: String(message.message_id), replyTo,
-        request: telegramRequestId(botId, binding.id, update.update_id), text, context: context_, taskId, sourceRun,
-    }, clock());
+    // A typed yes to a Start card (docs/plans/one-step-chat.md C5) is read here, before any model runs, and recorded with
+    // the message in the same transaction: the fixed words only, tied to one exact card by message ids and Toolroll's own
+    // delivery record. The worker acts on it (confirmTypedStart) and no lead turn runs for it. Anything else is queued for
+    // the lead exactly as before.
+    store.transact(() => {
+        const typed = typedYes(text) ? typedStartCard(store, { binding: binding.id, chatId: binding.chatId, approver: binding.approver }, { id: String(message.message_id), replyTo }) : null;
+        store.enqueueTelegramConversation({
+            binding, updateId: update.update_id, messageId: String(message.message_id), replyTo,
+            request: telegramRequestId(botId, binding.id, update.update_id), text, context: context_, taskId, sourceRun,
+        }, clock());
+        if (typed !== null)
+            recordTypedStart(store, `m${update.update_id}`, typed, clock());
+    });
     report.chatQueued = (report.chatQueued ?? 0) + 1;
     // Saved: 👀 on the owner's message right away (docs/plans/responsive-chat.md §3.1), once this update's transaction
     // has committed. It comes off when the answer or the failure notice is delivered. Never awaited: a burst of messages
@@ -2653,3 +2719,21 @@ export function wakeTelegramBridge(botId) {
     for (const wake of wakers)
         wake();
 }
+/** The newest notification id now: a follower cycle's mark for what its delivery covers. */
+function newestNotificationIdOf(store) {
+    return Number(store.handle.prepare("SELECT COALESCE(MAX(id), 0) AS id FROM notification").get()?.["id"] ?? 0);
+}
+/**
+ * Whether a message for this bot was written after `mark` and is still due: unresolved, addressed to everyone or to a
+ * person paired with this bot, and the bot not held back by Telegram's rate limit. Read-only; delivery itself still
+ * decides each row under its own fences.
+ */
+export function telegramOutboxDue(store, botId, mark, now) {
+    const approvers = [...new Set(store.liveTelegramBindings(botId).map(binding => binding.approver))];
+    if (approvers.length === 0)
+        return false;
+    if (store.telegramRetryAt(botId) > now.toISOString())
+        return false;
+    return store.handle.prepare(`SELECT 1 AS hit FROM notification WHERE id > ? AND resolved_at IS NULL
+      AND (recipient IS NULL OR recipient IN (SELECT value FROM json_each(?))) LIMIT 1`).get(mark, JSON.stringify(approvers)) !== undefined;
+}

package/dist/toolroll-update.js

@@ -44,6 +44,7 @@ import { orphanKey, updateSafeSchema, V117_RENAMED_COLUMNS, V117_RENAMED_TABLES,
 import { V152_ADDED_COLUMNS } from "./code-map-store.js";
 import { V153_ADDED_COLUMNS } from "./plain-schema.js";
 import { V158_ADDED_COLUMNS } from "./lead-latency-schema.js";
+import { V159_ADDED_COLUMNS } from "./one-step-chat-schema.js";
 import { isNewer, REGISTRY } from "./releases.js";
 import { markNeverIndex } from "./never-index.js";
 import { readRuntimeUpdateJournal, RUNTIME_PHASES, RUNTIME_UPDATE_STEPS, stagedStartedAt, updaterStartingOf } from "./contracts/update-journal.js";
@@ -432,7 +433,8 @@ const HISTORY_RULES = {
     // v156 adds tables only (fallback chains): likewise.
     // v158 (after v157's chat-app tables): a saved lead step reads no tool names and no failure detail, and a saved reply no route and no failure detail
     // (NULL); the quick-answer switch is a new table.
-    ...Object.fromEntries(Object.entries(addedColumns(V119_ADDED_COLUMNS, V120_ADDED_COLUMNS, V121_ADDED_COLUMNS, V122_ADDED_COLUMNS, V123_ADDED_COLUMNS, V125_ADDED_COLUMNS, V126_ADDED_COLUMNS, V128_ADDED_COLUMNS, V129_ADDED_COLUMNS, V134_ADDED_COLUMNS, V135_ADDED_COLUMNS, V138_ADDED_COLUMNS, V143_ADDED_COLUMNS, V147_ADDED_COLUMNS, V148_ADDED_COLUMNS, V150_ADDED_COLUMNS, V151_ADDED_COLUMNS, V152_ADDED_COLUMNS, V153_ADDED_COLUMNS, V158_ADDED_COLUMNS))
+    // v159: a saved fast-start preview reads no lead turn (NULL); a typed yes's record is a new table.
+    ...Object.fromEntries(Object.entries(addedColumns(V119_ADDED_COLUMNS, V120_ADDED_COLUMNS, V121_ADDED_COLUMNS, V122_ADDED_COLUMNS, V123_ADDED_COLUMNS, V125_ADDED_COLUMNS, V126_ADDED_COLUMNS, V128_ADDED_COLUMNS, V129_ADDED_COLUMNS, V134_ADDED_COLUMNS, V135_ADDED_COLUMNS, V138_ADDED_COLUMNS, V143_ADDED_COLUMNS, V147_ADDED_COLUMNS, V148_ADDED_COLUMNS, V150_ADDED_COLUMNS, V151_ADDED_COLUMNS, V152_ADDED_COLUMNS, V153_ADDED_COLUMNS, V158_ADDED_COLUMNS, V159_ADDED_COLUMNS))
         .map(([table, rule]) => [table, { ...EARLIER_RULES[table], ...rule }])),
 };
 /** The tables a migration may remove whole (v115's removed features). */

package/dist/tui-contract.d.ts

@@ -17,6 +17,8 @@ export type TuiRow = {
     /** The attempt running now, if any: what Stop names. */
     readonly liveRunId: number | null;
     readonly repo: string | null;
+    /** Home's group (home-groups.ts homeGroupOf): waits on you, working, done, or none (cancelled, replaced). */
+    readonly group: "you" | "working" | "done" | null;
 };
 /** A parked question on a task, answered by choosing one of its options. */
 export type TuiDecision = {

package/dist/tui-source.js

@@ -18,6 +18,7 @@ import { localModeOf, openStoreReadOnly } from "./store.js";
 import { routeChangeOf } from "./route-change.js";
 import { flakyCount } from "./flaky.js";
 import { memoryWaiting } from "./lesson-notes.js";
+import { homeGroupOf } from "./home-groups.js";
 import { terminalText } from "./terminal-text.js";
 import { welcomeHere, welcomeLines } from "./welcome-facts.js";
 const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
@@ -74,6 +75,8 @@ export function createTuiSource(options) {
                 return {
                     id: words(row["id"], words(row["rootId"])), title: shown(row["title"]), status: shown(status["label"], words(row["state"])), detail: shown(status["detail"]),
                     needsYou: views.includes("needs-you"), liveRunId: typeof row["liveRunId"] === "number" ? row["liveRunId"] : null, repo: typeof row["repo"] === "string" ? row["repo"] : null,
+                    // The same rule as Home's groups, over the same work index item.
+                    group: homeGroupOf({ status: { views: views.filter((one) => typeof one === "string") } }),
                 };
             });
             const waiting = rows.filter(one => one.needsYou);