toolroll 0.8.2 → 0.9.1

package/dist/browser-workspace.d.ts

@@ -201,6 +201,11 @@ export type BrowserSettingsView = {
             removable: boolean;
         }[];
     } | null;
+    /** Quiet chat: how chats reach this person, and their evening digest time (null: off). */
+    chat?: {
+        mode: 'quiet' | 'all';
+        digestAt: string | null;
+    } | null;
     digest: {
         every: string;
         held: string | null;
@@ -317,6 +322,11 @@ export type BrowserTaskView = {
         html: string;
         open: boolean;
     } | null;
+    /** "Do this every time…": Settings → Flows with the matching starter flow marked. */
+    everyTime?: {
+        href: string;
+        starter: string;
+    } | null;
 };
 /** One project on the Projects page; opening it is a POST to /projects/open. */
 export type BrowserProjectRow = {
@@ -327,6 +337,11 @@ export type BrowserProjectRow = {
     /** When it was last opened here; null for a project only seen in the queue. */
     openedAt: string | null;
     knowledgeHref: string;
+    /** Settings → Projects → Pull requests for this project, and whether they are on. */
+    pullRequests?: {
+        href: string;
+        on: boolean;
+    };
     /** What waits, runs, queues or finished today; null when not scanned. */
     peek: {
         label: string;
@@ -457,7 +472,7 @@ export type BrowserResultView = {
 export type BrowserFlowStage = {
     id: string;
     title: string;
-    kind: "inbox" | "task" | "report" | "approval" | "check" | "update" | "notify" | "sort" | "draft" | "request" | "email" | "tool" | "wait" | "teammate" | "done";
+    kind: "inbox" | "task" | "report" | "approval" | "check" | "pull-request" | "update" | "notify" | "sort" | "draft" | "request" | "email" | "tool" | "wait" | "teammate" | "done";
     zone: {
         x: number;
         y: number;
@@ -515,9 +530,14 @@ export type BrowserFlowStage = {
     } | null;
     /** v91: a Wait zone waits for a reply to the card's email (onFail: no reply in time) or a set time; any other zone may have a time limit. */
     wait?: {
-        for: "reply" | "time";
+        for: "reply" | "time" | "hours";
         minutes: number;
+        from?: string;
+        to?: string;
+        timeZone?: string;
     };
+    /** A Pull request zone merges once checks pass (after a person approved), this way. */
+    merge?: "squash" | "merge" | "rebase" | undefined;
     limit?: {
         minutes: number;
         to: string | null;

package/dist/chat-actions.d.ts

@@ -61,6 +61,11 @@ export declare const CHAT_ACTIONS: {
         readonly protected: false;
         readonly password: false;
     };
+    readonly flow_starter: {
+        readonly label: "Switch on";
+        readonly protected: false;
+        readonly password: false;
+    };
     readonly flow_edit: {
         readonly label: "Save flow";
         readonly protected: false;

package/dist/chat-actions.js

@@ -28,6 +28,7 @@ import { cleanMemory, editMemory, forgetMemory, tellTeammate } from "./teammate-
 import { addRoutine, removeRoutine, routineSchedule, routinesOf } from "./teammate-desk.js";
 import { requestUndo, undoFor } from "./teammate-week.js";
 import { kitInstalled, kitOf, KITS, setUpKitNow } from "./kits.js";
+import { starterFlowOf, starterOf, startersFor, starterTerms, STARTER_FLOWS, switchOnStarter } from "./flow-starters.js";
 import { answerTeammateQuestion } from "./teammate-work.js";
 import { callWords, checkRule, defaultRule, grantListed, revokeTool, ruleWords, setToolRules } from "./teammate-tools.js";
 /** A tool from the lead's card: a common tool by its id, or the operator's own program or address. */
@@ -77,6 +78,8 @@ export const CHAT_ACTIONS = {
     tool_remove: { label: "Remove tool", protected: false, password: false },
     // Flows: a drawing and cards on it. Any work a card files is an ordinary task under the usual approvals.
     flow_create: { label: "Create flow", protected: false, password: false },
+    // A starter flow: its zones and its trigger, switched on with one yes (flow-starters.ts).
+    flow_starter: { label: "Switch on", protected: false, password: false },
     flow_edit: { label: "Save flow", protected: false, password: false },
     flow_card_add: { label: "Add card", protected: false, password: false },
     flow_card_move: { label: "Move card", protected: false, password: false },
@@ -128,7 +131,8 @@ export const CHAT_ACTION_FIELDS = {
     knowledge_restore: ["repo", "restore"],
     tool_add: ["repo", "catalog", "name", "command", "args", "url", "secrets", "about"],
     tool_remove: ["repo", "name"],
-    flow_create: ["repo", "name", "definition"],
+    flow_create: ["repo", "name", "definition", "trigger"],
+    flow_starter: ["repo", "starter"],
     flow_edit: ["flow", "name", "definition"],
     flow_card_add: ["flow", "title", "description", "zone"],
     flow_card_move: ["card", "zone"],
@@ -265,7 +269,7 @@ export function prepareSharedAction(store, who, operation, input, root, now = ne
     const task = operation.startsWith("skill_") || operation.startsWith("knowledge_") || operation.startsWith("decision_") || operation.startsWith("tool_") || operation.startsWith("flow_") || operation.startsWith("teammate_") || operation.startsWith("kit_")
         ? null
         : text(input, "task", 64);
-    const flowTarget = operation.startsWith("flow_") && operation !== "flow_create" && operation !== "flow_script_save" ? flowTargetOf(store, input) : null;
+    const flowTarget = operation.startsWith("flow_") && operation !== "flow_create" && operation !== "flow_script_save" && operation !== "flow_starter" ? flowTargetOf(store, input) : null;
     // v92: a teammate names its project; a question names it through its card's flow.
     const mateTarget = operation.startsWith("teammate_") && operation !== "teammate_create" && operation !== "teammate_answer" ? store.getTeammate(integer(input, "teammate")) : null;
     if (mateTarget !== null && mateTarget.state === "removed")
@@ -551,6 +555,28 @@ export function prepareSharedAction(store, who, operation, input, root, now = ne
             state = {};
             title = `Create the ${name} flow in ${project}`;
             terms.push(...flowTerms(definition, null));
+            // A template's trigger (Issues to PRs: labelled issues) comes with it, checked as the flow will have it.
+            if (input["trigger"] !== undefined) {
+                const draft = { id: 0, repo, name, definitionJson: JSON.stringify(definition), revision: 1, state: "active", createdBy: who.name, createdAt: now.toISOString(), updatedBy: who.name, updatedAt: now.toISOString(), owner: who.name };
+                const config = validateTriggerConfig(input["trigger"], { store, flow: draft, definition, actor: who.name });
+                if (takesDeliveries(config))
+                    throw Error("Webhook addresses are secrets, so they are set up on the flow's Triggers panel.");
+                request["trigger"] = config;
+                terms.push(`Starts cards from: ${describeTrigger(config, store)}. Only what happens from now on counts.`);
+            }
+        }
+        else if (operation === "flow_starter") {
+            const starter = starterOf(String(input["starter"] ?? ""));
+            if (starter === null)
+                throw Error(`Choose a starter flow: ${STARTER_FLOWS.map(one => one.id).join(", ")}.`);
+            if (starterFlowOf(store, starter, repo) !== null)
+                throw Error(`${starter.name} is already on in ${project}.`);
+            const blocked = startersFor(store, repo).find(one => one.id === starter.id)?.blocked ?? null;
+            if (blocked !== null)
+                throw Error(blocked);
+            state = {};
+            title = `Switch on ${starter.name} in ${project}`;
+            terms.push(...starterTerms(store, starter, repo));
         }
         else if (operation === "flow_edit") {
             const { flow, definition: before } = flowTarget;
@@ -1214,9 +1240,23 @@ function runFlowAction(store, payload, actor, repos, root, now) {
         return { said: `${said}${filed}`, href: card === null ? `/flows/${flow}` : flowCardHref(flow, card) };
     };
     if (payload.operation === "flow_create") {
-        const id = store.createFlow({ repo: payload.repo, name: String(req["name"]), definitionJson: JSON.stringify(req["definition"]), by: actor }, now);
+        const id = store.transact(() => {
+            const made = store.createFlow({ repo: payload.repo, name: String(req["name"]), definitionJson: JSON.stringify(req["definition"]), by: actor }, now);
+            if (req["trigger"] !== undefined) {
+                const trigger = addFlowTriggerTo(store, store.getFlow(made), req["trigger"], actor, now, null);
+                if (!trigger.ok)
+                    throw Error(trigger.message);
+            }
+            return made;
+        });
         return { said: "Flow created. Add cards to it here or on its canvas.", href: `/flows/${id}` };
     }
+    if (payload.operation === "flow_starter") {
+        const switched = switchOnStarter(store, starterOf(String(req["starter"])), payload.repo, actor, now, configDirOf(store));
+        if (!switched.ok)
+            throw Error(switched.said);
+        return { said: switched.said, href: `/flows/${switched.flow}` };
+    }
     if (payload.operation === "flow_edit") {
         const flow = Number(payload.state["flow"]);
         if (!store.saveFlow(flow, { name: String(req["name"]), definitionJson: JSON.stringify(req["definition"]), sawRevision: Number(payload.state["revision"]), by: actor }, now))

package/dist/chat-delivery.js

@@ -9,6 +9,7 @@ import { answerChatFlowPrompt, applyChatFlowTap, flowDecisionParts } from "./cha
 import { connectChannel, FLOW_WORDS, takeChannelMessage, watchedChannel } from "./chat-inbox.js";
 import { triggerConfigOf } from "./flow-triggers.js";
 import { telegramProgressCard } from "./telegram-progress.js";
+import { enqueueEveningDigests, isTaskFact, needsPerson, quietCardView, readyPingView } from "./chat-quiet.js";
 import { phoneText, PHONE_HELP, phoneCommand, phoneStatus, phoneTaskView, phoneTaskChoices, phoneTaskListText, resolvePhoneTask, phoneFocusText, PHONE_NO_MATCH, PHONE_BACK_TO_LEAD } from "./telegram-status.js";
 import { applyRoomInbound, conversationRow, roomCardApprover, roomCommand, roomGrantAllowed, roomMessagesAfter, roomMessageText, teamDomain } from "./chat-rooms.js";
 import { isTelegramProgressNotification, proposalTaskOf } from "./store.js";
@@ -574,6 +575,33 @@ export async function planRoomMessages(options) {
         }
     }
 }
+/** Quiet mode: the task's one card (or its group's) in this person's chat, planned once and then repainted in
+ * place whenever what it says changes. */
+function planQuietCard(options, binding, notification, now) {
+    const { state, store, identity } = options;
+    if (notification.taskRef === null || notification.taskId === null)
+        return;
+    const card = store.chatCardFor(`${state.channel}:${binding.id}`, notification.taskRef, store.getTask(notification.taskId)?.createdAt ?? notification.createdAt, now);
+    const view = quietCardView(store, card.tasks, now, options.evidenceRoot);
+    if (view === null)
+        return;
+    const content = { text: view.text, link: view.link, ...(card.tasks.length === 1 ? { task: notification.taskId } : {}) };
+    const shown = chatHash(JSON.stringify(content));
+    if (card.message !== null) {
+        if (card.digest === shown)
+            return;
+        state.prepare("UPDATE chat_part SET payload=?,state='pending',created=?,next_at=NULL WHERE id=? AND state!='dropped'").run(JSON.stringify(content), now.toISOString(), Number(card.message));
+        store.setChatCardMessage(card.id, card.message, shown);
+        return;
+    }
+    const id = chatHash(`${state.channel}:card:${binding.id}:${card.id}`);
+    state.enqueue({ id, installation: identity.installation, binding: binding.id, kind: "notice", channel: binding.channel, member: binding.member,
+        ts: "", thread: "", payload: "{}", created: now.toISOString() });
+    state.plan(id, [content], now);
+    const part = state.prepare("SELECT id FROM chat_part WHERE event=?").get(id);
+    if (part !== undefined)
+        store.setChatCardMessage(card.id, String(part.id), shown);
+}
 /** One progress card per exact result; separate urgent facts retain their own review link. */
 export async function planChatNotifications(options) {
     const state = options.state, { store, identity } = options, bindings = state.bindings(identity.installation).filter(one => state.live(one));
@@ -582,6 +610,11 @@ export async function planChatNotifications(options) {
         !options.current())
         return;
     const registry = await options.readProjects();
+    // An evening digest someone asked for is due: record it as their own notification, delivered below.
+    try {
+        enqueueEveningDigests(store, nowOf(options), options.evidenceRoot);
+    }
+    catch { /* Retried on the next pass. */ }
     const cursor = Number(state
         .prepare("SELECT notification FROM chat_runtime WHERE installation=?")
         .get(identity.installation)?.notification ?? 0);
@@ -602,7 +635,22 @@ export async function planChatNotifications(options) {
                         : (notification.taskId || notification.kind === "flow-decision") && notification.project !== null && repos.includes(notification.project))) {
                     const run = store.telegramProgressRun(notification);
                     const id = chatHash(`${options.state.channel}:notice:${binding.id}:${notification.id}`), now = nowOf(options);
-                    if (run && notification.taskId && notification.project !== null && isTelegramProgressNotification(notification)) {
+                    // Only when I'm needed (the default): the task's one card is edited in place, and a new message
+                    // follows only when this person is needed. Every step keeps the branches below unchanged.
+                    const quiet = !personal && isTaskFact(notification) && store.notificationPreference(binding.approver).mode === "quiet";
+                    if (quiet) {
+                        planQuietCard(options, binding, notification, now);
+                        if (!needsPerson(notification))
+                            return;
+                        if (notification.kind === "run-finished" && run) {
+                            const ping = readyPingView(store, store.getRun(run.id), notification.taskId, notification.project, now, options.evidenceRoot);
+                            state.enqueue({ id, installation: identity.installation, binding: binding.id, kind: "notice", channel: binding.channel, member: binding.member,
+                                ts: "", thread: "", payload: "{}", created: now.toISOString() });
+                            state.plan(id, [{ text: ping.text, task: notification.taskId, run: run.id, link: ping.link }], now);
+                            return;
+                        }
+                    }
+                    if (!quiet && run && notification.taskId && notification.project !== null && isTelegramProgressNotification(notification)) {
                         const card = telegramProgressCard(store, store.getRun(run.id), notification.taskId, notification.project, now, options.evidenceRoot);
                         const content = {
                             text: card.text,
@@ -661,7 +709,7 @@ export async function planChatNotifications(options) {
                             ts: "", thread: "", payload: "{}", created: now.toISOString() });
                         state.plan(id, questionParts(store, notification, binding), now);
                     }
-                    else if (notification.pushClass !== null || personal) {
+                    else if (notification.pushClass !== null || personal || quiet) {
                         state.enqueue({
                             id,
                             installation: identity.installation,
@@ -680,7 +728,7 @@ export async function planChatNotifications(options) {
                                 ...(notification.taskId ? { task: notification.taskId } : {}),
                                 ...(run ? { run: run.id } : {}),
                                 ...(notification.link
-                                    ? { link: { label: personal ? "Open" : "Review", path: notification.link } }
+                                    ? { link: { label: notification.kind === "pull-request-ready" ? "Merge" : personal ? "Open" : "Review", path: notification.link } }
                                     : {}),
                             },
                         ], now);

package/dist/chat-quiet.d.ts

@@ -0,0 +1,28 @@
+import { type ProgressEntity } from "./telegram-progress.js";
+import { type PhoneTaskLink } from "./telegram-status.js";
+import { type Notification, type Run, type Store } from "./store.js";
+export type QuietView = {
+    text: string;
+    entities: ProgressEntity[];
+    link: PhoneTaskLink;
+};
+export declare function needsPerson(row: Pick<Notification, "dedupeKey" | "kind" | "pushClass" | "recipient">): boolean;
+/** A fact about one placed task: in quiet mode it lands on that task's card. */
+export declare function isTaskFact(row: Pick<Notification, "taskRef" | "taskId" | "project">): row is typeof row & {
+    taskRef: number;
+    taskId: string;
+    project: string;
+};
+/** The card's words now: one task's progress card, or one line per task when several were filed together. */
+export declare function quietCardView(store: Store, taskRefs: readonly number[], now: Date, root?: string): QuietView | null;
+/** The one ping for a Ready result: its state and title, what to do next, and a link to that exact result. */
+export declare function readyPingView(store: Store, run: Run, taskId: string, project: string, now: Date, root?: string): QuietView;
+/** This computer's local day and time, which is what a person means by "the evening". */
+export declare function localDay(now: Date): string;
+export declare function localTime(now: Date): string;
+/** One person's evening: what finished and what failed in the last day, and what waits for them now. Null when
+ * nothing happened, so a quiet day sends nothing. */
+export declare function eveningDigestText(store: Store, account: string, now: Date, root?: string): string | null;
+/** Record each due evening digest once per person per local day, as one notification addressed to that person:
+ * every chat they paired delivers it with the usual receipts, and the console keeps it. */
+export declare function enqueueEveningDigests(store: Store, now: Date, root?: string): number;

package/dist/chat-quiet.js

@@ -0,0 +1,161 @@
+/** Quiet chat: a task's whole life is one chat message edited in place, and a
+ * new message arrives only when a person is needed. Every transport (Telegram,
+ * Slack, Discord, Teams) asks the same questions here: does this fact need a
+ * person, what does the task's card say now, and what does the Ready ping say.
+ * Delivery receipts, claims and retries stay with each transport; the
+ * console's activity keeps every fact whatever a chat showed. */
+import { assignmentOf } from "./assignment.js";
+import { chatControlHref } from "./chat-controls.js";
+import { telegramProgressCard } from "./telegram-progress.js";
+import { phoneText, projectLabel } from "./telegram-status.js";
+import { isLifecycleNotification } from "./store.js";
+/** What always makes a new message, even in quiet mode: a question or approval waiting, a failure or other
+ * attention fact, a result Ready for review, a security alert or release, and anything addressed to one person
+ * (a sign-in or plan-limit pause, an evening digest). */
+const NEEDED_KINDS = new Set([
+    "acceptance-ready", "acceptance-evidence", "flow-decision", "flow-card", "plan-ready", "report-ready",
+    "stale-approval", "security-release", "secret-detected",
+]);
+export function needsPerson(row) {
+    if (row.recipient !== null)
+        return true;
+    if (/^decision:\d+$/.test(row.dedupeKey))
+        return true;
+    if (row.pushClass !== null && row.pushClass !== "progress")
+        return true;
+    if (NEEDED_KINDS.has(row.kind))
+        return true;
+    // A built or unchanged result is Ready: the one lifecycle step that asks for a person.
+    return isLifecycleNotification(row) && row.kind === "run-finished";
+}
+/** A fact about one placed task: in quiet mode it lands on that task's card. */
+export function isTaskFact(row) {
+    return row.taskRef !== null && row.taskId !== null && row.project !== null;
+}
+/** The attempt a task's card follows: its newest builder attempt, outside any contest. */
+function cardRun(store, taskRef) {
+    return store.runsFor(taskRef).find(run => run.role === "builder" && run.contestant === null) ?? null;
+}
+/** Before any attempt starts, the card says where the task stands in the words of its last lifecycle fact. */
+const BEFORE_RUN = {
+    "task-filed": { icon: "📝", status: "Filed" },
+    "scope-approved": { icon: "✓", status: "Approved · Waiting to start" },
+    "approval-withdrawn": { icon: "📝", status: "Approval withdrawn" },
+    "task-held": { icon: "⏸", status: "Paused" },
+    "task-released": { icon: "✓", status: "Waiting to start" },
+    "task-queued": { icon: "✓", status: "Waiting to start" },
+    "task-requeued": { icon: "✓", status: "Waiting to start" },
+    "task-cancelled": { icon: "⏹", status: "Cancelled" },
+};
+function taskLine(store, taskRef, now, root) {
+    const ref = store.refById(taskRef);
+    if (ref === null || ref.repo === null)
+        return null;
+    const task = store.getTask(ref.externalId);
+    const title = phoneText(task?.title ?? ref.externalId, 88);
+    const run = cardRun(store, taskRef);
+    if (run !== null) {
+        const view = telegramProgressCard(store, run, ref.externalId, ref.repo, now, root);
+        const heading = view.entities[1] === undefined ? "" : view.text.slice(view.entities[1].offset, view.entities[1].offset + view.entities[1].length);
+        const split = heading.indexOf(" ");
+        return { title, icon: heading.slice(0, split), status: heading.slice(split + 1), project: ref.repo, view };
+    }
+    const fact = store.latestTaskFact(taskRef);
+    const words = task?.state === "cancelled" ? BEFORE_RUN["task-cancelled"] : BEFORE_RUN[fact?.kind ?? ""] ?? BEFORE_RUN["task-filed"];
+    const heading = `${words.icon} ${words.status}`;
+    const text = [title, heading, "", `${projectLabel(ref.repo)} · ${ref.externalId}`].join("\n");
+    return { title, icon: words.icon, status: words.status, project: ref.repo, view: {
+            text, entities: [{ type: "bold", offset: 0, length: title.length }, { type: "bold", offset: title.length + 1, length: heading.length }],
+            link: { label: "Open task", path: chatControlHref("task", ref.externalId) },
+        } };
+}
+/** The card's words now: one task's progress card, or one line per task when several were filed together. */
+export function quietCardView(store, taskRefs, now, root) {
+    const lines = taskRefs.map(ref => taskLine(store, ref, now, root)).filter((one) => one !== null);
+    if (lines.length === 0)
+        return null;
+    if (lines.length === 1)
+        return lines[0].view;
+    const heading = `${lines.length} tasks`;
+    const projects = [...new Set(lines.map(one => projectLabel(one.project)))];
+    const text = [heading, ...lines.map(one => `${one.icon} ${phoneText(one.title, 60)} · ${one.status}`), "", projects.join(", ")].join("\n");
+    return { text, entities: [{ type: "bold", offset: 0, length: heading.length }], link: { label: "Open tasks", path: "/tasks" } };
+}
+/** The one ping for a Ready result: its state and title, what to do next, and a link to that exact result. */
+export function readyPingView(store, run, taskId, project, now, root) {
+    const card = telegramProgressCard(store, run, taskId, project, now, root);
+    const [title = "", shown = ""] = card.entities.map(one => card.text.slice(one.offset, one.offset + one.length));
+    // A saved result is Ready even in the moment before its worker lets go of the task.
+    const saved = shown.endsWith(" Result saved");
+    const heading = saved ? "✅ Ready" : shown;
+    const next = card.next !== "" ? card.next : saved ? "Next: open the result, then mark it complete or request changes." : "";
+    const first = `${heading} · ${title}`;
+    return { text: next === "" ? first : `${first}\n${next}`, entities: [{ type: "bold", offset: 0, length: heading.length }], link: card.link };
+}
+// ---- the evening digest ----------------------------------------------------------
+const FAILURE = /fail|exhausted|fenced/;
+const pad = (n) => String(n).padStart(2, "0");
+/** This computer's local day and time, which is what a person means by "the evening". */
+export function localDay(now) {
+    return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+}
+export function localTime(now) {
+    return `${pad(now.getHours())}:${pad(now.getMinutes())}`;
+}
+/** One person's evening: what finished and what failed in the last day, and what waits for them now. Null when
+ * nothing happened, so a quiet day sends nothing. */
+export function eveningDigestText(store, account, now, root) {
+    const since = new Date(now.getTime() - 86_400_000).toISOString();
+    const recent = new Date(now.getTime() - 14 * 86_400_000).toISOString();
+    const visible = (row) => row.project !== null && store.accountCanAccess(account, row.project);
+    const title = (taskId) => phoneText(store.getTask(taskId)?.title ?? taskId, 80);
+    const finished = new Map(), failed = new Map(), waits = new Map();
+    const facts = store.taskFactsSince(recent).filter(visible);
+    for (const row of facts) {
+        if (row.createdAt < since || row.taskId === null)
+            continue;
+        if (isLifecycleNotification(row) && row.kind === "run-finished")
+            finished.set(row.taskId, title(row.taskId));
+        else if (FAILURE.test(row.kind))
+            failed.set(row.taskId, title(row.taskId));
+    }
+    for (const taskId of new Set(facts.map(row => row.taskId).filter((one) => one !== null))) {
+        let state = null;
+        try {
+            const project = facts.find(row => row.taskId === taskId).project;
+            state = assignmentOf(store, taskId, now, { principal: "operator", repos: [project] }, root)?.state ?? null;
+        }
+        catch {
+            state = null;
+        }
+        if (state === "ready-to-check")
+            waits.set(taskId, `${title(taskId)} · Ready for review`);
+        else if (state === "needs-decision")
+            waits.set(taskId, `${title(taskId)} · Needs your decision`);
+    }
+    if (finished.size + failed.size + waits.size === 0)
+        return null;
+    const section = (name, items) => items.size === 0 ? [] : ["", `${name} (${items.size})`, ...[...items.values()].slice(0, 12).map(one => `• ${one}`), ...(items.size > 12 ? [`• and ${items.size - 12} more`] : [])];
+    return [...section("Finished", finished), ...section("Waiting for you", waits), ...section("Failed", failed)].slice(1).join("\n");
+}
+/** Record each due evening digest once per person per local day, as one notification addressed to that person:
+ * every chat they paired delivers it with the usual receipts, and the console keeps it. */
+export function enqueueEveningDigests(store, now, root) {
+    const day = localDay(now), time = localTime(now);
+    let queued = 0;
+    for (const person of store.eveningDigestPeople()) {
+        if (person.digestAt > time || (person.digestOn !== null && person.digestOn >= day))
+            continue;
+        store.transact(() => {
+            if (!store.claimEveningDigestDay(person.account, day))
+                return;
+            const body = eveningDigestText(store, person.account, now, root);
+            if (body === null)
+                return;
+            if (store.enqueueNotification({ dedupeKey: `digest:evening:${person.account}:${day}`, kind: "evening-digest", subject: "Evening digest", body,
+                link: "/tasks", source: { installation: true }, recipient: person.account }, now))
+                queued++;
+        });
+    }
+    return queued;
+}

package/dist/cli.d.ts

@@ -39,7 +39,7 @@ export type ParseResult = {
     error: string;
 };
 type Write = (line: string) => void;
-export declare const HELP = "toolroll \u2014 a control plane for unattended coding agents\n\nUsage\n  toolroll [path...]        report what is in flight\n  toolroll pulls            report what is waiting on a person\n  toolroll graph            report which work graph is already here\n  toolroll repos            list connected repositories, and how to adjust\n  toolroll repos add <path> connect one (no path: the repo you are in)\n  toolroll repos remove <path>\n  toolroll repos add-from-github <owner/name> --root <dir>\n                                   preview, then clone and connect (--yes)\n  toolroll link             put `toolroll` on your PATH\n  toolroll unlink           take it off again\n  toolroll update           update to the latest release: verified, drained, undoable\n                                   (preview first; --yes, --now, --at HH:MM, --rollback)\n  toolroll contract         the machine contract: envelope version + capabilities\n                                   (--commands dumps the declared command guide)\n  toolroll skills install --claude-code [--dir <path>]\n                                   install this binary's guides for Claude Code (preview first)\n  toolroll skills install   teach a repo's agents this queue exists (preview first)\n  toolroll skills list      the guides this exact binary serves\n  toolroll skills get <name>  print one guide (version-matched, never stale)\n  toolroll demo             a seeded throwaway sandbox \u2014 see it working in 90 seconds\n  toolroll up               app + builder for every saved project \u2014 the normal start\n  toolroll onboard          make your agent Toolroll's lead: add this repo, install its skill (--yes)\n  toolroll status           running, queued, ready results, release check and plan windows\n  toolroll session          native coding sessions through the running service\n  toolroll connect          save a private connection to your central service\n  toolroll lead             named leads on the connected service\n  toolroll conversation     shared and private conversations on that service\n  toolroll chat --lead <id> --conversation <id>  central chat (use --local for local chat)\n\nOperating the queue \u2014 `toolroll task` prints the whole surface,\nand any queue command + --help prints it too\n  toolroll approver add <name>\n                               mint the credential that lets a person say yes\n  toolroll ready            what could be dispatched right now\n  toolroll check-progress <run>  current or final approved check progress\n  toolroll task wait <id> [--timeout <seconds>]\n                               wait for this attempt to finish or need a person\n  toolroll task add <title> queue work\n  toolroll task scope <id> --goal <text>\n                               state what success is; approval binds to it\n  toolroll task approve <id>\n                               the yes \u2014 nothing builds without one\n  toolroll claim <id> --runner <name>\n  toolroll heartbeat <lease> / release <lease> / reap\n  toolroll tick --runner <name> --token <t> --repo <path>\n                               one unattended pass over the ready set\n  toolroll chat --as <you> --token <t>\n                               talk to the mate: one conversation across every\n                               project; it proposes, you confirm (--say \"\u2026\" for one turn)\n  toolroll serve --repo <path>  advanced: run only the console\n                               (--editor vscode with --runner: file links\n                               open in VS Code on the device you browse from)\n  toolroll watch / daemon install   advanced: run only the builder\n  toolroll reconcile        recover what the last stretch left behind\n\nWith nothing connected it reports everything it can find below the working\ndirectory. Once you connect repositories it reports those instead.\n\nOptions\n  --all         report everything discoverable, ignoring connected repos\n  --depth <n>   directory levels to descend (default: 6)\n  --hidden      include dot-directories, which are skipped by default\n  --dirty       also read each working tree for uncommitted files\n  --local       branches only: no network, no pull requests, no issues\n  --json        emit a machine-readable envelope instead of a report\n  -o <file>     also write that envelope to a file (requires --json)\n  -h, --help    show this\n\nNothing is written, installed, or configured. Every repository is read\nthrough git with --no-optional-locks, so a scan never contends for the\nindex lock with an editor you have open.\n\n--dirty is off by default because reading a working tree is unbounded\nwork: on a large or cloud-synced repo `git status` can take minutes,\nwhere listing branches takes milliseconds.\n\nlink shows what it would do and changes nothing; add --yes to apply it,\nor --to <dir> to choose where. It never uses sudo, never leaves your\nhome directory, and never touches a file it did not create.";
+export declare const HELP = "toolroll \u2014 a control plane for unattended coding agents\n\nUsage\n  toolroll [path...]        report what is in flight\n  toolroll pulls            report what is waiting on a person\n  toolroll graph            report which work graph is already here\n  toolroll repos            list connected repositories, and how to adjust\n  toolroll repos add <path> connect one (no path: the repo you are in)\n  toolroll repos remove <path>\n  toolroll repos add-from-github <owner/name> --root <dir>\n                                   preview, then clone and connect (--yes)\n  toolroll link             put `toolroll` on your PATH\n  toolroll unlink           take it off again\n  toolroll update           update to the latest release: verified, drained, undoable\n                                   (preview first; --yes, --now, --at HH:MM, --rollback)\n  toolroll contract         the machine contract: envelope version + capabilities\n                                   (--commands dumps the declared command guide)\n  toolroll skills install --claude-code [--dir <path>]\n                                   install this binary's guides for Claude Code (preview first)\n  toolroll skills install   teach a repo's agents this queue exists (preview first)\n  toolroll skills list      the guides this exact binary serves\n  toolroll skills get <name>  print one guide (version-matched, never stale)\n  toolroll demo             a seeded throwaway sandbox \u2014 see it working in 90 seconds\n  toolroll up               app + builder for every saved project \u2014 the normal start\n  toolroll onboard          make your agent Toolroll's lead: add this repo, install its skill (--yes), offer starter flows (--starter)\n  toolroll status           running, queued, ready results, release check and plan windows\n  toolroll integrations     which integrations work, and what to do about the ones that don't (--json)\n  toolroll session          native coding sessions through the running service\n  toolroll connect          save a private connection to your central service\n  toolroll lead             named leads on the connected service\n  toolroll conversation     shared and private conversations on that service\n  toolroll chat --lead <id> --conversation <id>  central chat (use --local for local chat)\n\nOperating the queue \u2014 `toolroll task` prints the whole surface,\nand any queue command + --help prints it too\n  toolroll approver add <name>\n                               mint the credential that lets a person say yes\n  toolroll ready            what could be dispatched right now\n  toolroll check-progress <run>  current or final approved check progress\n  toolroll task wait <id> [--timeout <seconds>]\n                               wait for this attempt to finish or need a person\n  toolroll task add <title> queue work\n  toolroll task scope <id> --goal <text>\n                               state what success is; approval binds to it\n  toolroll task approve <id>\n                               the yes \u2014 nothing builds without one\n  toolroll claim <id> --runner <name>\n  toolroll heartbeat <lease> / release <lease> / reap\n  toolroll tick --runner <name> --token <t> --repo <path>\n                               one unattended pass over the ready set\n  toolroll chat --as <you> --token <t>\n                               talk to the mate: one conversation across every\n                               project; it proposes, you confirm (--say \"\u2026\" for one turn)\n  toolroll serve --repo <path>  advanced: run only the console\n                               (--editor vscode with --runner: file links\n                               open in VS Code on the device you browse from)\n  toolroll watch / daemon install   advanced: run only the builder\n  toolroll reconcile        recover what the last stretch left behind\n\nWith nothing connected it reports everything it can find below the working\ndirectory. Once you connect repositories it reports those instead.\n\nOptions\n  --all         report everything discoverable, ignoring connected repos\n  --depth <n>   directory levels to descend (default: 6)\n  --hidden      include dot-directories, which are skipped by default\n  --dirty       also read each working tree for uncommitted files\n  --local       branches only: no network, no pull requests, no issues\n  --json        emit a machine-readable envelope instead of a report\n  -o <file>     also write that envelope to a file (requires --json)\n  -h, --help    show this\n\nNothing is written, installed, or configured. Every repository is read\nthrough git with --no-optional-locks, so a scan never contends for the\nindex lock with an editor you have open.\n\n--dirty is off by default because reading a working tree is unbounded\nwork: on a large or cloud-synced repo `git status` can take minutes,\nwhere listing branches takes milliseconds.\n\nlink shows what it would do and changes nothing; add --yes to apply it,\nor --to <dir> to choose where. It never uses sudo, never leaves your\nhome directory, and never touches a file it did not create.";
 export declare function parseArgs(argv: readonly string[]): ParseResult;
 /** The commands that operate the queue rather than report on the world. */
 /** Every verb the CLI routes OUTSIDE runOperate. Exported (with

package/dist/cli.js

@@ -59,8 +59,9 @@ Usage
   toolroll skills get <name>  print one guide (version-matched, never stale)
   toolroll demo             a seeded throwaway sandbox — see it working in 90 seconds
   toolroll up               app + builder for every saved project — the normal start
-  toolroll onboard          make your agent Toolroll's lead: add this repo, install its skill (--yes)
+  toolroll onboard          make your agent Toolroll's lead: add this repo, install its skill (--yes), offer starter flows (--starter)
   toolroll status           running, queued, ready results, release check and plan windows
+  toolroll integrations     which integrations work, and what to do about the ones that don't (--json)
   toolroll session          native coding sessions through the running service
   toolroll connect          save a private connection to your central service
   toolroll lead             named leads on the connected service
@@ -197,10 +198,12 @@ export const OPERATE_COMMANDS = new Set([
     "ledger",
     "storage",
     "monitoring",
+    "integrations",
     "check-progress",
     "spend",
     "budget",
     "retention",
+    "notifications",
     "backup",
     "restore",
     "export",

package/dist/desktop-update.d.ts

@@ -66,6 +66,7 @@ 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): {
+    version?: never;
     active: boolean;
     phase: string;
     detail: string;
@@ -79,7 +80,6 @@ export declare function desktopUpdateStatus(stateDir: string): {
     wasRunning?: never;
     backupPath?: never;
     updateId?: never;
-    version?: never;
     buildId?: never;
     workDir?: never;
 } | {

package/dist/digest-times.d.ts

@@ -0,0 +1,3 @@
+/** The evening digest choices Settings offers: off, or an evening hour — plus a time set from the command line,
+ * kept as chosen. Shared by the console page and its no-script fallback. */
+export declare function digestTimes(current: string | null): [string, string][];

package/dist/digest-times.js

@@ -0,0 +1,7 @@
+/** The evening digest choices Settings offers: off, or an evening hour — plus a time set from the command line,
+ * kept as chosen. Shared by the console page and its no-script fallback. */
+export function digestTimes(current) {
+    const hours = ["17:00", "18:00", "19:00", "20:00", "21:00", "22:00"];
+    const times = current === null || hours.includes(current) ? hours : [...hours, current].sort();
+    return [["off", "Off"], ...times.map(one => [one, `At ${one}`])];
+}

package/dist/dispose.js

@@ -132,6 +132,7 @@ function disposeBuildOutcomeLocked(context, result) {
                     const grant = store.publicationGrantFor(repo);
                     const headSha = store.getRun(runId)?.headRevision ?? null;
                     if (grant !== null &&
+                        grant.publishOn !== "complete" &&
                         headSha !== null &&
                         headWithin(branch, grant.headPrefix) &&
                         (grant.selector === "all" || origin === "ours")) {
@@ -203,6 +204,7 @@ function disposeBuildOutcomeLocked(context, result) {
                 const grant = store.publicationGrantFor(repo);
                 const headSha = store.getRun(runId)?.headRevision ?? null;
                 if (grant !== null &&
+                    grant.publishOn !== "complete" &&
                     headSha !== null &&
                     headWithin(branch, grant.headPrefix) &&
                     (grant.selector === "all" || origin === "ours")) {

package/dist/export.js

@@ -60,7 +60,7 @@ export function categoryOf(table) {
         [/^(run|artifact|claim|worktree$|execution_slot|contest|tournament_terms|fallback_cycle|fallback_transition|held_session|session_turn|attended_authorization|criterion_review|diff_comment|proof_|review_request|repair_chain|incident|publication$|merge_|side_spend|knowledge_snapshot|learning_snapshot|skill_snapshot)/, "runs"],
         [/^(task|hold$|plan_|scope_|tool_seal|decision|external_|skill_test)/, "tasks"],
         [/^(project|approval_policy|capability|verify_command|worktree_setup|backend_grant|intake_grant|publication_grant|operating_mode|knowledge_|learning_|memory_|skill_)/, "projects"],
-        [/(_config|_default|_defaults)$|^(budget|model_|provider_|installation_fact|runtime_check|monitoring_status|quota|mode_rail|schema_version)/, "settings"],
+        [/(_config|_default|_defaults)$|^(budget|model_|provider_|installation_fact|runtime_check|monitoring_status|integration_check|quota|mode_rail|schema_version)/, "settings"],
     ];
     return rules.find(([pattern]) => pattern.test(table))?.[1] ?? "other";
 }

package/dist/flow-engine.js

@@ -8,7 +8,7 @@
 import { assignmentOf } from "./assignment.js";
 import { filerFor } from "./approval-policy.js";
 import { diagnoseTaskDispatch } from "./dispatch.js";
-import { deciderOf, durationWords, fillFlowText, validateFlowDefinition } from "./flows.js";
+import { deciderOf, durationWords, fillFlowText, validateFlowDefinition, withinHours } from "./flows.js";
 import { reportSummaryFor } from "./report-summary.js";
 import { fileTaskProposal } from "./proposal.js";
 import { requestResultChanges } from "./result-actions.js";
@@ -138,6 +138,17 @@ function advanceCard(store, flow, definition, card, now, options, outcome) {
             return;
         case "wait": {
             const wait = stage.wait ?? { for: "reply", minutes: 24 * 60 };
+            // Set hours (like 22:00–06:00): a card goes on once the clock is inside them, at once when it already is.
+            if (wait.for === "hours") {
+                if (withinHours(wait, now)) {
+                    onward("ok");
+                    return;
+                }
+                const waiting = `Waiting until ${wait.from}.`;
+                if (card.waiting !== waiting)
+                    store.updateFlowCard(card.id, { waiting }, now);
+                return;
+            }
             const entered = Date.parse(store.flowCardEnteredAt(card.id) ?? card.updatedAt);
             const words = durationWords(wait.minutes);
             if (now.getTime() < entered + wait.minutes * 60_000) {
@@ -217,6 +228,7 @@ function advanceCard(store, flow, definition, card, now, options, outcome) {
             workStage(store, flow, stage, card, now, options, outcome, onward);
             return;
         case "check":
+        case "pull-request":
         case "update":
         case "sort":
         case "draft":

package/dist/flow-pull-request.d.ts

@@ -0,0 +1,11 @@
+import type { Runner } from "./backend.js";
+import type { FlowDefinition, FlowStage } from "./flows.js";
+import type { FlowCardRow, FlowRow, Store } from "./store.js";
+export type PullRequestIo = {
+    gh: Runner;
+    evidenceRoot?: string;
+};
+/** Whether a person approved this card at a "Person decides" zone since it was last built; their name when so. */
+export declare function approvedSinceBuild(store: Store, definition: FlowDefinition, card: FlowCardRow): string | null;
+/** One pass of a Pull request zone for one card. Returns whether it changed anything. */
+export declare function pullRequestStep(store: Store, flow: FlowRow, definition: FlowDefinition, stage: FlowStage, card: FlowCardRow, now: Date, io: PullRequestIo): Promise<boolean>;