toolroll 0.9.97 → 0.9.98

package/dist/telegram-lead.js

@@ -1,7 +1,8 @@
 import { telegramCardMessage } from "./card-render.js";
 import { cardOfProposal, cardPlainOf, cardsFirst, cardWithin, isCardProposal } from "./chat-card.js";
 import { CHAT_ACTIONS, sharedActionAllowsChallenge, sharedActionPayload } from "./chat-actions.js";
-import { armedQuestion, taskInCeiling, mirrorToTaskChat, couldNotAnswerText, channelRepos as telegramConversationRepos, resolveChannelLead as resolveTelegramLead, NO_PHONE_LINK, NO_TASK_LINK, phoneProposalLink, confirmedLink, phoneProposalPreview, proposalOutcomeText, handoffCardText, confirmedCardText } from "./chat-channel.js";
+import { typedStartOf } from "./typed-start.js";
+import { armedQuestion, taskInCeiling, mirrorToTaskChat, couldNotAnswerText, channelRepos as telegramConversationRepos, resolveChannelLead as resolveTelegramLead, NO_PHONE_LINK, NO_TASK_LINK, phoneProposalLink, confirmedLink, startedTaskLink, phoneProposalPreview, proposalOutcomeText, handoffCardText, confirmedCardText } from "./chat-channel.js";
 export { channelRepos as telegramConversationRepos, resolveChannelLead as resolveTelegramLead, tooLongText, whichTaskText, replyContextFor, NO_PHONE_LINK, NO_TASK_LINK, proposalLink, confirmedLink, proposalPreview, proposalOutcomeText, handoffCardText, confirmedCardText, CHAT_ACTION_PARITY as TELEGRAM_ACTION_PARITY, parityGaps } from "./chat-channel.js";
 /**
  * The paired phone as one more way to use the same assistant.
@@ -26,7 +27,7 @@ export { channelRepos as telegramConversationRepos, resolveChannelLead as resolv
  */
 import { createHash, randomBytes } from "node:crypto";
 import { leadFailureText, runLeadTurn } from "./lead.js";
-import { confirmLeadProposal, dismissLeadProposal } from "./lead-doors.js";
+import { confirmLeadProposal, confirmTypedStart, dismissLeadProposal, TYPED_START_STARTED } from "./lead-doors.js";
 import { ceilingDigestOf, verifyApproverStanding } from "./principal.js";
 import { LEAD_ASK_OTHER } from "./store.js";
 import { phoneText } from "./telegram-status.js";
@@ -129,7 +130,10 @@ export function mintCardTokens(store, binding, proposal, now, messageId, chatId
     for (const [token, phase] of [[confirm, "confirm"], [dismiss, "dismiss"]]) {
         store.createTelegramProposalAction({ token, binding: binding.id, proposal, phase, chatId, ttlMs: CARD_TTL_MS, ...(messageId === undefined ? {} : { messageId }) }, now);
     }
-    return { keyboard: [[telegramButton("Confirm", confirm), telegramButton("Dismiss", dismiss)]], tokens: [confirm, dismiss] };
+    // A Start card's button says what it does: the card's last line tells the person to tap it (or reply yes).
+    const saved = store.getLeadProposal(proposal);
+    const label = saved?.kind === "action" && sharedActionPayload(saved.payload)?.operation === "task_start" ? "Start work" : "Confirm";
+    return { keyboard: [[telegramButton(label, confirm), telegramButton("Dismiss", dismiss)]], tokens: [confirm, dismiss] };
 }
 /**
  * One tap on a proposal card, applied inside the update's own transaction
@@ -249,7 +253,7 @@ export function applyProposalTap(store, binding, token, message, repos, options,
     }
     const irreversible = proposal.kind === "answer" && proposal.payload["reversible"] === false;
     const sharedAction = proposal.kind === "action" ? sharedActionPayload(proposal.payload) : null;
-    const challenged = sharedAction !== null && sharedActionAllowsChallenge(sharedAction);
+    const challenged = sharedAction !== null && sharedActionAllowsChallenge(sharedAction, "telegram");
     // The arm: two fresh one-time tokens make a real challenge, exactly as a
     // decision button does. Nothing is answered or recorded here.
     const arm = () => {
@@ -573,7 +577,11 @@ async function runTelegramConversation(row, args) {
                 const proposal = part.kind === "card" && part.proposal !== null ? store.getLeadProposal(part.proposal) : null;
                 const origin = proposal === null ? null : options.phoneOrigin?.() ?? null;
                 const wanted = proposal === null ? null : phoneProposalLink(store, proposal, repos);
-                const keyboard = keyboardWith(part.keyboard, phoneLinkButton(origin, wanted));
+                // A typed yes that started a task (one-step-chat.md C5): Toolroll's reply carries the task's link, as a tapped
+                // card does. From the record and the origin read now, like every link.
+                const yes = part.kind === "reply" ? typedStartOf(store, "telegram", `m${row.id}`) : null;
+                const started = yes !== null && yes.outcome === "started" && yes.taskId !== null ? phoneLinkButton(options.phoneOrigin?.() ?? null, startedTaskLink(store, yes.taskId, repos)) : null;
+                const keyboard = keyboardWith(part.keyboard, started ?? phoneLinkButton(origin, wanted));
                 // A Toolroll card: read again now, shown only where every project behind it is still reachable. An unreadable
                 // one goes out as its saved plain words.
                 const isCard = proposal !== null && isCardProposal(proposal);
@@ -751,6 +759,62 @@ async function runTelegramConversation(row, args) {
         return;
     }
     const repos = telegramConversationRepos(store, binding.approver, registry);
+    // A typed yes to a Start card (docs/plans/one-step-chat.md C5), recorded when the message arrived: Toolroll acts on it
+    // here and no lead turn runs for it. Its outcome and Toolroll's own reply are written in ONE transaction (the claim
+    // fences the reply; a lapsed claim takes the whole act back), then sent like any reply. A settled record returns its
+    // first outcome, so a redelivery or a crash starts nothing more.
+    const typed = typedStartOf(store, "telegram", `m${row.id}`);
+    if (typed !== null) {
+        const verified = verifyApproverStanding(store, binding.approver, binding.approverGeneration, repos);
+        // The card's turn is gone when the chat was ended (its proposals are deleted) or its project deleted: there is then
+        // no session to send a reply under, and nothing can have started. Toolroll says so itself. The yes is never passed on.
+        const unanchored = { said: null };
+        try {
+            store.transact(() => {
+                const now = clock();
+                const answered = confirmTypedStart(store, verified.ok ? verified.who : null, { provider: "telegram", event: typed.event }, now, { binding: binding.id, evidenceRoot: options.evidenceRoot });
+                // The reply is fenced on the session the card was composed under.
+                const card = store.getLeadProposal(typed.proposal);
+                const turn = card === null ? null : store.getLeadTurn(card.turn);
+                if (turn === null) {
+                    // A start without its card can't happen (the door re-reads the card); if it ever did, take it back.
+                    if (answered.ok)
+                        throw new PlanRefused();
+                    unanchored.said = answered.said;
+                    return;
+                }
+                // The card is answered: its buttons are spent with it.
+                if (answered.ok)
+                    store.consumeTelegramProposalActions(typed.proposal, now);
+                if (!store.planTelegramConversationParts(row.id, owner, { session: turn.session, turn: turn.id }, [{ kind: "reply", text: answered.said, replyTo: row.messageId }], now))
+                    throw new PlanRefused();
+            });
+        }
+        catch (error) {
+            if (error instanceof PlanRefused)
+                return;
+            throw error;
+        }
+        if (unanchored.said !== null) {
+            await notify(unanchored.said);
+            finish({ state: "failed", outcome: "typed-start:not-counted" });
+            report.refused++;
+            return;
+        }
+        // The card it answered is repainted as a tap's would be, best effort: its buttons are already spent, and the
+        // reply below says the same words with the same link.
+        const settled = typedStartOf(store, "telegram", typed.event);
+        if (settled?.outcome === "started" && settled.taskId !== null && pairingProblem() === null && held()) {
+            const link = phoneLinkButton(options.phoneOrigin?.() ?? null, startedTaskLink(store, settled.taskId, repos));
+            try {
+                await transport("editMessageText", { chat_id: chatId, message_id: Number(typed.cardMessage), text: `✓ ${TYPED_START_STARTED}`, link_preview_options: { is_disabled: true },
+                    reply_markup: { inline_keyboard: link === null ? [] : [link] } });
+            }
+            catch { /* the reply below still says it */ }
+        }
+        await sendOrHandOff("typed-start");
+        return;
+    }
     // 4. A session bound before an earlier dispatch: the receipt lives there,
     // whatever session is live today.
     if (row.session !== null) {

package/dist/telegram-status.js

@@ -8,6 +8,8 @@ import { familyCompleted } from "./result-completion.js";
 import { approvedCheckOf, approvedCheckStateOf, assignmentStatusFacts, checksFactOf, plainReasonOf, stageOfDispatch, taskStatusOf } from "./task-status.js";
 import { assignmentChecksForRun, assignmentOf } from "./assignment.js";
 import { CHAT_CONTROLS, chatControlHref, chatResultHref } from "./chat-controls.js";
+import { homeFiguresLine, homeFiguresOf } from "./home-groups.js";
+import { workIndexPage } from "./work-index.js";
 export function phoneCommand(text) {
     // Slash forms everywhere; the bare words too, because Slack and Discord
     // keep unregistered slash text for themselves. Only a whole message that
@@ -106,10 +108,13 @@ function nextStep(d) {
  * history. This snapshot is intentionally bounded and advertises that bound. */
 export function phoneStatus(store, repos, now, focused = null, root) {
     if (repos.length === 0)
-        return "No connected projects are available to this bridge. Add a project in Toolroll, then send /status again.";
+        return "No projects are connected here yet. Add a project in Toolroll, then send /status again.";
     return store.transact(() => {
         const snapshot = withDispatchDiagnoses(store, store.chatSnapshot(repos, now), now);
-        const lines = [...(focused === null ? [] : [`Talking about: ${focused} · /lead to switch back`, ""]), "Recent work", `As of ${now.toISOString().replace("T", " ").slice(0, 19)} UTC · ${repos.length} project(s)`, ""];
+        // It opens with Home's figures, from the work index totals over these projects (the Tasks lists' own counts);
+        // the groups below are dispatch diagnoses, which are not the work index's families, so they keep their headings.
+        const figures = homeFiguresOf(workIndexPage(store, now, { principal: "operator", repos, includeUnplaced: false }, { limit: 1, ...(root === undefined ? {} : { root }) }).totals);
+        const lines = [homeFiguresLine(figures), "", ...(focused === null ? [] : [`Talking about: ${focused} · /lead to switch back`, ""]), "Recent work", `As of ${now.toISOString().replace("T", " ").slice(0, 19)} UTC · ${repos.length} project(s)`, ""];
         if (snapshot.tasksSaturated)
             lines.push("Newest 60 tasks only — older work may still need attention.", "");
         if (snapshot.tasks.length === 0)
@@ -126,7 +131,7 @@ export function phoneStatus(store, repos, now, focused = null, root) {
                 lines.push(`  +${rows.length - 2} more in the console`);
             lines.push("");
         }
-        lines.push("Send /tasks to pick one, or /task <name> for its next step. Status is a snapshot, not a promise that the next attempt will succeed.");
+        lines.push("Send /tasks to pick one, or /task <name> for its next step. This is how things stand right now.");
         return lines.join("\n");
     });
 }
@@ -251,7 +256,7 @@ export function phoneTaskView(store, repos, id, now, root) {
                 lines.push(`Attempt ended: ${plain(latest.finishedAt, 40)}`);
             else if (d.condition === "running") {
                 const checkpoint = store.latestCheckpointForRun(latest.id);
-                lines.push(checkpoint === null ? "No milestone progress has been recorded for this attempt." : `Latest agent-reported milestone update: ${plain(checkpoint.createdAt, 40)} (not independent proof).`);
+                lines.push(checkpoint === null ? "No milestone progress has been recorded for this attempt." : `Latest update from the agent, not verified: ${plain(checkpoint.createdAt, 40)}.`);
             }
         }
         let link = null;

package/dist/telegram.d.ts

@@ -148,6 +148,8 @@ export type BridgeReport = {
     contention?: number;
     /** v98: Telegram answered that it pushes this bot's updates to a webhook. */
     webhookActive?: boolean;
+    /** The long poll was ended on purpose because a message was due to go out (live-wakeups.md): not a failure. */
+    deliveryWake?: boolean;
     /** v98: pushed updates applied this pass. */
     pushed?: number;
 };
@@ -242,6 +244,8 @@ export declare function followBridge(store: Store, options: {
     } | null;
     /** v98: how often to check Telegram still pushes to us (tests shorten it). */
     pushCheckMs?: number;
+    /** While a long poll is open, how often to look for a message due to go out (tests shorten it). */
+    deliveryCheckMs?: number;
 }): Promise<FollowReport>;
 /** The digest text: a header with the count and the window, then one
  * fact per entry — its subject, then its body's first line, indented.
@@ -260,3 +264,9 @@ export declare function digestText(rows: readonly Notification[], since: string
 export declare const TELEGRAM_MAX_WAITING = 10;
 /** A pushed update was kept for this bot: wake its bridge if it runs in this process (docs/plans/responsive-chat.md §3.1). */
 export declare function wakeTelegramBridge(botId: string): void;
+/**
+ * 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 declare function telegramOutboxDue(store: Store, botId: string, mark: number, now: Date): boolean;

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);