toolroll 0.9.30 → 0.9.32

package/dist/builder.js

@@ -1,5 +1,7 @@
 import { OBSERVATION_MAILBOX, observationBrief, parseObservationCases, collectObservations } from "./observations.js";
 import { checkCommandFor, effectiveCheckLevel, recordRunCheckLevel } from "./check-levels.js";
+import { queueBatchCheck } from "./batch-checks.js";
+import { batchesFullCheck } from "./batch-policy.js";
 import { skillsContext } from "./project-skills.js";
 import { failedVerificationEvidence, sealVerificationReceipt, verificationEvidence, reuseObservationVerification } from "./verification-evidence.js";
 import { learningContext } from "./project-learning.js";
@@ -684,7 +686,7 @@ export async function build(store, request) {
             // copy links it instead of installing its own; a setup that is about to
             // run never reaches through an old link into a shared copy.
             const depsRoot = sharedDepsRootOf(store);
-            const sharing = depsRoot === null ? null : sharingFor({ repo: leased.repo, worktree, setup: setupWanted });
+            const sharing = depsRoot === null ? null : sharingFor({ repo: leased.repo, worktree, setup: setupWanted, root: depsRoot });
             if (depsRoot !== null)
                 detachShared(worktree, depsRoot);
             if (depsRoot !== null && sharing !== null) {
@@ -2175,6 +2177,11 @@ async function settleProof(captured, statArtifactId, sealedHead) {
     const configured = chosenCheck?.command ?? null;
     if (repo !== null && chosenCheck !== null)
         recordRunCheckLevel(store, { id: runId, taskId: request.taskId, repo }, chosenCheck.level, checkChoice.from, now());
+    // Batch checks (batch-checks.ts): with the project's batching on, a Full check waits to run once with
+    // other results on a temporary batch commit. The build seals no check of its own; the batch's sealed
+    // receipt is this result's check, and Merge waits for it.
+    const batched = repo !== null && chosenCheck !== null && batchesFullCheck(store, repo, chosenCheck.level, configured);
+    const gateCommand = batched ? null : configured;
     let verifyCommand;
     const checkLog = [];
     const checkOutcomes = [];
@@ -2210,6 +2217,10 @@ async function settleProof(captured, statArtifactId, sealedHead) {
     else if (configured === null) {
         verifyCommand = { configured: false };
     }
+    else if (batched && repo !== null) {
+        verifyCommand = { configured: false };
+        queueBatchCheck(store, { runId, taskId: request.taskId, repo, head: sealedHead, base: captured.baseRevision, command: configured }, now());
+    }
     else if (!store.proveRunnerCustodyForSpawn(runId, now())) {
         verifyCommand = { configured: true, ran: false, attemptFailed: true, failure: "custody-lost" };
         recordCheckNote("Verification did not start: this worker no longer owned the build.");
@@ -2258,7 +2269,7 @@ async function settleProof(captured, statArtifactId, sealedHead) {
             const live = linked === null ? null : store.liveWorktreeSetup(repo);
             if (linked === null || live === null)
                 return null;
-            if (sharingFor({ repo, worktree, setup: live })?.key === linked && readyCopy(depsRoot, linked) !== null)
+            if (sharingFor({ repo, worktree, setup: live, root: depsRoot })?.key === linked && readyCopy(depsRoot, linked) !== null)
                 return null;
             if (!store.proveRunnerCustodyForSpawn(runId, now()))
                 return "custody-lost";
@@ -2497,7 +2508,7 @@ async function settleProof(captured, statArtifactId, sealedHead) {
     }
     const { verdict, reasons, matrix, machineVerdict } = adjudicate({
         directAssessment: true,
-        ...(configured === null ? {} : { verificationCommand: configured.command }),
+        ...(gateCommand === null ? {} : { verificationCommand: gateCommand.command }),
         proofArtifactPresent,
         proofParse,
         handoffPresent: handoffArtifact !== null,

package/dist/chat-actions.js

@@ -5,7 +5,7 @@ import { TEXT_LIMITS } from "./text-limits.js";
 import { publicChatText } from "./chat-display.js";
 import { gateWords } from "./approval-policy.js";
 import { createHash, randomBytes } from "node:crypto";
-import { verifiedAuthor } from "./store.js";
+import { mateTurnKeepsProposals, verifiedAuthor } from "./store.js";
 import { isVerifiedApprover, reproveApprover, } from "./principal.js";
 import { changeSkills, importSkill, skillsView, skillsVersion, testSkill, validateSkill, } from "./project-skills.js";
 import { changeKnowledge, knowledgeVersion, knowledgeView, } from "./project-knowledge.js";
@@ -1025,7 +1025,7 @@ function savedActionContext(store, who, id, state) {
         session.ceilingDigest !== who.ceilingDigest ||
         proposal.ceilingDigest !== who.ceilingDigest ||
         (!shared && turn?.session !== session.id) ||
-        turn?.state !== "answered")
+        !mateTurnKeepsProposals(turn))
         throw Error("This conversation ended or its project access changed. Ask for a fresh proposal.");
     requireActor(store, who, payload.repo, payload.operation);
     return payload;

package/dist/check-levels-ui.d.ts

@@ -19,6 +19,10 @@ export type CheckSettingsView = {
         on: boolean;
         source: "project" | "hands-off" | "default";
     };
+    /** Batch checks (batch-checks.ts): off by default. */
+    batch?: {
+        on: boolean;
+    };
     said: string | null;
     problem: string | null;
 };

package/dist/check-levels-ui.js

@@ -3,6 +3,7 @@
  * one. Every change takes the password and lands in the ledger; approving a
  * command restates exactly what will run, unattended, before the yes. */
 import { CHECK_LEVELS, CHECK_LEVEL_HINTS, CHECK_LEVEL_WORDS } from "./check-levels.js";
+import { BATCH_HINT } from "./batch-policy.js";
 const escape = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 export function checkSettingsHtml(view) {
     const hidden = (act) => `<input type="hidden" name="csrf" value="${escape(view.csrf)}"><input type="hidden" name="repo" value="${escape(view.repo)}"><input type="hidden" name="act" value="${act}">`;
@@ -19,7 +20,7 @@ export function checkSettingsHtml(view) {
         (fallsBack ? `<p class="meta">No quick command yet, so builds run the full check.</p>` : "") +
         (view.level !== "full" && view.full !== null ? `<p class="meta">The full check still runs when a pull request opens, and Merge waits for it.</p>` : "");
     if (!view.canChange) {
-        return head + `<section class="card check-settings">${current}</section>` + reviewHtml(view, "") +
+        return head + `<section class="card check-settings">${current}</section>` + batchHtml(view, "") + reviewHtml(view, "") +
             `<section class="card check-settings"><h2>Quick check</h2>${view.quick === null ? `<p class="meta">None yet.</p>` : command(view.quick)}</section>` +
             `<section class="card check-settings"><h2>Full check</h2>${view.full === null ? `<p class="meta">None yet.</p>` : command(view.full)}</section>`;
     }
@@ -45,7 +46,25 @@ export function checkSettingsHtml(view) {
             `<p class="meta">Quick builds run the full check instead.</p>${password}<button type="submit" class="danger">Remove</button></form></details></section>`;
     const full = `<details class="settings-more"><summary>Full check</summary><section class="card check-settings">` +
         (view.full === null ? `<p class="meta">None yet. Approve one with <span class="mono">toolroll verify set --repo … --command "…"</span>.</p>` : command(view.full)) + `</section></details>`;
-    return head + levelForm + reviewHtml(view, password) + quick + full;
+    return head + levelForm + batchHtml(view, password) + reviewHtml(view, password) + quick + full;
+}
+/** Batch checks: one state and one sentence; turning it on restates exactly what happens, behind a disclosure with the password. */
+function batchHtml(view, password) {
+    const batch = view.batch;
+    if (batch === undefined)
+        return "";
+    const act = batch.on ? "Turn off" : "Turn on";
+    const terms = batch.on ? `<p class="meta">Each result runs its own full check again. Results already waiting are checked now.</p>`
+        : `<ul class="check-terms"><li>When results finish within 10 minutes of each other, they're merged in a temporary checkout and the full check runs once.</li>` +
+            `<li>If it fails, the batch is split until the result that breaks it is found. Results that conflict are checked on their own.</li>` +
+            `<li>Nothing is merged into a real branch. Each result still lands on its own.</li></ul>`;
+    const change = password === "" ? ""
+        : `<details class="settings-more"><summary>${act}</summary><form method="post" action="/settings/checks" class="check-settings">` +
+            `<input type="hidden" name="csrf" value="${escape(view.csrf)}"><input type="hidden" name="repo" value="${escape(view.repo)}"><input type="hidden" name="act" value="batch">` +
+            `<input type="hidden" name="on" value="${batch.on ? "0" : "1"}">${terms}${password}<button type="submit">${act}</button></form></details>`;
+    return `<section class="card check-settings" data-batch-checks="${batch.on ? "on" : "off"}"><h2>Batch checks</h2>` +
+        `<p><strong>${batch.on ? "On" : "Off"}</strong> · ${escape(BATCH_HINT)}</p>` +
+        (batch.on && view.level !== "full" ? `<p class="meta">Only Full checks are batched.</p>` : "") + `${change}</section>`;
 }
 /** Automatic review: one state, one sentence, and its one change behind a disclosure (the password). */
 function reviewHtml(view, password) {

package/dist/checkout-cleanup.d.ts

@@ -1,7 +1,7 @@
 import { type CheckoutCleanup } from "./storage.js";
 import type { Store, WorktreeRow } from "./store.js";
 import { type WorktreePool } from "./worktree.js";
-/** A release candidate's checkout holds the build a deploy installs: kept a week after its task was done. */
+/** A release candidate's checkout holds the build a deploy installs: the newest complete one waits at most a week for it. */
 export declare const CANDIDATE_KEEP_MS: number;
 /** The worker's pass removes at most this many; a clean-up by hand has no cap. */
 export declare const AUTO_MAX = 20;
@@ -43,6 +43,7 @@ type Status = {
 export type Deployed = {
     head: string | null;
     run: number | null;
+    at?: string | null;
 };
 export declare function deployedRelease(stateDir: string | null): Deployed | null;
 /**

package/dist/checkout-cleanup.js

@@ -7,9 +7,10 @@
  *
  * Always kept: a checkout in use, one whose task isn't finished (on hold, failed, a revision under way), a result
  * still waiting for review, a checkout with changes (files Toolroll wrote itself aside), and one with commits on no
- * branch. A release candidate's checkout (a deploy installs from it) is kept only while it is the newest gate for its
- * release (for a week after it was done) or the one deployed; a superseded or cancelled gate goes at once, whatever
- * its task's state (staged releases keep the rollback copy). A checkout no task names (adopted after a crash) goes only
+ * branch. A release check's checkout (a deploy installs from it) goes once its task is complete, with its dependency
+ * install and journey output, except the one deployed now and the project's newest complete one still waiting for its
+ * deploy (no deploy since it was complete; at most a week). A superseded or cancelled gate goes at once, whatever its
+ * task's state (staged releases keep the rollback copy). A checkout no task names (adopted after a crash) goes only
  * in a clean-up by hand. Every removal is in the ledger.
  *
  * A kept checkout waiting for review or with changes drops its dependencies and build output once its run ends
@@ -23,7 +24,7 @@ import { COMPLETION_ACTION } from "./result-completion.js";
 import { CLEANUP_CHOICES, bytesWords, diskBytes } from "./storage.js";
 import { worktreePath } from "./worktree.js";
 const DAY_MS = 86_400_000;
-/** A release candidate's checkout holds the build a deploy installs: kept a week after its task was done. */
+/** A release candidate's checkout holds the build a deploy installs: the newest complete one waits at most a week for it. */
 export const CANDIDATE_KEEP_MS = 7 * DAY_MS;
 /** The worker's pass removes at most this many; a clean-up by hand has no cap. */
 export const AUTO_MAX = 20;
@@ -56,7 +57,7 @@ export function deployedRelease(stateDir) {
             continue;
         newest = { at, head: typeof journal["candidate"] === "string" ? journal["candidate"] : null, run: Number.isSafeInteger(journal["builder"]) ? Number(journal["builder"]) : null };
     }
-    return newest === null ? null : { head: newest.head, run: newest.run };
+    return newest === null ? null : { head: newest.head, run: newest.run, at: newest.at === "" ? null : newest.at };
 }
 /** The folder beside the database (where staged releases live), or null for a database in memory. */
 function stateDirOf(store) {
@@ -117,6 +118,19 @@ export function taskStatuses(store, now, deployed) {
         if (ref !== undefined && (completedRef.get(ref) ?? "") < at)
             completedRef.set(ref, at);
     }
+    const completedAtOf = (row) => [completed.get(String(row["id"])), completedRef.get(Number(row["ref"]))].filter((one) => one !== undefined).sort().at(-1) ?? null;
+    // Per project, the newest complete gate (by when it was complete): the one a deploy may still be about to install.
+    // Once the project deployed after it was complete, it waits for nothing.
+    const deployedRepo = deployedRef === undefined ? (live?.head == null ? undefined : gates.find(row => String(row["candidate"]) === live.head)?.["repo"]) : refs.find(row => Number(row["ref"]) === deployedRef)?.["repo"];
+    const newestDone = new Map();
+    for (const row of gates) {
+        if (row["state"] !== "done")
+            continue;
+        const at = completedAtOf(row) ?? (row["updated_at"] === null ? "" : String(row["updated_at"]));
+        const seen = newestDone.get(String(row["repo"]));
+        if (seen === undefined || at > seen.at || (at === seen.at && Number(row["ref"]) > seen.ref))
+            newestDone.set(String(row["repo"]), { ref: Number(row["ref"]), at });
+    }
     const byRef = new Map();
     const byId = new Map();
     const parentOf = new Map();
@@ -139,11 +153,13 @@ export function taskStatuses(store, now, deployed) {
         else if (state === "cancelled")
             status = { keep: null, taskId: id, finishedAt: updated };
         else {
-            const completedAt = [completed.get(id), completedRef.get(ref)].filter((one) => one !== undefined).sort().at(-1) ?? null;
+            const completedAt = completedAtOf(row);
             if (gate) {
                 const since = completedAt ?? updated ?? now.toISOString();
                 const until = new Date(Date.parse(since) + CANDIDATE_KEEP_MS).toISOString();
-                status = until > now.toISOString() ? { keep: "release candidate", taskId: id, finishedAt: since, dueAt: until } : { keep: null, taskId: id, finishedAt: since };
+                const deployedSince = live?.at != null && deployedRepo !== undefined && String(row["repo"]) === String(deployedRepo) && live.at >= since;
+                const waiting = newestDone.get(String(row["repo"]))?.ref === ref && !deployedSince && until > now.toISOString();
+                status = waiting ? { keep: "release candidate", taskId: id, finishedAt: since, dueAt: until } : { keep: null, taskId: id, finishedAt: since, atOnce: true };
             }
             else
                 status = completedAt === null ? { keep: "waiting for review", taskId: id, finishedAt: null } : { keep: null, taskId: id, finishedAt: completedAt };
@@ -353,7 +369,7 @@ export function whyWords(item) {
         case "in use": return "in use";
         case "task not finished": return "its task isn't finished";
         case "waiting for review": return "its result is waiting for review";
-        case "release candidate": return item.dueAt === undefined ? "the deployed release candidate" : `newest release candidate, kept until ${item.dueAt.slice(0, 10)}`;
+        case "release candidate": return item.dueAt === undefined ? "the deployed release candidate" : `newest release candidate, kept for its deploy until ${item.dueAt.slice(0, 10)}`;
         case "has changes": return "has changes";
         case "has commits": return "has commits on no branch";
         case "unreadable": return "git couldn't read it";

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/exec.d.ts

@@ -56,6 +56,8 @@ export type RunOptions = ProcessTreeObserver & {
      * timeoutMs there is deliberately no absolute wall-clock ceiling.
      */
     idleTimeoutMs?: number;
+    /** Ends a process-group run early, exactly as its timeout does: the whole group is killed and the result reads timed out. */
+    signal?: AbortSignal;
     maxBuffer?: number;
     /**
      * Extra environment, merged over the process's own. A capability probe is a

package/dist/exec.js

@@ -526,6 +526,7 @@ export function run(file, args, options = {}) {
         return retryTransientSpawn(() => runBufferedGroup(file, args, {
             timeoutMs,
             maxBuffer,
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
             ...(options.stdin === undefined ? {} : { stdin: options.stdin }),
             ...(cwd === undefined ? {} : { cwd }),
             ...(childEnv === undefined ? {} : { childEnv }),
@@ -610,6 +611,15 @@ function runBufferedGroup(file, args, bag) {
             timedOut = true;
             killGroup(child);
         }, bag.timeoutMs);
+        // The caller's deadline, when it owns one: the same group kill as the timer.
+        const aborted = () => {
+            timedOut = true;
+            killGroup(child);
+        };
+        if (bag.signal?.aborted === true)
+            aborted();
+        else
+            bag.signal?.addEventListener("abort", aborted, { once: true });
         child.stdout?.setEncoding("utf8");
         child.stdout?.on("data", (chunk) => {
             stdout += chunk;
@@ -638,6 +648,7 @@ function runBufferedGroup(file, args, bag) {
                 return;
             settled = true;
             clearTimeout(timer);
+            bag.signal?.removeEventListener("abort", aborted);
             liveProviders.delete(child);
             // The OS object is settled BEFORE the answer: a root that exited is
             // not an empty container until the OS says so.

package/dist/flow-gallery-ui.d.ts

@@ -1,17 +1,19 @@
-/**
- * The flow gallery in the console (Flows → New and Settings → Flows): cards grouped by what they're for, each with
- * its promise, a small drawing of its zones, what it needs and "Use this". A template's page asks only what it
- * needs, previews in plain words what it will do and never do, and creates it — the same answers it previewed.
- */
-import { type GalleryAnswers, type GalleryPreview, type GalleryTemplate } from "./flow-gallery.js";
-import { type FlowDefinition } from "./flows.js";
+import { type GalleryAnswers, type GalleryPreview, type GalleryTemplate, type GalleryTool } from "./flow-gallery.js";
+import { type FlowDefinition, type FlowStage } from "./flows.js";
 export declare const GALLERY_CSS: string;
-/** A small drawing of a flow's zones where they sit on its canvas, with its paths; a person's decisions stand out. */
-export declare function zonesDiagram(definition: FlowDefinition, label: string): string;
+/** A flow's main path, as a person reads it: from the start, each step's first way on (a sort's first answer, a choose's
+ * first option that goes somewhere, else next; a check's failure when passing just ends), never back to a step shown. */
+export declare function mainPath(definition: FlowDefinition): FlowStage[];
+/** A flow's steps in order, joined by arrows; a person's decisions carry the accent. */
+export declare function stepStrip(definition: FlowDefinition): string;
 /** The gallery: every template, grouped, each with one "Use this". `repo` carries a chosen project to the template's page. */
 export declare function galleryHtml(input: {
     repo: string | null;
     canUse: boolean;
+    connections?: readonly {
+        id: string;
+        state: "connected" | "open" | "taken";
+    }[] | null;
 }): string;
 /** A template's page: its questions, then what it will do and never do, then Create. */
 export declare function galleryUseHtml(input: {
@@ -27,4 +29,7 @@ export declare function galleryUseHtml(input: {
     problem: string | null;
     csrf: string;
     diagram: FlowDefinition | null;
+    /** The template's tools in this project; `said` is how the last Connect went. */
+    tools?: readonly GalleryTool[];
+    said?: string | null;
 }): string;

package/dist/flow-gallery-ui.js

@@ -1,22 +1,30 @@
 /**
  * The flow gallery in the console (Flows → New and Settings → Flows): cards grouped by what they're for, each with
- * its promise, a small drawing of its zones, what it needs and "Use this". A template's page asks only what it
+ * its promise, its steps in order, what it needs and "Use this". A template's page asks only what it
  * needs, previews in plain words what it will do and never do, and creates it — the same answers it previewed.
+ * A template's tools show their marks and whether the project has them; one it lacks offers Connect first.
  */
-import { BLANK, GALLERY, GALLERY_GROUPS, galleryDiagram, OUTDATED_COMMANDS, SEND_RESULT } from "./flow-gallery.js";
+import { brandMarkHtml } from "./brand-mark.js";
+import { BLANK, GALLERY, GALLERY_GROUPS, galleryDiagram, galleryToolsOf, OUTDATED_COMMANDS, SEND_RESULT, sendsAlready } from "./flow-gallery.js";
 import { choiceTargets } from "./flows.js";
 const e = (value) => String(value ?? "").replace(/[&<>"']/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
 export const GALLERY_CSS = `.gallery{max-width:1120px;min-width:0}.gallery h2{margin:28px 0 10px;font-size:.9375rem}.gallery h2:first-of-type{margin-top:8px}` +
     `.gallery-grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(250px,1fr));gap:12px}` +
     `.gallery-card{display:flex;flex-direction:column;gap:8px;padding:16px;border:1px solid var(--so-line);border-radius:10px;background:var(--so-paper);min-width:0}` +
     `.gallery-card h3{margin:0;font-size:.9375rem}.gallery-card p{margin:0;overflow-wrap:anywhere}.gallery-card .gallery-promise{line-height:1.5;flex:1}` +
-    `.gallery-zones{display:block;width:100%;height:56px;border-radius:8px;background:var(--so-raised)}.gallery-zones rect{fill:var(--so-paper);stroke:var(--so-input-line);stroke-width:1.5}` +
-    `.gallery-zones rect[data-person="true"]{fill:var(--so-signal-soft,var(--so-raised));stroke:var(--so-ink)}.gallery-zones line{stroke:var(--so-input-line);stroke-width:1.5}` +
+    // A template's steps in order, joined by arrows; a person's own steps carry the attention chip.
+    `.gallery-steps{display:flex;flex-wrap:wrap;align-items:center;gap:4px 6px;list-style:none;padding:0;margin:0;font-size:12px;font-weight:500;line-height:1.5;color:var(--so-ink)}` +
+    `.gallery-steps li{display:inline-flex;align-items:center;gap:6px;min-width:0;overflow-wrap:anywhere}.gallery-steps li>span[aria-hidden]{color:var(--so-muted)}` +
+    `.gallery-steps b{font-weight:500;font-size:11.5px;line-height:18px;padding:1px 6px;border-radius:5px;background:var(--so-signal-soft);color:var(--so-signal)}` +
     `.gallery-needs{display:flex;flex-wrap:wrap;gap:4px;list-style:none;padding:0;margin:0}.gallery-needs li{font-size:11.5px;font-weight:500;line-height:18px;padding:1px 6px;border-radius:5px;background:var(--so-neutral-soft,var(--so-raised));color:var(--so-neutral-ink,var(--so-muted))}` +
     // An outline action in a list (the Quiet List Rule), over the workspace's ink default for .button-link.
     `.gallery .gallery-card a.button-link{align-self:flex-start;min-height:36px;background:var(--so-paper);color:var(--so-ink);border:1px solid var(--so-input-line)}` +
     `.gallery-blank{margin-top:20px}` +
-    `.gallery-use{max-width:720px;min-width:0}.gallery-use .gallery-zones{height:88px;margin:4px 0 12px}.gallery-use form{display:grid;gap:12px;margin:0}.gallery-use label{display:grid;gap:4px;font-weight:500}` +
+    // A template's tools: the mark Settings → Integrations shows, its name and where the project stands.
+    `.gallery-tools{display:grid;gap:6px;list-style:none;padding:0;margin:0}.gallery-tools li{display:flex;align-items:center;gap:8px;min-width:0;flex-wrap:wrap}.gallery-tools li>span:not(.brand-mark){min-width:0;overflow-wrap:anywhere}` +
+    `.gallery-tools strong{font-weight:500;overflow-wrap:anywhere}.gallery-connect{display:grid;gap:10px;padding:12px 0;border-top:1px solid var(--so-line)}.gallery-connect:last-child{border-bottom:1px solid var(--so-line);margin-bottom:4px}` +
+    `.gallery-connect form{display:grid;gap:8px;margin:0}.gallery-connect p{margin:0;overflow-wrap:anywhere}.gallery-connect .gallery-tool-head{display:flex;align-items:center;gap:8px;flex-wrap:wrap}.gallery-connect button{justify-self:start;min-height:36px;white-space:nowrap;background:var(--primary);color:var(--primary-foreground);border-color:var(--primary);font-weight:600}` +
+    `.gallery-use{max-width:720px;min-width:0}.gallery-use .gallery-steps{margin:4px 0 12px}.gallery-use form{display:grid;gap:12px;margin:0}.gallery-use label{display:grid;gap:4px;font-weight:500}` +
     `.gallery-use label small{font-weight:400;color:var(--so-muted)}.gallery-use label.gallery-check{display:flex;align-items:flex-start;gap:8px;font-weight:500}.gallery-use label.gallery-check input{margin-top:3px;width:16px;height:16px;min-height:0;flex:none}.gallery-use label.gallery-check small{display:block}` +
     `.gallery-use input:not([type=hidden]),.gallery-use select{box-sizing:border-box;width:100%;max-width:100%;min-height:32px;padding:0 10px;border:1px solid var(--so-input-line);border-radius:8px;background:var(--so-paper);color:var(--so-ink);font:inherit}` +
     `.gallery-preview{display:grid;gap:8px;padding:16px;border:1px solid var(--so-line);border-radius:10px;background:var(--so-paper);min-width:0}.gallery-preview h2{margin:0;font-size:.9375rem}` +
@@ -24,33 +32,47 @@ export const GALLERY_CSS = `.gallery{max-width:1120px;min-width:0}.gallery h2{ma
     `.gallery-preview details ol{margin:6px 0 0;padding-left:20px;white-space:pre-line;font-size:.875rem;line-height:1.5;color:var(--so-muted)}.gallery-preview details li{margin:0 0 6px;overflow-wrap:anywhere}` +
     `.gallery-preview summary{cursor:pointer;min-height:36px;display:flex;align-items:center;font-weight:500}` +
     `.gallery-actions{display:flex;flex-wrap:wrap;gap:8px;margin:0}.gallery-actions button{min-height:36px;white-space:nowrap}` +
-    `.gallery-use .gallery-actions button[value=create]{background:var(--primary);color:var(--primary-foreground);border-color:var(--primary);font-weight:600}.gallery-heading{margin:36px 0 0;font-size:1.05rem}` +
-    `@media(max-width:760px){.gallery-grid{grid-template-columns:minmax(0,1fr)}.gallery .gallery-card a.button-link{min-height:44px;align-self:stretch;justify-content:center}` +
+    `.gallery-use .gallery-actions button[value=create]:not(.secondary){background:var(--primary);color:var(--primary-foreground);border-color:var(--primary);font-weight:600}.gallery-heading{margin:36px 0 0;font-size:1.05rem}` +
+    `@media(max-width:760px){.gallery-grid{grid-template-columns:minmax(0,1fr)}.gallery-connect button{min-height:44px;justify-self:stretch}.gallery .gallery-card a.button-link{min-height:44px;align-self:stretch;justify-content:center}` +
     `.gallery-use input:not([type=hidden]),.gallery-use select{font-size:16px;min-height:44px}.gallery-actions button{flex:1 1 auto;min-height:44px}}`;
-/** A small drawing of a flow's zones where they sit on its canvas, with its paths; a person's decisions stand out. */
-export function zonesDiagram(definition, label) {
-    const zones = definition.stages.map(one => one.zone);
-    const minX = Math.min(...zones.map(one => one.x)), minY = Math.min(...zones.map(one => one.y));
-    const maxX = Math.max(...zones.map(one => one.x + one.w)), maxY = Math.max(...zones.map(one => one.y + one.h));
-    const pad = 40;
-    const box = `${minX - pad} ${minY - pad} ${maxX - minX + pad * 2} ${maxY - minY + pad * 2}`;
-    const centre = (id) => { const at = definition.stages.find(one => one.id === id)?.zone; return at === undefined ? null : { x: at.x + at.w / 2, y: at.y + at.h / 2 }; };
-    const lines = definition.stages.flatMap(stage => [stage.next, ...(stage.sort?.answers.map(one => one.to) ?? []), ...(stage.routes?.map(one => one.to) ?? []), ...choiceTargets(stage)].map(to => {
-        const from = centre(stage.id), end = centre(to);
-        return from === null || end === null ? "" : `<line x1="${from.x}" y1="${from.y}" x2="${end.x}" y2="${end.y}" vector-effect="non-scaling-stroke"/>`;
-    })).join("");
-    const rects = definition.stages.map(one => `<rect x="${one.zone.x}" y="${one.zone.y}" width="${one.zone.w}" height="${one.zone.h}" rx="36" data-person="${one.kind === "approval" || one.kind === "choose"}" vector-effect="non-scaling-stroke"/>`).join("");
-    return `<svg class="gallery-zones" viewBox="${box}" preserveAspectRatio="xMidYMid meet" role="img" aria-label="${e(label)}">${lines}${rects}</svg>`;
+/** A flow's main path, as a person reads it: from the start, each step's first way on (a sort's first answer, a choose's
+ * first option that goes somewhere, else next; a check's failure when passing just ends), never back to a step shown. */
+export function mainPath(definition) {
+    const byId = new Map(definition.stages.map(one => [one.id, one]));
+    const path = [];
+    for (let at = byId.get(definition.start); at !== undefined && at.kind !== "done" && !path.includes(at);) {
+        path.push(at);
+        const ways = [...(at.sort?.answers.map(one => one.to) ?? []), ...choiceTargets(at), at.next, ...(at.routes?.map(one => one.to) ?? [])].map(id => id === null ? undefined : byId.get(id));
+        if (at.kind === "check")
+            ways.push(at.onFail === null ? undefined : byId.get(at.onFail));
+        at = at.kind === "check" ? ways.find(one => one !== undefined && one.kind !== "done") : ways.find(one => one !== undefined);
+    }
+    return path;
 }
-const needsList = (template) => template.needs.length === 0 ? `<ul class="gallery-needs"><li>Nothing to connect</li></ul>`
+/** A step's short name in the strip: a person's own steps from their side. */
+const stepName = (stage) => stage.kind === "choose" ? "You choose" : stage.kind === "approval" ? "You approve" : stage.kind === "send" ? "Sent to you" : stage.title;
+/** A flow's steps in order, joined by arrows; a person's decisions carry the accent. */
+export function stepStrip(definition) {
+    return `<ol class="gallery-steps" aria-label="Steps">${mainPath(definition).map((one, i) => {
+        const name = e(stepName(one));
+        return `<li>${i === 0 ? "" : `<span aria-hidden="true">→</span>`}${one.kind === "choose" || one.kind === "approval" ? `<b data-person>${name}</b>` : name}</li>`;
+    }).join("")}</ol>`;
+}
+const needsList = (template) => template.needs.length === 0 ? (template.tools ?? []).length > 0 ? "" : `<ul class="gallery-needs"><li>Nothing to connect</li></ul>`
     : `<ul class="gallery-needs" aria-label="Needs">${template.needs.map(one => `<li>${e(one)}</li>`).join("")}</ul>`;
+/** A tool's state in words, as Settings → Integrations badges it; nothing without a project. */
+const STATE = { connected: ["connected", "Connected"], open: ["not-set-up", "Not connected"], taken: ["not-set-up", "Added another way"] };
+const toolState = (tool) => tool.state === null ? "" : `<span class="integration-state integration-state--${STATE[tool.state][0]}"><i aria-hidden="true"></i>${STATE[tool.state][1]}</span>`;
+const toolMark = (tool) => brandMarkHtml(tool.id.replace(/-desktop$/, ""), tool.label, tool.state === "connected");
+const toolsList = (tools) => tools.length === 0 ? ""
+    : `<ul class="gallery-tools" aria-label="Tools">${tools.map(one => `<li data-tool="${e(one.id)}" data-state="${one.state ?? "unknown"}">${toolMark(one)}<strong>${e(one.label)}</strong>${toolState(one)}</li>`).join("")}</ul>`;
 /** The gallery: every template, grouped, each with one "Use this". `repo` carries a chosen project to the template's page. */
 export function galleryHtml(input) {
     const href = (id) => `/flows/new/${id}${input.repo === null ? "" : `?repo=${encodeURIComponent(input.repo)}`}`;
     const card = (template) => {
         const definition = galleryDiagram(template);
         return `<article class="gallery-card" data-template="${e(template.id)}"><h3>${e(template.name)}</h3><p class="gallery-promise">${e(template.promise)}</p>` +
-            zonesDiagram(definition, `Zones: ${definition.stages.map(one => one.title).join(", ")}`) + needsList(template) +
+            stepStrip(definition) + toolsList(galleryToolsOf(template, definition, input.repo === null ? null : input.connections ?? null)) + needsList(template) +
             (input.canUse ? `<a class="button-link" href="${e(href(template.id))}" aria-label="Use ${e(template.name)}">Use this</a>` : "") + `</article>`;
     };
     const groups = GALLERY_GROUPS.map(group => `<h2 id="gallery-${group.id}">${e(group.label)}</h2><div class="gallery-grid" data-group="${group.id}">${GALLERY.filter(one => one.group === group.id).map(card).join("")}</div>`).join("");
@@ -59,28 +81,48 @@ export function galleryHtml(input) {
 /** A template's page: its questions, then what it will do and never do, then Create. */
 export function galleryUseHtml(input) {
     const { template } = input;
+    const tools = input.tools ?? input.preview?.tools ?? [];
+    // A tool added another way is there: only one the project lacks is missing.
+    const missing = tools.filter(one => one.state !== "connected" && one.state !== "taken");
+    // Each tool with its state; one the project lacks offers its own Connect (the Tools page's, with the same password), and comes back here.
+    const connect = (tool) => {
+        const head = `<p class="gallery-tool-head">${toolMark(tool)} <strong>${e(tool.label)}</strong> ${toolState(tool)}</p>`;
+        // Added another way, it is there: nothing to connect.
+        if (tool.state === "connected" || tool.state === "taken" || input.csrf === "")
+            return `<div class="gallery-connect" data-tool="${e(tool.id)}" data-state="${tool.state}">${head}</div>`;
+        const how = tool.id === "figma-desktop" ? "Open the Figma desktop app and turn on its Dev Mode MCP server in Preferences." : `You sign in on ${tool.label}, then come back here.`;
+        return `<div class="gallery-connect" data-tool="${e(tool.id)}" data-state="open">${head}<form method="post" action="/settings/tools/connect">` +
+            `<input type="hidden" name="csrf" value="${e(input.csrf)}"><input type="hidden" name="repo" value="${e(input.repo)}"><input type="hidden" name="shown" value="${e(input.repo)}"><input type="hidden" name="template" value="${e(template.id)}">` +
+            `<p class="meta">${e(how)}</p><label>Your Toolroll password<input type="password" name="password" autocomplete="current-password" required></label>` +
+            `<button name="service" value="${e(tool.id)}">Connect ${e(tool.label)}</button></form></div>`;
+    };
+    const toolsBlock = tools.length === 0 ? "" : `<section class="gallery-tools-use" aria-label="Tools">${tools.map(connect).join("")}</section>`;
+    // Made without a tool, the preview names the zone that needs it.
+    const zones = (tool) => tool.zones.map(zone => `“${e(zone)}”`).join(" and ");
+    const needing = missing.filter(one => one.zones.length > 0).map(one => `<p class="meta" data-needs-tool="${e(one.id)}">${zones(one)} need${one.zones.length === 1 ? "s" : ""} ${e(one.label)}, which isn't connected.</p>`).join("") +
+        tools.filter(one => one.state === "taken" && one.zones.length > 0).map(one => `<p class="meta" data-tool-taken="${e(one.id)}">${zones(one)} use${one.zones.length === 1 ? "s" : ""} ${e(one.label)}, added another way.</p>`).join("");
     const field = (ask) => {
         const value = input.answers[ask.key] ?? ask.default;
         const hint = ask.hint === undefined ? "" : ` <small>${e(ask.hint)}</small>`;
         if (ask.key === "outdated")
             return `<label>${e(ask.label)}<select name="outdated">${Object.entries(OUTDATED_COMMANDS).map(([id, one]) => `<option value="${id}"${id === value ? " selected" : ""}>${e(one.label)}</option>`).join("")}</select></label>`;
-        return `<label>${e(ask.label)}${hint}<input name="${ask.key}" value="${e(value)}" required maxlength="${ask.key === "command" ? 500 : 100}"${ask.key === "command" ? ' spellcheck="false" autocapitalize="off"' : ""}></label>`;
+        return `<label>${e(ask.label)}${hint}<input name="${ask.key}" value="${e(value)}" required maxlength="${ask.key === "command" ? 500 : ask.key === "team" ? 12 : 100}"${ask.key === "command" ? ' spellcheck="false" autocapitalize="off"' : ask.key === "team" ? ' spellcheck="false" autocapitalize="characters"' : ""}></label>`;
     };
     const project = input.projects.length > 1
         ? `<label>Project<select name="repo">${input.projects.map(one => `<option value="${e(one.path)}"${one.path === input.repo ? " selected" : ""}>${e(one.name)}</option>`).join("")}</select></label>`
         : `<input type="hidden" name="repo" value="${e(input.repo)}">`;
     const preview = input.preview === null ? "" : `<section class="gallery-preview" aria-labelledby="gallery-will">` +
         `<h2 id="gallery-will">What it will do</h2><ul>${input.preview.built.does.map(one => `<li>${e(one)}</li>`).join("")}</ul>` +
-        `<p class="gallery-never">${e(input.preview.built.never)}</p>` +
+        `<p class="gallery-never">${e(input.preview.built.never)}</p>${needing}` +
         (input.preview.startsFrom.length === 0 ? `<p class="meta">Cards start when you add them.</p>` : input.preview.startsFrom.map(one => `<p class="meta">Starts from: ${e(one)}</p>`).join("")) +
         `<details><summary>Every step</summary><ol>${input.preview.steps.map(one => `<li>${e(one.replace(/^\d+\.\s/, ""))}</li>`).join("")}</ol></details></section>`;
     return `<section class="gallery-use" data-gallery-template="${e(template.id)}">` +
-        (input.problem === null ? "" : `<p class="problem" role="alert">${e(input.problem)}</p>`) +
-        `<p>${e(template.promise)}</p>${input.diagram === null ? "" : zonesDiagram(input.diagram, `Zones: ${input.diagram.stages.map(one => one.title).join(", ")}`)}${needsList(template)}` +
+        (input.problem === null ? "" : `<p class="problem" role="alert">${e(input.problem)}</p>`) + (input.said ? `<p role="status">${e(input.said)}</p>` : "") +
+        `<p>${e(template.promise)}</p>${input.diagram === null ? "" : stepStrip(input.diagram)}${needsList(template)}${toolsBlock}` +
         `<form method="post" action="/flows/new/${e(template.id)}" data-gallery-use><input type="hidden" name="csrf" value="${e(input.csrf)}">` +
         `<input type="hidden" name="previewed" value="${e(input.preview?.digest ?? "")}">${project}${template.asks.map(field).join("")}` +
         `<label>Name<input name="name" value="${e(input.name)}" maxlength="80"></label>` +
-        `<label class="gallery-check"><input type="checkbox" name="${SEND_RESULT.key}" value="yes"${input.answers[SEND_RESULT.key] === "yes" ? " checked" : ""} data-send-result><span>${e(SEND_RESULT.title)}<small>When a card finishes, what was done comes to you in your chat apps.</small></span></label>${preview}` +
-        `<p class="gallery-actions">${input.preview === null ? "" : `<button type="submit" name="intent" value="create">Create flow</button>`}<button type="submit" name="intent" value="preview" class="secondary">${input.preview === null ? "Preview" : "Update preview"}</button></p>` +
+        (sendsAlready(template) ? "" : `<label class="gallery-check"><input type="checkbox" name="${SEND_RESULT.key}" value="yes"${input.answers[SEND_RESULT.key] === "yes" ? " checked" : ""} data-send-result><span>${e(SEND_RESULT.title)}<small>When a card finishes, what was done comes to you in your chat apps.</small></span></label>`) + preview +
+        `<p class="gallery-actions">${input.preview === null ? "" : `<button type="submit" name="intent" value="create"${missing.length > 0 ? ' class="secondary" data-without-tools' : ""}>Create flow</button>`}<button type="submit" name="intent" value="preview" class="secondary">${input.preview === null ? "Preview" : "Update preview"}</button></p>` +
         `</form><p class="meta"><a href="/flows/new">All templates</a></p></section>`;
 }

package/dist/flow-gallery.d.ts

@@ -15,7 +15,7 @@ export declare const GALLERY_GROUPS: readonly [{
 }];
 export type GalleryGroup = (typeof GALLERY_GROUPS)[number]["id"];
 /** What a template may ask, besides the project. */
-export type AskKey = "label" | "branch" | "schedule" | "time" | "command" | "outdated";
+export type AskKey = "label" | "branch" | "schedule" | "time" | "command" | "outdated" | "team";
 export type GalleryAsk = {
     key: AskKey;
     default: string;
@@ -36,6 +36,8 @@ export type GalleryTemplate = {
     promise: string;
     /** What it needs to work, in a word or two each. */
     needs: string[];
+    /** The project tools it puts to work: one-click service ids (ONE_CLICK) or "figma-desktop". */
+    tools?: readonly string[];
     /** Watches a GitHub repository, so the project must be on GitHub. */
     github?: boolean;
     asks: GalleryAsk[];
@@ -55,10 +57,28 @@ export type GalleryTemplate = {
     does: string[];
     never: string;
 };
+/** The card's Linear issue key, read from its source as the Linear trigger stored it ("Linear ENG-123"); "none" skips the comment. */
+export declare const LINEAR_KEY = "key=\"$(sed -n 's/.*\"source\":{\"kind\":\"linear\",\"label\":\"Linear \\([A-Z][A-Z0-9]*-[0-9][0-9]*\\)\".*/\\1/p' | head -n 1)\"\nif [ -n \"$key\" ]; then echo \"$key\"; echo \"goto: Found\"; else echo none; echo \"goto: None\"; fi";
 export declare const GALLERY: readonly GalleryTemplate[];
 /** The blank flow, for starting from nothing. */
 export declare const BLANK: GalleryTemplate;
 export declare const galleryTemplateOf: (id: string) => GalleryTemplate | null;
+/** A tool a template uses: where the chosen project stands with it (null with no project), and the zones that use it. */
+export type GalleryTool = {
+    id: string;
+    label: string;
+    state: "connected" | "open" | "taken" | null;
+    zones: string[];
+};
+/** A tool's name ("Mobbin", "Figma (desktop app)"); null for an id that's neither a one-click service nor an app on this computer. */
+export declare const galleryToolLabel: (id: string) => string | null;
+/** The zones that use a tool: a tool step on it, or a research or build step that names it ("With Mobbin, …"). */
+export declare function zonesUsing(definition: FlowDefinition, id: string): string[];
+/** A template's tools, each with its state in a project's connections (connectionsOf), or none without a project. */
+export declare function galleryToolsOf(template: GalleryTemplate, definition: FlowDefinition, connections: readonly {
+    id: string;
+    state: "connected" | "open" | "taken";
+}[] | null): GalleryTool[];
 export type GalleryAnswers = Record<string, string>;
 /** Each question's default for a project: the branch pull requests go to, when that's set up. */
 export declare function galleryDefaults(store: Store, template: GalleryTemplate, repo: string | null): GalleryAnswers;
@@ -68,7 +88,10 @@ export declare const SEND_RESULT: {
     readonly title: "Send me the result";
     readonly does: "When a card finishes, sends you what was done (its summary, links and screenshots) in your chat apps.";
 };
-/** A flow with "Send me the result" before its end: every path into its main Done zone passes through it first. */
+/** A template that already sends its result to the person: it isn't offered "Send me the result" again. */
+export declare const sendsAlready: (template: GalleryTemplate) => boolean;
+/** A flow with "Send me the result" before its end: every path into its main Done zone passes through it first.
+ * A flow that already has a send zone is left as it is, so nobody gets the result twice. */
 export declare function withSendResult(definition: FlowDefinition): FlowDefinition;
 /** The answers, checked in plain words, with what they fill in. Throws. */
 export declare function checkAnswers(template: GalleryTemplate, given: GalleryAnswers): GalleryAnswers;
@@ -96,6 +119,7 @@ export type GalleryPreview = {
     built: GalleryBuilt;
     startsFrom: string[];
     steps: string[];
+    tools: GalleryTool[];
     digest: string;
 };
 /** What using a template will do, in words, before anything is made: its triggers checked as the flow will have them. Throws. */