toolroll 0.9.37 → 0.9.39

package/dist/browser-crew.js

@@ -38,6 +38,10 @@ export function browserCrewFromIndex(page, conversationId) {
     const link = (href) => conversationId && href.startsWith('/chat?') ? href + '&conversation=' + encodeURIComponent(conversationId) : href;
     const rows = page.items.map(summary => {
         const status = summary.status;
+        // Keep the server's sentence intact; ignore only empty or repeated badge words.
+        const words = (text) => text.trim().replace(/\s+/g, ' ').replace(/[.!?]+$/, '').toLowerCase();
+        const detail = ['Waiting', 'Failed', 'Needs you'].includes(status.label)
+            && words(status.detail) !== '' && words(status.detail) !== words(status.label) ? status.detail : undefined;
         const resultHref = summary.resultRunId === null || summary.resultTaskId === null || (summary.resultOutcome !== 'built' && summary.resultOutcome !== 'no-change')
             ? null : chatResultHref(summary.resultTaskId, summary.resultRunId);
         const href = chatControlHref('task', summary.rootId);
@@ -48,6 +52,7 @@ export function browserCrewFromIndex(page, conversationId) {
             state: summary.assignmentState, label: status.label, tone: status.tone, href: link(href), resultHref: resultHref === null ? null : link(resultHref),
             action: action === null || actionHref === null ? null : { label: action.label, href: link(actionHref) },
             updatedAt: summary.updatedAt,
+            ...(detail === undefined ? {} : { detail }),
             ...(summary.lead === undefined ? {} : { lead: summary.lead }),
         };
         return { item, rank: status.rank };

package/dist/browser-workspace.d.ts

@@ -49,6 +49,8 @@ export type BrowserCrewItem = {
     } | null;
     /** When the task family last changed (the index's own sort time), shown as the row's age. */
     updatedAt: string;
+    /** The server's status detail, when Waiting, Failed or Needs you adds to its badge. */
+    detail?: string;
     /** "<name> is on it.": the person's own lead took it on, by the name they gave it. */
     lead?: string;
 };
@@ -98,6 +100,10 @@ export type BrowserConversation = {
     resultRunId: number | null;
     /** A project's own thread (v77); absent or null for the lead conversation or a task. */
     project?: string | null;
+    /** The lead thread a change in reachable projects replaced (mate arc ruling 9): shown above a divider, read only. */
+    previous?: {
+        messages: BrowserMessage[];
+    } | null;
 };
 /** A page rebuilt as React components (shadcn/ui). The server still renders
  * its HTML as the no-JavaScript fallback; forms post to the same routes. */
@@ -174,6 +180,8 @@ export type BrowserLimits = {
 export type BrowserSettingsView = {
     kind: 'settings';
     said: string | null;
+    /** Using it from a phone, under Chat apps (approvers only). */
+    phone?: BrowserPhoneCard;
     /** The settings destinations under short headings; a chat app's tile says whether it is connected and gets alerts. */
     groups: BrowserSettingsGroup[];
     theme: 'system' | 'light' | 'dark';

package/dist/chat-channel.js

@@ -273,16 +273,27 @@ export function proposalPreview(store, proposal, repos, channel = null) {
             : undefined;
         return path === undefined ? id : projectLabel(path);
     })();
+    // Telegram's card leads with the action and what confirming does, then the exact terms; its buttons say the rest.
+    const phone = channel === "telegram";
     const card = (headline, body = [], consequence = null) => ({
-        text: [
-            headline,
-            ...body,
-            ...(consequence === null ? [] : ["", consequence]),
-            "",
-            "Confirm or Dismiss below. Nothing changes until you confirm.",
-        ].join("\n"),
+        text: (phone
+            ? [
+                headline,
+                ...(consequence === null ? [] : [consequence]),
+                ...(body.length === 0 ? [] : ["", ...body]),
+                "",
+                "Nothing changes until you confirm.",
+            ]
+            : [
+                headline,
+                ...body,
+                ...(consequence === null ? [] : ["", consequence]),
+                "",
+                "Confirm or Dismiss below. Nothing changes until you confirm.",
+            ]).join("\n"),
         buttons: true,
     });
+    const lasting = phone ? " ⚠ can't be undone" : " — IRREVERSIBLE";
     // A handoff's text is origin-free on purpose: it is persisted before the
     // send, and the button or the missing-setup line joins it at send time.
     const handoff = (headline, body = []) => ({
@@ -361,11 +372,11 @@ export function proposalPreview(store, proposal, repos, channel = null) {
                 ? ["(the decision is gone)"]
                 : [
                     `Q: ${phoneText(decision.question, 400)}`,
-                    ...decision.options.map((one) => `${one.id === pick ? "→" : " "} ${phoneText(one.label, 120)}${one.reversible ? "" : " — IRREVERSIBLE"}${one.id === decision.recommendation ? " (the builder recommends this)" : ""}: ${phoneText(one.consequence, 300)}`),
+                    ...decision.options.map((one) => `${one.id === pick ? "→" : " "} ${phoneText(one.label, 120)}${one.reversible ? "" : lasting}${one.id === decision.recommendation ? " (the builder recommends this)" : ""}: ${phoneText(one.consequence, 300)}`),
                     ...(t("rationale") === "" ? [] : [`Why: ${t("rationale", 300)}`]),
                 ];
             return card(`Answer decision #${String(id ?? "?")} on ${taskName} with "${t("optionLabel", 120) || pick}"`, body, irreversible
-                ? "⚠ This choice is irreversible. Confirming asks you once more."
+                ? phone ? "⚠ This choice can't be undone. Confirming asks you once more." : "⚠ This choice is irreversible. Confirming asks you once more."
                 : null);
         }
         case "task_action": {

package/dist/chat-decide.d.ts

@@ -108,11 +108,12 @@ export declare function mergeInChat(store: Store, taskId: string, run: number, a
     ok: false;
     why: string;
 };
-/** The plan card: title, goal in two lines, what changes, done when, and what the yes allows. */
-export declare function planCardText(store: Store, taskId: string, scope: Scope, root?: string): string;
+/** The plan card: title, goal in two lines, what changes, done when, and what the yes allows. On Telegram the yes's
+ * terms come second, under the title, and the steps are fewer: the full plan is behind Edit. */
+export declare function planCardText(store: Store, taskId: string, scope: Scope, root?: string, channel?: DecideChannel): string;
 /** The acts a card about this target can take in chat right now, or null when none can (the card keeps its own
  * link). Reads only; nothing is minted. */
-export declare function decideOffer(store: Store, target: DecideTarget, who: VerifiedApprover, now: Date, root?: string): DecideOffer | null;
+export declare function decideOffer(store: Store, target: DecideTarget, who: VerifiedApprover, now: Date, root?: string, channel?: DecideChannel): DecideOffer | null;
 /** One fingerprint of what the card offers, without its tokens: a repaint with the same offer keeps its buttons. */
 export declare function offerFingerprint(offer: DecideOffer): string;
 /** The card's buttons, minted now (message unknown until it is sent: `placeDecideTokens` puts them on it). */

package/dist/chat-decide.js

@@ -155,8 +155,9 @@ export function mergeInChat(store, taskId, run, approver, now) {
         return mode;
     return { ok: true, modeDigest: mode.digest, head: publication.headSha };
 }
-/** The plan card: title, goal in two lines, what changes, done when, and what the yes allows. */
-export function planCardText(store, taskId, scope, root) {
+/** The plan card: title, goal in two lines, what changes, done when, and what the yes allows. On Telegram the yes's
+ * terms come second, under the title, and the steps are fewer: the full plan is behind Edit. */
+export function planCardText(store, taskId, scope, root, channel) {
     const ref = store.lookupRef(taskId);
     const artifact = ref === null ? null : store.latestPlanArtifact(ref.id);
     let milestones = [];
@@ -176,6 +177,19 @@ export function planCardText(store, taskId, scope, root) {
     const goal = scope.goal.split("\n").filter(one => one.trim() !== "").slice(0, 2).map(one => phoneText(one, 160));
     const allowing = [permissionPlainWords(scope.profile), scope.budgetMicrousd === null ? "no attempt limit" : `up to ${money(scope.budgetMicrousd)} per attempt`]
         .filter((one) => one !== null);
+    if (channel === "telegram") {
+        return [
+            `Plan ready: ${title(store, taskId)}`,
+            `Starting allows: ${allowing.join(" · ")}`,
+            "",
+            ...goal,
+            ...(scope.touches.length > 0 ? [`Only in: ${scope.touches.slice(0, 6).map(one => phoneText(one, 80)).join(", ")}${scope.touches.length > 6 ? ", …" : ""}`] : ["Any file in the project."]),
+            "",
+            "Done when:",
+            ...(scope.acceptance.length > 0 ? bullets(scope.acceptance.map(one => one.statement), 5) : ["You decide when you review the result."]),
+            ...(milestones.length > 0 ? ["", "Steps:", ...bullets(milestones, 3)] : []),
+        ].join("\n");
+    }
     return [
         `Plan ready: ${title(store, taskId)}`,
         "",
@@ -194,7 +208,7 @@ export function planCardText(store, taskId, scope, root) {
 // ---- what a card offers ---------------------------------------------------------------
 /** The acts a card about this target can take in chat right now, or null when none can (the card keeps its own
  * link). Reads only; nothing is minted. */
-export function decideOffer(store, target, who, now, root) {
+export function decideOffer(store, target, who, now, root, channel) {
     const ref = store.lookupRef(target.taskId);
     if (ref === null || ref.repo === null || !who.repos.includes(ref.repo))
         return null;
@@ -222,7 +236,7 @@ export function decideOffer(store, target, who, now, root) {
             const plan = planInChat(store, target.taskId, who.name, now, root);
             if (!plan.ok)
                 return null;
-            return { text: planCardText(store, target.taskId, plan.scope, root),
+            return { text: planCardText(store, target.taskId, plan.scope, root, channel),
                 rows: [[{ act: "approve", run: null, digest: plan.digest }], [{ label: DECIDE_LABELS.edit, path: chatControlHref("approval", target.taskId) }, { act: "not-now", run: null, digest: plan.digest }]] };
         }
         case "merge": {
@@ -414,7 +428,7 @@ export function applyDecideTap(store, seat, input) {
     }
     if (row.phase === "cancel") {
         spend();
-        const offer = decideOffer(store, target, who, now, input.root);
+        const offer = decideOffer(store, target, who, now, input.root, seat.channel);
         if (offer === null)
             return { ack: "Cancelled.", edit: { text: body, rows: linksFor(target), tokens: [] } };
         const minted = mintDecideButtons(store, seat, target, offer, now, input.message);

package/dist/desktop-update.d.ts

@@ -125,13 +125,13 @@ export declare function prepareDesktopUpdate(stateDir: string, installed: string
 export declare function sqliteLock(file: string, busyTimeoutMs?: number): DatabaseSync | null;
 export declare const installationLock: (j: UpdateJournal) => DatabaseSync | null;
 export declare function desktopUpdateStatus(stateDir: string): {
-    error?: never;
     active: boolean;
     phase: string;
     detail: string;
     running: boolean;
     canResume: boolean;
     canCancel: boolean;
+    error?: never;
     automaticRecovery?: never;
     recoveryAttempts?: never;
     recoveryRepairs?: never;

package/dist/mate-progress.d.ts

@@ -12,14 +12,40 @@ export type MateProgress = {
     kind: "tool";
     turn: number;
     step: number;
+    id: string;
     label: string;
+} | {
+    kind: "tool-result";
+    turn: number;
+    step: number;
+    id: string;
+    outcome: MateToolOutcome;
 } | {
     kind: "text";
     turn: number;
     step: number;
     text: string;
 };
+export type MateToolOutcome = {
+    state: "succeeded";
+} | {
+    state: "failed";
+    reason: string;
+};
+export type MateLiveTool = {
+    id: string;
+    label: string;
+} & ({
+    state: "running";
+} | MateToolOutcome);
+/** Keep tools as labels for older clients; toolCalls adds per-call outcomes. */
+export type MateLiveStep = {
+    tools: string[];
+    toolCalls: MateLiveTool[];
+    text: string;
+};
 export declare function mateToolLabel(name: string): string;
+export declare function mateToolFailureReason(name: string, message: string): string;
 /** The `text` of a structured answer still being written, when the answer
  * opens with it (`{"text": "…`); null until then. Escapes are decoded, and
  * an escape cut off at the end is left for the next chunk. */

package/dist/mate-progress.js

@@ -43,6 +43,30 @@ export function mateToolLabel(name) {
         return TOOL_LABELS[name];
     return name.startsWith("propose_") ? "Preparing a card for you to confirm" : "Working";
 }
+/** Tool errors instruct the model how to retry. Only known, fixed copy belongs
+ * in the live UI; never echo arguments, redaction placeholders or exceptions. */
+const TOOL_FAILURE_REASONS = new Map([
+    ["Choose a project from list_repos.", "That project isn't available."],
+    ["Choose an available project from list_repos.", "That project isn't available."],
+    ["repo must be one of the ids from list_repos", "That project isn't available."],
+    ["not-found: no such task in your projects", "That task isn't available in your projects."],
+    ["That task is not in your projects.", "That task isn't available in your projects."],
+    ["not-found: no such decision in your projects", "That decision isn't available in your projects."],
+    ["that decision is no longer open", "That decision is already closed."],
+    ["No such flow in your projects.", "No such flow in your projects."],
+    ["That action is outside your access.", "You don't have access to that action."],
+    ["Read the current task version before proposing this action.", "The task needs to be checked again before this action."],
+    ["That file is not in these changes. Call get_diff without file for the list.", "That file isn't in the saved changes."],
+    ["The saved changes could not be verified.", "The saved changes could not be verified."],
+    ["The saved check log could not be verified.", "The saved check log could not be verified."],
+    ["Saved results are unavailable here.", "Saved results are unavailable here."],
+    ["There is no finished result for that version yet.", "There is no finished result for that version yet."],
+    ["Task text cannot contain credentials.", "The task text contains a password or secret key."],
+    ["that tool refused — the plane could not answer it right now", "Toolroll couldn't finish that step right now."],
+]);
+export function mateToolFailureReason(name, message) {
+    return TOOL_FAILURE_REASONS.get(message) ?? `That step didn't work (${mateToolLabel(name)}).`;
+}
 /** The `text` of a structured answer still being written, when the answer
  * opens with it (`{"text": "…`); null until then. Escapes are decoded, and
  * an escape cut off at the end is left for the next chunk. */

package/dist/mate.js

@@ -1,5 +1,5 @@
 import { Buffer } from "node:buffer";
-import { mateToolLabel } from "./mate-progress.js";
+import { mateToolFailureReason, mateToolLabel } from "./mate-progress.js";
 import { createHash } from "node:crypto";
 import { mateTimeoutNotice } from "./store.js";
 import { RESULT_IMAGES_PER_TURN_CAP } from "./chat-evidence.js";
@@ -499,8 +499,17 @@ export async function runMateTurn(input) {
                 if (changed !== null)
                     return changed;
             }
-            progress({ kind: "tool", turn: turnId, step: steps, label: mateToolLabel(call.name) });
+            // Position within this turn is unique even if a provider reuses call ids.
+            const progressId = `${turnId}:${steps}:${index}`;
+            progress({ kind: "tool", turn: turnId, step: steps, id: progressId, label: mateToolLabel(call.name) });
             const outcome = executeMateTool({ store, who, now: clock(), draft, selectEvidence, step: steps, readDecisions, readResults, searchedMemory, checkedCapabilities, ask, ...(input.integrations === undefined ? {} : { integrations: input.integrations }), thread: thread.id, turn: turnId, ...(promiseChannelOfTurn(input.channel) === undefined ? {} : { channel: promiseChannelOfTurn(input.channel) }), ...(input.evidenceRoot === undefined ? {} : { evidenceRoot: input.evidenceRoot }), ...(input.mediaDelivery === undefined ? {} : { mediaDelivery: input.mediaDelivery }) }, call.name, call.args, view);
+            let displayOutcome = { state: "succeeded" };
+            if (!outcome.ok) {
+                const reason = mateToolFailureReason(call.name, outcome.message);
+                displayOutcome = { state: "failed", reason: scanForSecrets(reason).length === 0
+                        ? reason : `That step didn't work (${mateToolLabel(call.name)}).` };
+            }
+            progress({ kind: "tool-result", turn: turnId, step: steps, id: progressId, outcome: displayOutcome });
             if (READ_TOOLS.has(call.name))
                 reads++;
             if (call.name === "show_control" && outcome.ok)

package/dist/serve.js

@@ -744,6 +744,19 @@ export function createDecisionServer(options) {
         provider: () => { const enabled = chatEnablement(); return enabled.ok ? { config: enabled.config, key: enabled.key } : null; },
         ...(options.subscriptionChatRunner ? { subscriptionRunner: options.subscriptionChatRunner } : {}),
     });
+    // Only browser sessions receive HTML cards. The CLI keeps its summary contract.
+    const teamBrowserReply = (reply, csrf) => {
+        const snapshot = reply.snapshot;
+        if (!snapshot?.selected || !snapshot.proposals)
+            return reply;
+        return { ...reply, snapshot: { ...snapshot, proposals: snapshot.proposals.map(summary => {
+                    const proposal = store.getMateProposal(summary.id);
+                    if (!proposal || proposal.thread !== snapshot.selected.threadId)
+                        return summary;
+                    const decision = proposal.kind === 'answer' && typeof proposal.payload['decision'] === 'number' ? store.getDecision(proposal.payload['decision']) : null;
+                    return { ...summary, card: teamProposalCardParts(proposal, snapshot, csrf, decision).card };
+                }) } };
+    };
     const teamEndpoint = (request, response) => handleTeamHttp(request, response, {
         authenticate: request => {
             const who = identify(request, request.method === 'POST');
@@ -773,7 +786,11 @@ export function createDecisionServer(options) {
                 return false;
             return request.headers['x-csrf-token'] === who.session.csrf;
         },
-        execute: team.execute, cursor: team.cursor, streams: teamStreams,
+        execute: async (actor, input) => {
+            const reply = await team.execute(actor, input);
+            const who = identify(request, false);
+            return who?.via === 'cookie' ? teamBrowserReply(reply, who.session.csrf) : reply;
+        }, cursor: team.cursor, streams: teamStreams,
     });
     const sessionEndpoint = createSessionEndpoint({ store, workspace: coding, projects: codingProjects, projectAllowed: repo => rowVisible(liveCeiling(), repo) });
     /** The enumerable admission list for roll-up SQL: repos-only ceilings
@@ -3585,11 +3602,11 @@ export function createDecisionServer(options) {
             if (who.via !== "cookie")
                 return refuse(response, who, 403, "chat is a browser surface — it keeps your drafts in the session");
             if (url.searchParams.get('private') !== '1' && !url.searchParams.has('task') && !url.searchParams.has('result') && !url.searchParams.has('project')) {
-                const reply = await team.execute({ name: who.name, generation: who.session.generation }, {
+                const reply = teamBrowserReply(await team.execute({ name: who.name, generation: who.session.generation }, {
                     operation: url.searchParams.has('conversation') ? 'show' : 'list',
                     args: { ...(url.searchParams.has('conversation') ? { conversationId: url.searchParams.get('conversation') } : {}),
                         ...(url.searchParams.has('lead') ? { leadId: url.searchParams.get('lead') } : {}) },
-                });
+                }), who.session.csrf);
                 if (!reply.ok || !reply.snapshot)
                     return refuse(response, who, 403, reply.message, '/chat?private=1');
                 if (url.searchParams.has('proposal')) {
@@ -3599,11 +3616,7 @@ export function createDecisionServer(options) {
                         return refuse(response, who, 404, 'This proposal is unavailable.', '/chat');
                     const back = '/chat?conversation=' + encodeURIComponent(selected.id);
                     const decision = proposal.kind === 'answer' && typeof proposal.payload['decision'] === 'number' ? store.getDecision(proposal.payload['decision']) : null;
-                    const active = reply.snapshot.messages.some(message => message.status === 'running');
-                    const canAct = reply.snapshot.canSend && reply.snapshot.chatAuthorization?.enabled === true;
-                    let card = mateProposalCard(proposal, who.session.csrf, !canAct || active, decision, back);
-                    if (!canAct)
-                        card = card.replace('Available when the current turn finishes.', reply.snapshot.canSend ? 'Enable chat in this conversation before acting on a proposal.' : 'An authorized contributor can act on this proposal.');
+                    const card = teamProposalCardParts(proposal, reply.snapshot, who.session.csrf, decision).html;
                     return sendScreen(response, 200, screen('Review action', `<p><a href="${escape(back)}">Back to conversation</a></p>` + card, { chrome: chromeFor(null, 'chat', undefined, 'all') }));
                 }
                 if (reply.snapshot.leads.length > 0 || url.searchParams.has('conversation') || url.searchParams.get('team') === '1') {
@@ -4290,7 +4303,7 @@ export function createDecisionServer(options) {
             })(), (() => {
                 const chosen = store.notificationPreference(who.name);
                 return { mode: chosen.mode, digestAt: chosen.digestAt, screenshots: chosen.screenshots, projects: notificationProjects(store, who.name) };
-            })(), telegramTrouble(store, loadBotToken(process.env, options.telegramTokenFile))));
+            })(), telegramTrouble(store, loadBotToken(process.env, options.telegramTokenFile)), who.via === "cookie" ? phoneSetup(who) ?? null : null));
         }
         if (url.pathname === "/push/key") {
             // Session-gated: the key is not secret, but strangers get nothing.
@@ -4464,12 +4477,19 @@ export function createDecisionServer(options) {
         return first !== undefined && String(first["id"]) === rootId;
     }
     /** After the first Ready result, once (onboarding): the phone, by a chat app or the console over Tailscale. */
+    /** Chat's one-line pointer to the phone setup: after the first Ready result, until put away or Telegram is paired. */
     function phoneCard(who, now) {
         if (who.role !== "approver" || store.isDemo() || store.firstSuccessAt(now) === null || store.installationFact(PHONE_CARD_FACT) !== null)
             return undefined;
         const botId = options.telegramTokenFile === undefined ? null : loadBotToken(process.env, options.telegramTokenFile)?.botId ?? null;
         if (botId !== null && store.liveTelegramBindings(botId).length > 0)
             return undefined;
+        return phoneSetup(who);
+    }
+    /** The phone setup itself (Settings → Chat apps): a chat app, or this console over Tailscale. */
+    function phoneSetup(who) {
+        if (who.role !== "approver" || store.isDemo())
+            return undefined;
         const port = servedPort() ?? 4180;
         const address = server.address();
         const bound = typeof address === "object" && address !== null ? address.address : "127.0.0.1";
@@ -4509,7 +4529,11 @@ export function createDecisionServer(options) {
         const ask = last?.role === "assistant" && last.turn !== null && store.getMateTurn(last.turn)?.approver === who.name ? store.mateAskOpen(last.turn, now) : null;
         // Answered questions stay readable above the answer; only their buttons go.
         const asks = new Map(messages.flatMap(one => { const asked = one.role === "assistant" && one.turn !== null ? store.mateAsk(one.turn) : null; return asked === null ? [] : [[asked.turn, asked]]; }));
+        // The thread a ceiling change replaced (ruling 9): read after the open, display only.
+        const replaced = store.replacedLeadThread(opened.thread);
+        const previousProposals = replaced === null ? [] : store.listMateProposals(replaced.id);
         return {
+            previous: replaced === null ? null : { messages: store.listMateMessages(replaced.id, 40), proposals: previousProposals, decisions: decisionsFor(store, previousProposals) },
             messages,
             ask,
             asks,
@@ -4540,14 +4564,25 @@ export function createDecisionServer(options) {
             clearTimeout(previous.expiry);
         const live = { steps: [], done: false, ok: false, listeners: previous?.listeners ?? new Set() };
         liveTurns.set(thread, live);
-        const current = () => live.steps.at(-1) ?? (live.steps.push({ tools: [], text: "" }), live.steps.at(-1));
+        const current = () => live.steps.at(-1) ?? (live.steps.push({ tools: [], toolCalls: [], text: "" }), live.steps.at(-1));
         return event => {
             if (live.done)
                 return;
             if (event.kind === "step")
-                live.steps.push({ tools: [], text: "" });
-            else if (event.kind === "tool")
+                live.steps.push({ tools: [], toolCalls: [], text: "" });
+            else if (event.kind === "tool") {
                 current().tools.push(event.label);
+                current().toolCalls.push({ id: event.id, label: event.label, state: "running" });
+            }
+            else if (event.kind === "tool-result") {
+                for (const step of live.steps) {
+                    const index = step.toolCalls.findIndex(tool => tool.id === event.id);
+                    if (index !== -1) {
+                        step.toolCalls[index] = { ...step.toolCalls[index], ...event.outcome };
+                        break;
+                    }
+                }
+            }
             else if (event.kind === "text")
                 current().text = event.text;
             for (const listener of live.listeners)
@@ -15395,6 +15430,8 @@ ${THEME_DARK}
     min-height: min(32rem, 48vh); padding: .25rem;
   }
   .thread .msg { max-width: 48rem; line-height: 1.65; overflow-wrap: anywhere; }
+  .chat-previous-divider { display: flex; align-items: center; gap: .6rem; margin: 1rem 0; color: var(--so-muted); font-size: .8rem; }
+  .chat-previous-divider::before, .chat-previous-divider::after { content: ""; flex: 1; border-top: 1px solid var(--so-line); }
   .thread .msg p { margin: .3rem 0; }
   .thread .msg.op {
     align-self: flex-end; max-width: min(82%, 40rem); padding: .75rem 1rem;
@@ -18300,6 +18337,19 @@ function mateProposalCard(proposal, csrf, inert, decision, returnTo = null) {
 function mateProposalCardParts(proposal, csrf, inert, decision, returnTo = null) {
     return proposalCardParts({ id: proposal.id, kind: proposal.kind, payload: proposal.payload, state: proposal.state, outcome: proposal.outcome, by: { mate: true }, actionBase: "/chat/proposal" }, csrf, inert, decision, returnTo);
 }
+/** Review and inline team cards share the same server-decided controls and reasons. */
+function teamProposalCardParts(proposal, snapshot, csrf, decision) {
+    const canAct = snapshot.canSend && snapshot.chatAuthorization?.enabled === true;
+    const active = snapshot.messages.some(message => message.status === 'running');
+    const back = '/chat?conversation=' + encodeURIComponent(snapshot.selected.id);
+    const parts = mateProposalCardParts(proposal, csrf, !canAct || active, decision, back);
+    if (!canAct && proposal.state === 'pending') {
+        const reason = snapshot.canSend ? 'Enable chat in this conversation before acting on a proposal.' : 'An authorized contributor can act on this proposal.';
+        parts.html = parts.html.replace('Available when the current turn finishes.', reason);
+        parts.card = { ...parts.card, note: reason };
+    }
+    return parts;
+}
 function coordinatorProposalCard(proposal, csrf, now, decision, returnTo = null) {
     return proposalCard({ id: proposal.id, kind: proposal.kind, payload: proposal.payload, state: proposal.state, outcome: proposal.outcome, by: { mate: false, name: proposal.name, ago: relativeAge(proposal.createdAt, now) }, actionBase: "/proposals" }, csrf, false, decision, returnTo);
 }
@@ -18319,6 +18369,24 @@ function coordinatorProposalsSection(proposals, decisions, csrf, now, heading =
         proposals.map(one => coordinatorProposalCard(one, csrf, now, decisions.get(typeof one.payload["decision"] === "number" ? one.payload["decision"] : -1) ?? null, returnTo)).join("") +
         `</div>`);
 }
+const REPLACED_THREAD_DIVIDER = "New conversation — the projects I can reach changed";
+/** The replaced thread as the React conversation renders it: words and card outcomes, no buttons. */
+function replacedBrowserMessages(previous, csrf) {
+    return mateBrowserMessages({ ...previous, pending: null, ask: null, asks: new Map() }, csrf, null).map(message => ({
+        ...message, cardsHtml: "",
+        cards: (message.cards ?? []).map(card => ({ ...card, primary: null, dismissable: false })),
+    }));
+}
+/** The replaced thread for the server-rendered page: read only, then the divider. */
+function replacedThreadHtml(previous) {
+    if (previous == null)
+        return "";
+    return `<section class="thread chat-previous" aria-label="Earlier conversation" data-previous-thread>` +
+        previous.messages.map(one => one.role === "operator"
+            ? `<div class="msg op" data-previous-message="${one.id}"><p style="white-space:pre-wrap">${escape(one.text)}</p></div>`
+            : `<div class="msg mate" data-previous-message="${one.id}">${renderChatText(one.text)}</div>`).join("") +
+        `<p class="chat-previous-divider" role="separator" data-thread-divider>${escape(REPLACED_THREAD_DIVIDER)}</p></section>`;
+}
 /** The lead's question as buttons: each option sends itself as the next message (the same POST as a typed one);
  * "Something else" moves to the composer. Nothing shows while a reply is running. */
 function mateAskHtml(ask, csrf, target, composer, open = true) {
@@ -18367,6 +18435,7 @@ function mateChatVersion(rows) {
     const focus = rows.focusTask;
     const facts = [
         rows.messages.map(one => [one.id, one.role, one.turn]),
+        rows.previous == null ? null : rows.previous.messages.map(one => one.id),
         rows.proposals.map(one => [one.id, one.state, one.outcome === null ? null : JSON.stringify(one.outcome)]),
         rows.coordinatorProposals.map(one => [one.id, one.state, one.outcome === null ? null : JSON.stringify(one.outcome)]),
         [...rows.decisions.values()].map(one => [one.id, one.state, one.choice ?? null]),
@@ -18493,6 +18562,7 @@ function matePage(chrome, data) {
     }
     const lastMessage = data.messages.at(-1);
     const latestReply = data.pending === null && lastMessage?.role === "assistant" ? lastMessage.id : null;
+    conversation.push(replacedThreadHtml(data.previous));
     conversation.push(mateThreadHtml({ ...data, problem: null, chatProject }));
     conversation.push(
     // The New update action (package 2): hidden until a live update lands
@@ -18513,6 +18583,7 @@ function matePage(chrome, data) {
                 messages: mateBrowserMessages(data, data.csrf, data.focusTask === null && chatProject === null ? null : returnTo, { task: data.focusTask?.id ?? null, project: chatProject }),
                 pendingTurnId: data.pending?.id ?? null, requestId: randomBytes(16).toString('hex'), maxChars: MATE_MESSAGE_MAX_CHARS,
                 taskId: data.focusTask?.id ?? null, resultRunId: data.resultRunId ?? null, project: chatProject,
+                ...(data.previous == null ? {} : { previous: { messages: replacedBrowserMessages(data.previous, data.csrf) } }),
             },
             focus: data.focusTask === null ? null : { id: data.focusTask.id, title: data.focusTask.title,
                 html: taskChatLiveRegion(data.focusTask, data.csrf, requestContext.getStore()?.workspaceRead === true, data.pending !== null) },
@@ -24046,7 +24117,7 @@ function notificationProjects(store, account) {
         .map(one => ({ repo: one.path, name: one.name, muted: muted.has(one.path) }))
         .sort((a, b) => a.name.localeCompare(b.name));
 }
-function settingsPage(chrome, existing, hasEnv, csrf, problem, messaging = null, push = null, providerKeys = null, digest = null, permissionDefault = null, qualityDefault = null, email = null, telegramDelivery = null, workers = null, updates = null, firstResult = null, chatNotices = null, telegramFailing = false) {
+function settingsPage(chrome, existing, hasEnv, csrf, problem, messaging = null, push = null, providerKeys = null, digest = null, permissionDefault = null, qualityDefault = null, email = null, telegramDelivery = null, workers = null, updates = null, firstResult = null, chatNotices = null, telegramFailing = false, phone = null) {
     const permissionCard = permissionDefault === null
         ? ""
         : [
@@ -24272,10 +24343,12 @@ function settingsPage(chrome, existing, hasEnv, csrf, problem, messaging = null,
         workers,
         updates,
         firstResult,
+        ...(phone === null ? {} : { phone }),
     };
     return screen("Settings", [
         "<h1>Settings</h1>",
         settingsTiles(view.groups),
+        phone === null ? "" : phoneSetupHtml(phone),
         appearanceCard(csrf),
         permissionCard,
         qualityCard,
@@ -24301,6 +24374,15 @@ function settingsPage(chrome, existing, hasEnv, csrf, problem, messaging = null,
         `</details>`,
     ].join("\n"), { chrome, workspace: { view }, functional: { script: SETTINGS_AUTOSAVE_SCRIPT + (pushScript ?? ""), ...(pushScript === null ? {} : { fetches: true }) } });
 }
+/** The phone setup for the server-rendered Settings page: the same choices as the React card. */
+function phoneSetupHtml(phone) {
+    const [first, ...others] = phone.chatApps;
+    return `<section class="card" id="phone" aria-labelledby="phone-card-title" data-phone-card><h2 id="phone-card-title">Use it from your phone</h2>` +
+        `<p>${first === undefined ? "" : `<a href="${escape(first.href)}">Pair ${escape(first.label)}</a>`}${others.length === 0 ? "" : ` · or ${others.map(one => `<a href="${escape(one.href)}">${escape(one.label)}</a>`).join(", ")}`}</p>` +
+        `<p class="meta" data-phone-tailnet>${phone.tailnet === null ? `Or install <a href="https://tailscale.com/download">Tailscale</a> on this computer and your phone, then reload this page for the address.`
+            : phone.tailnet.restart === null ? `Or on your phone open <code>${escape(phone.tailnet.address)}</code> and sign in.`
+                : `Or start Toolroll with <code>${escape(phone.tailnet.restart)}</code>, then on your phone open <code>${escape(phone.tailnet.address)}</code> and sign in.`}</p></section>`;
+}
 /** Every worker that is not retired: its capacity, and the tasks it holds now. */
 function settingsWorkers(store, now) {
     const claims = store.liveClaims(null, now);

package/dist/store.d.ts

@@ -6323,6 +6323,11 @@ export declare class Store {
     };
     /** The approver's live thread for one scope, read only — null when none is open. */
     liveMateThreadFor(approver: string, scope?: MateThreadScope): MateThread | null;
+    /** The lead thread a ceiling change closed just before `current` (ruling 9),
+     * read only and for display only: it never continues and never reaches the
+     * model. Null when there is none, when it was ended or revoked (its text is
+     * gone), or when it closed under the same ceiling. */
+    replacedLeadThread(current: MateThread): MateThread | null;
     /** The task a paired chat is talking about (v78), or null for the lead conversation. */
     chatFocus(surface: string, binding: number): string | null;
     setChatFocus(surface: string, binding: number, task: string | null, now: Date): void;

package/dist/store.js

@@ -19275,6 +19275,20 @@ export class Store {
         const row = this.db.prepare("SELECT * FROM mate_thread WHERE approver = ? AND scope_kind = ? AND scope_key IS ? AND closed_at IS NULL AND NOT EXISTS (SELECT 1 FROM team_conversation tc WHERE tc.thread=mate_thread.id) ORDER BY id DESC LIMIT 1").get(approver, scope.kind, scope.kind === "lead" ? null : scope.key);
         return row === undefined ? null : readMateThread(row);
     }
+    /** The lead thread a ceiling change closed just before `current` (ruling 9),
+     * read only and for display only: it never continues and never reaches the
+     * model. Null when there is none, when it was ended or revoked (its text is
+     * gone), or when it closed under the same ceiling. */
+    replacedLeadThread(current) {
+        if (current.scope.kind !== "lead")
+            return null;
+        const row = this.db.prepare(`SELECT * FROM mate_thread WHERE approver = ? AND scope_kind = 'lead' AND scope_key IS NULL AND id < ? AND closed_at IS NOT NULL
+      AND NOT EXISTS (SELECT 1 FROM team_conversation tc WHERE tc.thread=mate_thread.id) ORDER BY id DESC LIMIT 1`).get(current.approver, current.id);
+        if (row === undefined || String(row["ceiling_digest"]) === current.ceilingDigest)
+            return null;
+        const previous = readMateThread(row);
+        return this.db.prepare("SELECT 1 FROM mate_message WHERE thread = ? LIMIT 1").get(previous.id) === undefined ? null : previous;
+    }
     /** The task a paired chat is talking about (v78), or null for the lead conversation. */
     chatFocus(surface, binding) {
         const row = this.db.prepare("SELECT task FROM chat_focus WHERE surface = ? AND binding = ?").get(surface, binding);

package/dist/team-contract.d.ts

@@ -1,4 +1,5 @@
 import type { WorkIndexPage } from './work-index.js';
+import type { BrowserActionCard } from './browser-workspace.js';
 /** Shared central-team transport contract. Requests never establish actor identity. */
 export type TeamActor = {
     name: string;
@@ -52,6 +53,15 @@ export type TeamChatAuthorization = {
     termsDigest: string;
     waitingReason?: string;
 };
+/** Browser cards extend the existing CLI summary; both refer to the same saved proposal. */
+export type TeamProposal = {
+    id: number;
+    turnId: number;
+    title: string;
+    state: string;
+    href: string;
+    card?: BrowserActionCard;
+};
 export type TeamSnapshot = {
     leads: TeamLead[];
     conversations: TeamConversation[];
@@ -67,13 +77,7 @@ export type TeamSnapshot = {
     accounts: string[];
     chatAuthorization?: TeamChatAuthorization;
     tasks?: WorkIndexPage;
-    proposals?: {
-        id: number;
-        turnId: number;
-        title: string;
-        state: string;
-        href: string;
-    }[];
+    proposals?: TeamProposal[];
 };
 export declare const TEAM_OPERATIONS: readonly ['list', 'show', 'create-lead', 'update-lead', 'create-conversation', 'member', 'send', 'edit', 'withdraw', 'read', 'authorize', 'follow', 'stop', 'transfer'];
 export type TeamOperation = typeof TEAM_OPERATIONS[number];

package/dist/telegram-flow.d.ts

@@ -11,6 +11,12 @@ type Waiting = {
 };
 /** The card, if it is still at that visit, waiting at a decision. */
 export declare function flowDecisionAt(store: Store, cardId: number, entry: number): Waiting | null;
+/**
+ * A flow decision as Telegram shows it: the action and where each button takes the card first, then the draft (as
+ * the card holds it now, so what is approved is what is read) and why a teammate handed it over, then the flow and
+ * zone. `said` is the saved notice's body: the words before its instruction are the teammate's handoff.
+ */
+export declare function flowDecisionText(waiting: Waiting, said: string | null, head?: string): string;
 /** Buttons for one visit, minted before the send; `place` stamps the message they landed on. */
 export declare function flowButtons(store: Store, binding: TelegramBinding, waiting: Waiting, now: Date): {
     keyboard: InlineButton[][];
@@ -20,6 +26,9 @@ export declare function flowButtons(store: Store, binding: TelegramBinding, wait
 export declare function flowSentContent(store: Store, card: number, entry: number): FlowSendContent | null;
 /** A sent visit's links as one row of buttons: Toolroll's pages under the trusted origin, and its pull request. */
 export declare function flowSendKeyboardRow(origin: string | null, content: FlowSendContent): InlineButton[];
+/** A choice as Telegram shows it, first: what to choose, then where each option (and a reply) takes the card. The
+ * options are the ones its buttons carry: offered when sent, and still offered. */
+export declare function flowChoiceHead(visit: FlowChoiceVisit, content: FlowSendContent): string[];
 /** A choice's buttons for one visit, one option to a row, minted before the send; `place` stamps the message they landed on. */
 export declare function flowChoiceButtons(store: Store, binding: TelegramBinding, visit: FlowChoiceVisit, content: FlowSendContent, now: Date): {
     keyboard: InlineButton[][];