toolroll 0.9.86 → 0.9.88

package/dist/project-knowledge.d.ts

@@ -22,19 +22,19 @@ export type KnowledgeView = ReturnType<typeof knowledgeView>;
 export declare function knowledgeVersion(store: Store, repo: string, actor: string, revision: number): Knowledge;
 /** Chat reads only an admitted project. Keep the full source in the project UI. */
 export declare function conversationKnowledge(store: Store, repo: string, actor: string, reference?: string, decision?: number): {
-    title?: never;
-    content?: never;
+    history?: never;
     revision: number;
     stale: boolean;
     notice: string;
     decision?: never;
-    history?: never;
+    title?: never;
+    content?: never;
     instructions?: never;
     references?: never;
     decisions?: never;
 } | {
-    title?: never;
-    content?: never;
+    revision?: never;
+    history?: never;
     stale?: never;
     decision: {
         repo: string;
@@ -51,27 +51,27 @@ export declare function conversationKnowledge(store: Store, repo: string, actor:
         id: number;
     };
     notice: string;
-    revision?: never;
-    history?: never;
+    title?: never;
+    content?: never;
     instructions?: never;
     references?: never;
     decisions?: never;
 } | {
+    history?: never;
     stale?: never;
     decision?: never;
     revision: number;
     title: string;
     content: string;
     notice: string;
-    history?: never;
     instructions?: never;
     references?: never;
     decisions?: never;
 } | {
-    title?: never;
-    content?: never;
     stale?: never;
     decision?: never;
+    title?: never;
+    content?: never;
     revision: number;
     history: {
         revision: number;

package/dist/publish.d.ts

@@ -131,3 +131,14 @@ export declare function sweepMerges(store: Store, options: {
     clock?: () => Date;
     exec?: PublishExec;
 }): Promise<MergeReport>;
+/** A conditional settle (store.settleObservation) and, only when it won, that head's checks' own timing (v146 ci_check),
+ * in one transaction: a stale, losing answer neither settles nor records a check. */
+export declare function settleWithChecks(store: Store, observation: {
+    githubRepo: string;
+    prNumber: number;
+    headSha: string;
+    state: "passing" | "failing" | "running" | "none";
+    generation: number;
+}, rollup: unknown, now: Date): {
+    won: boolean;
+};

package/dist/publish.js

@@ -26,7 +26,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { run as execRun } from "./exec.js";
 import { summarizeChecks } from "./pulls.js";
-import { releasePublication } from "./store.js";
+import { parseCiRollup, recordCiChecks, releasePublication } from "./store.js";
 import { headWithin } from "./names.js";
 export const BODY_TEMPLATE_VERSION = 2;
 /** After this many failed attempts a publication stops retrying and pages instead. */
@@ -340,6 +340,8 @@ export async function observeChecks(store, options) {
                 if (!settled.won)
                     return;
                 won = true;
+                // The checks' own timing (v146), only with the observation that won.
+                recordCiChecks(store, publication.githubRepo, publication.prNumber, headOid, parseCiRollup(payload.statusCheckRollup), clock());
                 store.recordPublicationRemoteState(publication.id, remoteState, clock());
                 report.resolved += store.resolveCiEpisodes(publication.githubRepo, publication.prNumber, null, clock());
                 // A closed PR moots its merge blocker and supersedes its intent —
@@ -361,7 +363,8 @@ export async function observeChecks(store, options) {
             continue;
         }
         const state = summarizeChecks(payload.statusCheckRollup);
-        const settled = store.settleObservation({ githubRepo: publication.githubRepo, prNumber: publication.prNumber, headSha: headOid, state, generation }, clock());
+        // Settled and, when it won, the checks' own timing recorded (v146) in one transaction: a losing generation writes nothing.
+        const settled = settleWithChecks(store, { githubRepo: publication.githubRepo, prNumber: publication.prNumber, headSha: headOid, state, generation }, payload.statusCheckRollup, clock());
         if (!settled.won) {
             // An out-of-order response: a newer observation already spoke.
             // Nothing persists from this one (round-4 findings 24/25).
@@ -465,7 +468,7 @@ async function observeOne(store, exec, clock, githubRepo, prNumber) {
     if (String(payload.state ?? "").toUpperCase() !== "OPEN")
         return { ok: false, why: "pr-" + String(payload.state ?? "gone").toLowerCase() };
     const state = summarizeChecks(payload.statusCheckRollup);
-    const settled = store.settleObservation({ githubRepo, prNumber, headSha, state, generation }, clock());
+    const settled = settleWithChecks(store, { githubRepo, prNumber, headSha, state, generation }, payload.statusCheckRollup, clock());
     // A losing settle is NO observation (round-4 finding 24).
     if (!settled.won)
         return { ok: false, why: "stale-observation" };
@@ -707,3 +710,13 @@ export async function sweepMerges(store, options) {
     }
     return report;
 }
+/** A conditional settle (store.settleObservation) and, only when it won, that head's checks' own timing (v146 ci_check),
+ * in one transaction: a stale, losing answer neither settles nor records a check. */
+export function settleWithChecks(store, observation, rollup, now) {
+    return store.transact(() => {
+        const settled = store.settleObservation(observation, now);
+        if (settled.won)
+            recordCiChecks(store, observation.githubRepo, observation.prNumber, observation.headSha, parseCiRollup(rollup), now);
+        return settled;
+    });
+}

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

@@ -21,4 +21,5 @@ export type PullRequestSettingsView = {
     problem: string | null;
 };
 export declare function pullRequestSettingsHtml(view: PullRequestSettingsView): Html;
-export declare const PULL_REQUEST_SETTINGS_CSS = "\n  .pr-settings { display: grid; gap: .6rem; max-width: 40rem; }\n  .pr-settings p, .pr-settings h2 { margin: 0; }\n  .pr-settings label { display: grid; gap: .25rem; }\n  .pr-settings label input[type=password], .pr-settings select { min-height: 44px; box-sizing: border-box; width: 100%; }\n  .pr-settings .pr-check { display: flex; align-items: center; gap: .5rem; min-height: 44px; }\n  .pr-settings button { min-height: 44px; justify-self: start; }\n  .pr-terms { margin: 0; padding-left: 1.1rem; display: grid; gap: .25rem; }\n  @media (max-width: 480px) { .pr-settings button { justify-self: stretch; } }\n";
+/** Kept for the console's style bundle (server/chrome.ts); the page itself is kit markup. */
+export declare const PULL_REQUEST_SETTINGS_CSS = "";

package/dist/pull-request-ui.js

@@ -1,44 +1,55 @@
 /** Settings → Projects → Pull requests: one project's pull-request setup, in plain words. Off shows what setup
  * found (or what to fix) and one Turn on; on shows where pull requests go and how they merge. Every change takes
  * the password; turning on restates the exact repository and branch that were checked. */
-import { html, postForm, reauth } from "./html.js";
+import { html, joinHtml, postForm } from "./html.js";
+import { acts, btn, disclose, formRow, infoLine, note, notice, select, settingsSection, switchInput } from "./server/kit.js";
+import { kitSectionForm } from "./settings-kit.js";
 const METHOD_WORDS = { squash: "Squash and merge", merge: "Merge commit", rebase: "Rebase and merge" };
+const mono = (text) => html `<span class="k-mono">${text}</span>`;
 export function pullRequestSettingsHtml(view) {
-    const post = (act, body, hidden = {}) => postForm("/settings/pull-requests", body, { attrs: { class: "card pr-settings" }, hidden: { repo: view.repo, act, ...hidden } });
-    const password = html `${reauth(html `<label>Password<input type="password" name="password" autocomplete="current-password" required></label>`)}`;
-    const notes = [
-        view.said === null ? "" : html `<p class="notice" role="status">${view.said}</p>`,
-        view.problem === null ? "" : html `<p class="problem" role="alert">${view.problem}</p>`,
-    ];
-    const head = html `<p class="meta">${view.name} · <span class="mono">${view.repo}</span></p>${notes}`;
+    const head = joinHtml([
+        view.problem === null ? "" : notice(view.problem),
+        view.said === null ? "" : infoLine(view.said),
+        note(html `${view.name} · ${mono(view.repo)}`),
+    ]);
     const publishing = view.publishing;
     if (publishing.on) {
-        const status = html `<section class="card pr-settings"><p><strong>On</strong> · <span class="mono">${publishing.githubRepo}</span> into <span class="mono">${publishing.base}</span></p><p class="meta">${publishing.legacy ? "Every finished build opens a pull request (set up with publish grant)." : "Complete offers “Complete and open a pull request”."} Set up by ${publishing.grantedBy}.</p></section>`;
+        const status = settingsSection({ id: "pull-requests", title: "Pull requests", state: " · On",
+            lead: html `${mono(publishing.githubRepo)} into ${mono(publishing.base)}`,
+            body: note(`${publishing.legacy ? "Every finished build opens a pull request (set up with publish grant)." : "Complete offers “Complete and open a pull request”."} Set up by ${publishing.grantedBy}.`) });
         if (!view.canChange)
-            return html `${head}${status}`;
-        const methods = ["squash", "merge", "rebase"].map(method => html `<option value="${method}"${publishing.mergeMethod === method ? html ` selected` : ""}>${METHOD_WORDS[method]}${method === "squash" ? " (default)" : ""}</option>`);
-        return html `${head}${status}${post("settings", html `<h2>Merging</h2><label>Merge method<select name="method">${methods}</select></label><label class="row pr-check"><input type="checkbox" name="when-green" value="1"${publishing.mergeWhenGreen ? html ` checked` : ""}> Merge when checks pass</label><p class="meta">Off by default. When on, a pull request merges by itself once its checks pass on the completed commit. Branches are deleted after merging.</p>${password}<button type="submit">Save</button>`)}<details class="settings-more"><summary>Turn off pull requests</summary>${post("off", html `<p class="meta">Nothing more is pushed. Open pull requests stay on GitHub.</p>${password}<button type="submit" class="danger">Turn off</button>`)}</details>`;
+            return joinHtml([head, status]);
+        const merging = settingsSection({ id: "merging", title: "Merging",
+            body: kitSectionForm({ proof: "pull-requests", action: "/settings/pull-requests", id: "merging-form", gate: true, hidden: { repo: view.repo, act: "settings" },
+                body: joinHtml([
+                    formRow("Merge method", null, select({ id: "pr-method", name: "method", label: "Merge method", current: publishing.mergeMethod,
+                        items: ["squash", "merge", "rebase"].map(method => [method, `${METHOD_WORDS[method]}${method === "squash" ? " (default)" : ""}`]) })),
+                    formRow("Merge when checks pass", "Off by default. When on, a pull request merges by itself once its checks pass on the completed commit. Branches are deleted after merging.", switchInput({ id: "pr-when-green", name: "when-green", label: publishing.mergeWhenGreen ? "On" : "Off", on: publishing.mergeWhenGreen, attrs: { value: "1", "aria-label": "Merge when checks pass" } }), "inline"),
+                ]) }) });
+        const off = disclose("Turn off pull requests", kitSectionForm({ proof: "pull-requests", action: "/settings/pull-requests", id: "pr-off-form", hidden: { repo: view.repo, act: "off" },
+            save: { label: "Turn off", variant: "danger" }, confirm: "Turn off pull requests", body: note("Nothing more is pushed. Open pull requests stay on GitHub.") }));
+        return joinHtml([head, status, merging, off]);
     }
     const check = view.check;
     if (check === null)
-        return html `${head}<section class="card pr-settings"><p><strong>Off</strong></p><p class="meta">An approver can turn on pull requests.</p></section>`;
+        return joinHtml([head, settingsSection({ id: "pull-requests", title: "Pull requests", state: " · Off", body: note("An approver can turn on pull requests.") })]);
     // The checks ask git and GitHub, so they run when asked, never on opening the page (docs/plans/get-side-effects.md).
-    const checkButton = (label) => postForm("/settings/pull-requests/check", html `<button type="submit"${label === "Check again" ? html ` class="secondary"` : ""}>${label}</button>`, { hidden: { repo: view.repo } });
-    if (check === "unchecked")
-        return html `${head}<section class="card pr-settings"><p><strong>Off</strong></p><p class="meta">Check this project's GitHub setup to see what turning on would do.</p>${checkButton("Check setup")}</section>`;
+    const checkButton = (label, variant) => postForm("/settings/pull-requests/check", acts(btn(label, { sm: true, type: "submit", variant })), { hidden: { repo: view.repo } });
+    if (check === "unchecked") {
+        return joinHtml([head, settingsSection({ id: "pull-requests", title: "Pull requests", state: " · Off",
+                lead: "Check this project's GitHub setup to see what turning on would do.", body: checkButton("Check setup", "primary") })]);
+    }
     if (!check.ok) {
-        return html `${head}<section class="card pr-settings"><p><strong>Can’t turn on yet</strong></p><p>${check.message}</p>${checkButton("Check again")}</section>`;
+        return joinHtml([head, settingsSection({ id: "pull-requests", title: "Pull requests", state: " · Can’t turn on yet",
+                body: joinHtml([notice(check.message), checkButton("Check again", "outline")]) })]);
     }
     const plan = check.plan;
-    return html `${head}${post("on", html `<p><strong>Ready to turn on</strong></p><ul class="pr-terms"><li>Pull requests open on <span class="mono">${plan.githubRepo}</span> into <span class="mono">${plan.base}</span>${plan.account === null ? "" : `, as ${plan.account}`}.</li><li>Complete offers “Complete and open a pull request”, from the exact completed commit. A flow's Pull request zone can open one too.</li><li>Merging squashes and deletes the branch. A person merges with their password; a flow merges only when its zone says so, after a person approved the card.</li></ul>${password}<button type="submit">Turn on pull requests</button>`, { github: plan.githubRepo, base: plan.base })}`;
+    return joinHtml([head, settingsSection({ id: "pull-requests", title: "Pull requests", state: " · Ready to turn on",
+            body: kitSectionForm({ proof: "pull-requests-on", action: "/settings/pull-requests", id: "pr-on-form", hidden: { repo: view.repo, act: "on", github: plan.githubRepo, base: plan.base },
+                save: { label: "Turn on pull requests" }, confirm: "Turn on pull requests",
+                body: html `<ul class="k-note"><li>Pull requests open on ${mono(plan.githubRepo)} into ${mono(plan.base)}${plan.account === null ? "" : `, as ${plan.account}`}.</li>\
+<li>Complete offers “Complete and open a pull request”, from the exact completed commit. A flow's Pull request zone can open one too.</li>\
+<li>Merging squashes and deletes the branch. A person merges with their password; a flow merges only when its zone says so, after a person approved the card.</li></ul>` }) })]);
 }
-export const PULL_REQUEST_SETTINGS_CSS = `
-  .pr-settings { display: grid; gap: .6rem; max-width: 40rem; }
-  .pr-settings p, .pr-settings h2 { margin: 0; }
-  .pr-settings label { display: grid; gap: .25rem; }
-  .pr-settings label input[type=password], .pr-settings select { min-height: 44px; box-sizing: border-box; width: 100%; }
-  .pr-settings .pr-check { display: flex; align-items: center; gap: .5rem; min-height: 44px; }
-  .pr-settings button { min-height: 44px; justify-self: start; }
-  .pr-terms { margin: 0; padding-left: 1.1rem; display: grid; gap: .25rem; }
-  @media (max-width: 480px) { .pr-settings button { justify-self: stretch; } }
-`;
+/** Kept for the console's style bundle (server/chrome.ts); the page itself is kit markup. */
+export const PULL_REQUEST_SETTINGS_CSS = "";

package/dist/recipe-ui.d.ts

@@ -1,7 +1,9 @@
 import { type Recipe, type RecipeDocument, type WorkflowPreview } from "./recipes.js";
 import { type Html } from "./html.js";
 export declare function recipeFromForm(body: URLSearchParams): RecipeDocument;
-export declare function recipeLibraryHtml(starters: Recipe[], saved: Recipe[], project: string | null, revision: number, recent: {
+/** "One-time work" (New flow): the open project's recipes and the starters as rows, each with one "Use this"; then
+ * Create a recipe, importing a shared one, and the work recipes made lately. */
+export declare function recipeRowsHtml(starters: Recipe[], saved: Recipe[], project: string | null, projectName: string | null, revision: number, recent: {
     name: string;
     href: string;
     state: string;
@@ -16,4 +18,4 @@ export declare function recipeDefinitionPreviewHtml(preview: WorkflowPreview, re
 export declare function recipeRunHtml(recipe: Recipe, repo: string, revision: number, problem?: string | null, values?: URLSearchParams, saved?: boolean): Html;
 export declare function recipeAnswersFromForm(body: URLSearchParams): Map<string, string>;
 export declare function recipeScript(): string;
-export declare const RECIPE_CSS = "\n.recipe-heading { margin: .5rem 0 1.75rem; max-width: 46rem; }\n.recipe-heading h1 { font-size: clamp(1.65rem,3vw,2.5rem); letter-spacing:-.035em; margin:.35rem 0 .6rem; }\n.recipe-kicker { font-size:.7rem; text-transform:uppercase; letter-spacing:.12em; color:var(--muted-foreground); }\n.recipe-grid { display:grid; grid-template-columns:repeat(3,minmax(0,1fr)); gap:.8rem; margin:1rem 0 2rem; }\n.recipe-card { border:1px solid var(--border); border-radius:var(--radius); padding:1.1rem; background:var(--card); display:flex; flex-direction:column; gap:.5rem; }\n.recipe-card h3 { font-size:1.05rem; margin:0; letter-spacing:-.015em; }\n.recipe-card p { color:var(--muted-foreground); margin:.2rem 0; font-size:.85rem; line-height:1.5; }\n.recipe-card-link { margin-top:auto; padding-top:.75rem; display:flex; justify-content:space-between; }\n.recipe-editor { max-width:52rem; }.recipe-editor h2 { margin-top:0; }\n.recipe-criterion { border:1px solid var(--border); border-radius:calc(var(--radius) - 3px); padding:.8rem; margin:.8rem 0; }\n.recipe-evidence { display:flex; flex-wrap:wrap; gap:.5rem 1rem; }.recipe-evidence label { display:flex; align-items:center; gap:.4rem; font-size:.8rem; }.recipe-evidence input { width:auto; margin:0; }\n.recipe-options { display:grid; grid-template-columns:1fr 1fr; gap:1rem; }\n.recipe-preview-grid { display:grid; grid-template-columns:minmax(0,1.7fr) minmax(16rem,1fr); gap:1rem; }\n.recipe-steps { padding-left:1.4rem; }.recipe-steps li { padding:.4rem 0 .6rem .3rem; }.recipe-steps p { margin:.3rem 0 0; font-size:.85rem; color:var(--muted-foreground); }\n.recipe-launch { display:grid; grid-template-columns:1fr 1fr; gap:1rem; }.recipe-launch form { margin:0 0 .6rem; }\n.recipe-history a { display:flex; justify-content:space-between; gap:1rem; padding:.6rem 0; border-bottom:1px solid var(--border); }.recipe-history span { color:var(--muted-foreground); }\n.recipe-error { border-color:var(--destructive); }\n.recipe-card[hidden] { display:none; }.recipe-search { max-width:28rem; }.recipe-question { border:1px solid var(--border); border-radius:calc(var(--radius) - 3px); margin:1rem 0; padding:.8rem; min-width:0; }.recipe-run { max-width:42rem; }.recipe-run button { margin-top:1rem; }\n@media(max-width:1000px){.recipe-grid { grid-template-columns:repeat(2,minmax(0,1fr)); }}\n@media(max-width:760px){.recipe-grid,.recipe-options,.recipe-preview-grid,.recipe-launch { grid-template-columns:1fr; }.recipe-heading { margin-bottom:1rem; }.recipe-history a { flex-direction:column; gap:.2rem; }}\n";
+export declare const RECIPE_CSS = "\n.fl-recipe-more { display:grid; gap:12px; padding-top:12px; }.fl-recipe-more .k-disclose[open] > form, .fl-recipe-more .k-disclose[open] > div { margin-top:12px; }.fl-recipe-import { display:grid; gap:12px; margin:0; }\n.fl-recipe-recent { display:grid; }.fl-recipe-recent a { display:flex; justify-content:space-between; gap:12px; min-height:40px; align-items:center; border-bottom:1px solid var(--so-line); color:var(--so-ink); text-decoration:none; font-size:13px; }\n.recipe-heading { margin: .5rem 0 1.75rem; max-width: 46rem; }\n.recipe-heading h1 { font-size: clamp(1.65rem,3vw,2.5rem); letter-spacing:-.035em; margin:.35rem 0 .6rem; }\n.recipe-kicker { font-size:.7rem; text-transform:uppercase; letter-spacing:.12em; color:var(--muted-foreground); }\n.recipe-grid { display:grid; grid-template-columns:repeat(3,minmax(0,1fr)); gap:.8rem; margin:1rem 0 2rem; }\n.recipe-card { border:1px solid var(--border); border-radius:var(--radius); padding:1.1rem; background:var(--card); display:flex; flex-direction:column; gap:.5rem; }\n.recipe-card h3 { font-size:1.05rem; margin:0; letter-spacing:-.015em; }\n.recipe-card p { color:var(--muted-foreground); margin:.2rem 0; font-size:.85rem; line-height:1.5; }\n.recipe-card-link { margin-top:auto; padding-top:.75rem; display:flex; justify-content:space-between; }\n.recipe-editor { max-width:52rem; }.recipe-editor h2 { margin-top:0; }\n.recipe-criterion { border:1px solid var(--border); border-radius:calc(var(--radius) - 3px); padding:.8rem; margin:.8rem 0; }\n.recipe-evidence { display:flex; flex-wrap:wrap; gap:.5rem 1rem; }.recipe-evidence label { display:flex; align-items:center; gap:.4rem; font-size:.8rem; }.recipe-evidence input { width:auto; margin:0; }\n.recipe-options { display:grid; grid-template-columns:1fr 1fr; gap:1rem; }\n.recipe-preview-grid { display:grid; grid-template-columns:minmax(0,1.7fr) minmax(16rem,1fr); gap:1rem; }\n.recipe-steps { padding-left:1.4rem; }.recipe-steps li { padding:.4rem 0 .6rem .3rem; }.recipe-steps p { margin:.3rem 0 0; font-size:.85rem; color:var(--muted-foreground); }\n.recipe-launch { display:grid; grid-template-columns:1fr 1fr; gap:1rem; }.recipe-launch form { margin:0 0 .6rem; }\n.recipe-history a { display:flex; justify-content:space-between; gap:1rem; padding:.6rem 0; border-bottom:1px solid var(--border); }.recipe-history span { color:var(--muted-foreground); }\n.recipe-error { border-color:var(--destructive); }\n.recipe-card[hidden] { display:none; }.recipe-search { max-width:28rem; }.recipe-question { border:1px solid var(--border); border-radius:calc(var(--radius) - 3px); margin:1rem 0; padding:.8rem; min-width:0; }.recipe-run { max-width:42rem; }.recipe-run button { margin-top:1rem; }\n@media(max-width:1000px){.recipe-grid { grid-template-columns:repeat(2,minmax(0,1fr)); }}\n@media(max-width:760px){.recipe-grid,.recipe-options,.recipe-preview-grid,.recipe-launch { grid-template-columns:1fr; }.recipe-heading { margin-bottom:1rem; }.recipe-history a { flex-direction:column; gap:.2rem; }}\n";

package/dist/recipe-ui.js

@@ -3,6 +3,8 @@ import { composerSchedule, scheduleEditorHtml, scheduleEditorScript } from "./ta
 import { parseRecipe, workflowSteps, recipeScheduleWords, RecipeError, RECIPE_INPUT_LIMIT } from "./recipes.js";
 import { ACCEPTANCE_LIMITS } from "./scope.js";
 import { html, joinHtml, postForm, replaceMarkup } from "./html.js";
+import { templateRow } from "./flow-gallery-ui.js";
+import { acts, btn, count, disclose, field, group, note, textarea } from "./server/kit.js";
 const hidden = (name, value) => html `<input type="hidden" name="${name}" value="${value}">`;
 const evidence = [["check", "Passing tests or commands"], ["changed-path", "Changed files"], ["screenshot", "Screenshot"], ["manual-review", "Reviewer assessment"]];
 export function recipeFromForm(body) {
@@ -53,10 +55,16 @@ export function recipeFromForm(body) {
     return parseRecipe({ format: "standing-orders-recipe", version: inputs.length ? 2 : 1, ...(inputs.length ? { inputs } : {}), name: body.get("name") ?? "", description: body.get("description") ?? "", goal: body.get("goal") ?? "", outOfScope: body.get("not") || null,
         touches: (body.get("touches") ?? "").split(/[\n,]/).map(one => one.trim()).filter(Boolean), acceptance, planning: body.get("planning") ?? "auto", deliverable: body.get("deliverable") ?? "branch", schedule: schedule.schedule, costCeilingUsd: ceiling === "" ? null : Number(ceiling) });
 }
-export function recipeLibraryHtml(starters, saved, project, revision, recent) {
-    const cards = (recipes, reusable = false) => html `<div class="recipe-grid"${reusable && html ` data-saved-recipes`}>${recipes.map(recipe => html `<article class="recipe-card" data-recipe-card data-recipe-search="${recipe.document.name + " " + recipe.document.description}"><p class="recipe-kicker">${recipe.document.deliverable === "report" ? "Report" : recipe.document.schedule === null ? "One-time work" : "Recurring care"}${recipe.document.version === 2 ? ` · ${recipe.document.inputs.length} question${recipe.document.inputs.length === 1 ? "" : "s"}` : ""}</p><h3>${recipe.document.name}</h3><p>${recipe.document.description}</p><a class="recipe-card-link" href="/recipes/${reusable ? "run" : "start"}?recipe=${recipe.id}&revision=${recipe.revision}">${reusable ? "Use recipe" : "Customize recipe"} <span aria-hidden="true">→</span></a>${reusable && html `<a class="meta" href="/recipes/start?recipe=${recipe.id}&revision=${recipe.revision}">Edit a copy</a>`}</article>`)}</div>`;
-    const savedSection = html `<h2>Your project’s recipes</h2>${saved.length >= 100 && html `<p class="meta">Showing 100 recipes, with recently used recipes first.</p>`}${saved.length ? html `<p class="hint">Your usual work, ready to go. Recently used recipes come first.</p><label class="recipe-search">Find a recipe<input type="search" data-recipe-search-input placeholder="Search your recipes…"></label>${cards(saved, true)}<p data-recipe-empty hidden>No recipes match. Try another search.</p>` : html `<p class="hint">Save work you do often. Subagents with project access can use the same recipe.</p>`}`;
-    return html `<div class="recipe-heading"><p class="recipe-kicker">Workflows</p><h1>Good work, on repeat.</h1><p class="hint">Save the work you do often. Answer what changes this time. Kick it off.</p><p><a href="/recipes/new" class="new-task">Create a recipe</a> <a href="/flows">Manage scheduled work →</a></p></div>${project === null && html `<div class="card"><strong>Choose a project to get started.</strong><p>Browse recipes now; <a href="/projects">open a project</a> to customize, save, or run one.</p></div>`}${saved.length > 0 && savedSection}<h2>Start here</h2>${cards(starters)}${saved.length === 0 && savedSection}${recent.length > 0 && html `<h2>Recent workflows</h2><div class="card recipe-history">${recent.map(one => html `<a href="${one.href}"><strong>${one.name}</strong><span>${one.state} →</span></a>`)}</div>`}${project !== null && html `<details class="card"><summary>Import a shared recipe</summary><p class="hint">Paste exported recipe JSON. You’ll review it in this project before creating any work.</p>${postForm("/recipes/import", html `<label>Recipe JSON<textarea name="document" rows="7" required maxlength="32768" spellcheck="false"></textarea></label><button type="submit">Review imported recipe</button>`, { projectRevision: String(revision), hidden: { repo: project } })}</details>`}`;
+/** "One-time work" (New flow): the open project's recipes and the starters as rows, each with one "Use this"; then
+ * Create a recipe, importing a shared one, and the work recipes made lately. */
+export function recipeRowsHtml(starters, saved, project, projectName, revision, recent) {
+    const kind = (recipe) => `${recipe.document.deliverable === "report" ? "Report" : "Code change"} · ${recipe.document.schedule === null ? "runs once as a task" : "repeats on a schedule"}${recipe.document.version === 2 ? ` · ${recipe.document.inputs.length} question${recipe.document.inputs.length === 1 ? "" : "s"}` : ""}`;
+    const rowOf = (recipe, reusable) => templateRow({ name: recipe.document.name, promise: recipe.document.description, line: kind(recipe), attrs: html ` data-recipe-card data-recipe="${recipe.id}"`,
+        action: project === null ? "" : btn("Use this", { sm: true, href: `/recipes/${reusable ? "run" : "start"}?recipe=${recipe.id}&revision=${recipe.revision}`, attrs: { "aria-label": `Use ${recipe.document.name}` } }) });
+    const tools = project === null ? note("Open a project to use, save or import a recipe.")
+        : html `<p class="k-acts fl-recipe-acts">${btn("Create a recipe", { sm: true, href: "/recipes/new" })}</p>${disclose("Import a shared recipe", postForm("/recipes/import", html `${field({ id: "fl-recipe-json", label: "Recipe JSON", hint: "Paste exported recipe JSON. You review it in this project before any work is made.", control: textarea({ id: "fl-recipe-json", name: "document", rows: 6, attrs: { required: true, maxlength: 32768, spellcheck: "false" } }) })}${acts(btn("Review imported recipe", { type: "submit" }))}`, { projectRevision: String(revision), hidden: { repo: project }, attrs: { class: "fl-recipe-import" } }))}`;
+    const recentRows = recent.length === 0 ? "" : disclose(`Made from recipes lately (${recent.length})`, html `<div class="fl-recipe-recent">${recent.map(one => html `<a href="${one.href}"><span>${one.name}</span><span class="k-note">${one.state}</span></a>`)}</div>`);
+    return html `${group(projectName === null ? "One-time work" : `One-time work in ${projectName}`, count(saved.length + starters.length))}<div data-group="recipes">${saved.map(one => rowOf(one, true))}${starters.map(one => rowOf(one, false))}</div><div class="fl-recipe-more">${tools}${recentRows}</div>`;
 }
 function criterionHtml(index, criterion, values) {
     const prefix = `criterion-${index}-`;
@@ -137,6 +145,8 @@ export function recipeScript() {
   })();`;
 }
 export const RECIPE_CSS = `
+.fl-recipe-more { display:grid; gap:12px; padding-top:12px; }.fl-recipe-more .k-disclose[open] > form, .fl-recipe-more .k-disclose[open] > div { margin-top:12px; }.fl-recipe-import { display:grid; gap:12px; margin:0; }
+.fl-recipe-recent { display:grid; }.fl-recipe-recent a { display:flex; justify-content:space-between; gap:12px; min-height:40px; align-items:center; border-bottom:1px solid var(--so-line); color:var(--so-ink); text-decoration:none; font-size:13px; }
 .recipe-heading { margin: .5rem 0 1.75rem; max-width: 46rem; }
 .recipe-heading h1 { font-size: clamp(1.65rem,3vw,2.5rem); letter-spacing:-.035em; margin:.35rem 0 .6rem; }
 .recipe-kicker { font-size:.7rem; text-transform:uppercase; letter-spacing:.12em; color:var(--muted-foreground); }

package/dist/release-adapters.d.ts

@@ -189,3 +189,6 @@ export declare class ProtectionUnreadable extends Error {
 }
 /** Whether main's protection holds, as a yes/no (release-auto.ts sealAutoGreen): null when it can't be read. */
 export declare function readUpToDateRequired(run: Exec, gh: string, repo: string, branch?: string): Promise<boolean | null>;
+/** The release's step record (store.ts release_step, v146) through a store opened for each entry: a failure to open or
+ * write is swallowed, so recording never stops or changes the release. */
+export declare function releaseProgressRecorder(open: () => Store, done: (store: Store) => void): NonNullable<ReleaseAdapters["progress"]>;

package/dist/release-adapters.js

@@ -19,7 +19,7 @@ import { PROTECTION_MINIMUM_CHECKS, PROTECTION_REPORT_ONLY_CHECKS } from "./rele
 import { activeUpdateWork } from "./desktop-update-gate.js";
 import { BEFORE_SWAP, gateOwner } from "./release-gate.js";
 import { findCliLinks, switchCliLinks } from "./release-links.js";
-import { databasePath, finishReleaseOperation, requireFreshReleaseApproval, openStore, releaseAuthorityOfTask, releaseCarries, releaseOperations, renewReleaseLease, reserveRelease, runReleaseOperation, Store, releaseIssuerGone, takeReleaseLease, } from "./store.js";
+import { databasePath, finishReleaseOperation, requireFreshReleaseApproval, openStore, releaseAuthorityOfTask, releaseCarries, releaseOperations, renewReleaseLease, reserveRelease, runReleaseOperation, Store, recordReleaseStep, releaseIssuerGone, takeReleaseLease, } from "./store.js";
 import { acquireDeploymentLock } from "./deploy-lock.js";
 import { autoReleaseApprovalOf, liveReleaseOf } from "./scope.js";
 import { recheckReleaseTask, releaseCheckStanding } from "./check-failure.js";
@@ -429,7 +429,7 @@ export function releaseAdapters(options) {
     // A boundary's one bounded read of GitHub's nightly: plain exec, never the release's long retries (20 s in all).
     githubReads(run, ciGh));
     return {
-        ...(existsSync(database) ? { release } : {}),
+        ...(existsSync(database) ? { release, progress: releaseProgressRecorder(() => openStore(database), store => store.close()) } : {}),
         now: options.now ?? (() => new Date()),
         sleep: options.sleep ?? sleep,
         say,
@@ -1471,3 +1471,23 @@ function mainTriggered(run) {
         return bases.length > 0 && bases.every(base => base === "main");
     return false;
 }
+/** The release's step record (store.ts release_step, v146) through a store opened for each entry: a failure to open or
+ * write is swallowed, so recording never stops or changes the release. */
+export function releaseProgressRecorder(open, done) {
+    return entry => {
+        let store = null;
+        try {
+            store = open();
+            recordReleaseStep(store, entry);
+        }
+        catch { /* best effort: the release goes on */ }
+        finally {
+            if (store !== null) {
+                try {
+                    done(store);
+                }
+                catch { /* best effort */ }
+            }
+        }
+    };
+}

package/dist/release-cli.js

@@ -16,7 +16,8 @@ import { RELEASE_LIMITS, runRelease } from "./release.js";
 import { processes, releaseAdapters } from "./release-adapters.js";
 import { journals, releaseGate } from "./release-gate.js";
 import { rescueDeployment } from "./deploy-rescue.js";
-import { databasePath, openStore, revokeRelease } from "./store.js";
+import { databasePath, elapsedSeconds, latestReleaseStepTask, openStore, releaseProgressFor, revokeRelease } from "./store.js";
+import { dur } from "./design/kit.js";
 import { carryRefusalWords, proveCarry, setAskEveryReleaseCommit, setUnsandboxedCarry } from "./release-carry.js";
 import { authenticateApprover, machineActing, personProof, proveCredential } from "./scope.js";
 import { allowAutoPublish, setReleaseApproval } from "./release-auto.js";
@@ -35,6 +36,12 @@ export const RELEASE_HELP = `toolroll release <branch> — release Toolroll itse
 
   Run the same command to resume after a stop. Interrupted deployments recover their saved stage before retrying.
 
+  A branch whose name is one of this command's own words (status, nightly, carry…) is named with --branch <name>
+  or after --: \`toolroll release --branch status\`.
+
+toolroll release status [<task>] — the steps of a release (the newest one recorded, or the release task named): each
+  step's state and how long it took, and where it stopped
+
 toolroll release --release-gate <id> [--yes] — lift the update pause a deployment left before its swap
 
   Shows why it is safe first: the pause is that deployment's, its journal stopped before the swap, and the
@@ -98,7 +105,7 @@ A runner's lease is returned with \`toolroll worker release <lease>\`.`;
 /** A runner lease id (claim.ts mints randomUUID()). */
 export const LEASE_SHAPED = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 export const LEASE_DEPRECATION = "`toolroll release <lease>` is now `toolroll worker release <lease>`; the old form goes in the next minor version.";
-const VALUE_FLAGS = new Set(["--repo", "--limit", "--tap", "--release-gate", "--to", "--request", "--as", "--token", "--schedule", "--stage", "--lane-retire"]);
+const VALUE_FLAGS = new Set(["--repo", "--limit", "--tap", "--release-gate", "--to", "--request", "--as", "--token", "--schedule", "--stage", "--lane-retire", "--branch"]);
 const BARE_FLAGS = new Set(["--new", "--json", "--help", "--yes", "--no-carry", "--start", "--recover-deploy", "--github"]);
 export async function runReleaseCommand(args, write, deps = {}) {
     // The flag, not a secret's value that happens to read "--json".
@@ -112,9 +119,23 @@ export async function runReleaseCommand(args, write, deps = {}) {
     const positional = [];
     const limits = {};
     let stage, laneRetire, laneAlias;
+    // `--branch <name>` (or `-- <name>`) names the branch outright, so a branch called "status", "nightly" or "carry" is
+    // still a branch and never one of this command's own words.
+    let branchFlag, literal = false, branchFlags = 0;
+    // Only what follows `--` is literal: it never changes how the words before it read.
+    const literalArgs = [];
     let repo, tap, gate, to, request, as, token, scheduleFlag;
     for (let i = 0; i < args.length; i += 1) {
         const raw = args[i];
+        // After `--`, every argument is a branch name, never a flag or a subcommand.
+        if (raw === "--" && !literal) {
+            literal = true;
+            continue;
+        }
+        if (literal) {
+            literalArgs.push(raw);
+            continue;
+        }
         if (BARE_FLAGS.has(raw))
             continue;
         // `--lane-alias <lane-id> <new name>`: two values, neither a flag of this command.
@@ -157,6 +178,10 @@ export async function runReleaseCommand(args, write, deps = {}) {
                 stage = value;
             else if (arg === "--lane-retire")
                 laneRetire = value;
+            else if (arg === "--branch") {
+                branchFlag = value;
+                branchFlags += 1;
+            }
             else {
                 const match = /^([a-z]+)=([0-9]+)$/.exec(value);
                 if (match === null || !(match[1] in RELEASE_LIMITS) || Number(match[2]) < 1)
@@ -174,12 +199,12 @@ export async function runReleaseCommand(args, write, deps = {}) {
         return 0;
     }
     if (gate !== undefined) {
-        if (positional.length > 0 || args.some(arg => ["--repo", "--limit", "--tap", "--new"].includes(arg)))
+        if (positional.length > 0 || branchFlag !== undefined || literalArgs.length > 0 || args.some(arg => ["--repo", "--limit", "--tap", "--new"].includes(arg)))
             return refuse("usage", "--release-gate <id> takes no branch or release options.", 2);
         return runGateRelease(gate, bare.has("--yes"), write, json, deps.gateWorld ?? installedGateWorld());
     }
     if (bare.has("--recover-deploy")) {
-        if (positional.length > 0 || args.some(arg => ["--repo", "--limit", "--tap", "--new", "--release-gate"].includes(arg.split("=")[0])))
+        if (positional.length > 0 || branchFlag !== undefined || literalArgs.length > 0 || args.some(arg => ["--repo", "--limit", "--tap", "--new", "--release-gate"].includes(arg.split("=")[0])))
             return refuse("usage", "--recover-deploy takes only --stage <dir>, --yes and --json.", 2);
         return runRescue(stage, bare.has("--yes"), write, json, deps.rescueWorld ?? installedRescueWorld(deps.cwd ?? process.cwd()));
     }
@@ -194,15 +219,29 @@ export async function runReleaseCommand(args, write, deps = {}) {
             return refuse("usage", "Use one of --github, --lane-alias or --lane-retire, without --schedule or --start.", 2);
         return runGithubNightlyCommand({ repo: repo === undefined ? undefined : resolve(deps.cwd ?? process.cwd(), repo), as, token, alias: laneAlias, retire: laneRetire }, write, json, deps);
     }
-    if (positional[0] === "nightly" && positional.length === 1)
+    const named = branchFlag !== undefined || literalArgs.length > 0;
+    // One branch, named one way: never a guess between two.
+    if (branchFlags > 1 || literalArgs.length > 1 || (branchFlag !== undefined && (positional.length > 0 || literalArgs.length > 0)) || (literalArgs.length > 0 && positional.length > 0)) {
+        return refuse("usage", "Name the branch once: `toolroll release <branch>`, `--branch <name>` or `-- <name>`, never two of them.", 2);
+    }
+    if (branchFlag !== undefined && branchFlag === "")
+        return refuse("usage", "--branch takes a branch name.", 2);
+    // `release status [<task>]`: the steps recorded for a release. A branch named "status" is released with
+    // `--branch status` (or `-- status`).
+    if (!named && positional[0] === "status" && positional.length <= 2) {
+        if (args.some(arg => VALUE_FLAGS.has(arg.split("=")[0]) || ["--new", "--no-carry", "--start"].includes(arg)))
+            return refuse("usage", "`toolroll release status [<task>]` takes only --json.", 2);
+        return runStatusCommand(positional[1], write, json, deps);
+    }
+    if (!named && positional[0] === "nightly" && positional.length === 1)
         return runNightlyCommand({ repo: repo === undefined ? undefined : resolve(deps.cwd ?? process.cwd(), repo), as, token, schedule: scheduleFlag, start: bare.has("--start") }, write, json, deps);
-    if (["carry", "revoke", "ask-every-commit", "unsandboxed-carry", "auto-approve", "publish-ok"].includes(positional[0] ?? "") && positional.length === 2) {
+    if (!named && ["carry", "revoke", "ask-every-commit", "unsandboxed-carry", "auto-approve", "publish-ok"].includes(positional[0] ?? "") && positional.length === 2) {
         return runAuthorityCommand(positional[0], positional[1], { to, request, as, token, repo: repo === undefined ? undefined : resolve(deps.cwd ?? process.cwd(), repo) }, write, json, deps);
     }
-    if (positional.length !== 1)
+    if (!named && positional.length !== 1)
         return refuse("usage", `Which branch? \`toolroll release <branch>\`.\n${RELEASE_HELP}`, 2);
-    const branch = positional[0];
-    if (LEASE_SHAPED.test(branch)) {
+    const branch = branchFlag ?? literalArgs[0] ?? positional[0];
+    if (!named && LEASE_SHAPED.test(branch)) {
         const releaseOptions = args.filter(arg => VALUE_FLAGS.has(arg) || arg === "--new");
         if (releaseOptions.length > 0)
             return refuse("ambiguous", `${branch} looks like a lease id, but ${releaseOptions[0]} is a release option. Return a lease with \`toolroll worker release <lease>\`; a branch shaped like a lease id can't be released.`, 2);
@@ -519,3 +558,36 @@ async function runGithubNightlyCommand(flags, write, json, deps) {
         store.close();
     }
 }
+/** `toolroll release status [<task>]` (read-only): the release's recorded steps (store.ts release_step, v146). */
+async function runStatusCommand(task, write, json, deps) {
+    const command = "release status";
+    const refuse = (reason, message, code) => { write(json ? checkedEnvelopeJson({ ok: false, command, reason, message }) : message); return code; };
+    const database = deps.database ?? databasePath(process.env, homedir());
+    if (!existsSync(database))
+        return refuse("no-plane", "This machine has no Toolroll database.", 1);
+    const store = openStore(database);
+    try {
+        const now = (deps.now ?? (() => new Date()))();
+        const taskId = task ?? latestReleaseStepTask(store);
+        if (taskId === null)
+            return refuse("no-release", "No release has recorded its steps yet.", 1);
+        const progress = releaseProgressFor(store, taskId);
+        if (progress === null)
+            return refuse("no-release", `No release steps are recorded for ${taskId}.`, 1);
+        const steps = progress.steps.map(one => ({ ...one, seconds: elapsedSeconds(one.startedAt, one.endedAt, now) }));
+        if (json) {
+            write(checkedEnvelopeJson({ ok: true, command, task: taskId, release: { ...progress, steps } }));
+            return 0;
+        }
+        const word = { running: "running", waiting: "waiting", done: "done", failed: "failed" };
+        write(`Release ${progress.version} (${progress.tag})${progress.pr === null ? "" : ` · pull request #${progress.pr}`} · task ${taskId}`);
+        for (const one of steps)
+            write(`  ${one.step.padEnd(9)} ${word[one.state].padEnd(8)} ${one.seconds === null ? "–" : dur(one.seconds)}${one.detail === null ? "" : `  ${one.detail}`}`);
+        if (progress.stopped !== null)
+            write(`Stopped at ${progress.stopped.step}: ${progress.stopped.message}`);
+        return 0;
+    }
+    finally {
+        store.close();
+    }
+}

package/dist/release.d.ts

@@ -48,6 +48,15 @@ export declare const REQUIRED_PR_CHECKS_WORKFLOW: Readonly<Record<typeof REQUIRE
 export declare const PROTECTION_REPORT_ONLY_CHECKS: readonly string[];
 /** The checks main's protection must require at minimum: every required check that isn't report-only. */
 export declare const PROTECTION_MINIMUM_CHECKS: readonly string[];
+/**
+ * Pull-request checks a release never waits for or fails on, by exact name and the workflow file that defines them:
+ * youiyoux's UI drift check (src/design/KIT.md), which fails a pull request that adds design drift but says nothing
+ * about whether a build is safe to release, and the scripted journeys on a pull request (journeys.yml,
+ * docs/plans/ci-speed.md item 4), advisory while they settle in CI: the release check runs every journey itself. Only a
+ * GitHub Actions run of that name from that workflow is left out; the same name from anywhere else is judged like any
+ * other check. Never a required check.
+ */
+export declare const ADVISORY_PR_CHECKS: Readonly<Record<string, string>>;
 /**
  * Main's protection as the plane's gh reads it (release-adapters.ts readMainProtection): `effective` only when one layer
  * (classic protection or one active ruleset) requires up-to-date branches, binds every PROTECTION_MINIMUM_CHECKS check to GitHub Actions,
@@ -393,6 +402,18 @@ export type AutoReleaseAdapter = {
 export type ReleaseAdapters = {
     /** One approval per release (release-once.md); absent on a plane that can't carry. */
     release?: ReleaseAuthorityAdapter;
+    /** Where each step's start, end and outcome are recorded (store.ts release_step, v146) for the Release view and
+     * `toolroll release status`. Best effort: a failure here never stops or changes the release. */
+    progress?: (entry: {
+        taskId: string;
+        tag: string;
+        version: string;
+        pr: number | null;
+        step: ReleaseStep;
+        state: "running" | "done" | "failed" | "waiting";
+        at: Date;
+        detail?: string | null;
+    }) => void;
     now(): Date;
     sleep(ms: number): Promise<void>;
     say(line: string): void;
@@ -731,4 +752,6 @@ export declare function checkFailedWords(input: {
 }): string;
 /** Whether GitHub's workflow-run `path` names exactly `file` (it may carry the ref it ran from, after an `@`). */
 export declare function workflowIs(path: string | null | undefined, file: string): boolean;
+/** How a person names this branch to `toolroll release` again. */
+export declare function releaseBranchArg(branch: string): string;
 export {};