toolroll 0.9.54 → 0.9.56

package/dist/evidence-pack.js

@@ -15,6 +15,7 @@ import { rulesWords } from "./approval-policy.js";
 import { assignmentOf } from "./assignment.js";
 import { projectName } from "./project.js";
 import { changedFilesOf } from "./result-completion.js";
+import { html, htmlString, joinHtml, styleElement } from "./html.js";
 export const EVIDENCE_PACK_FORMAT = "standing-orders/evidence-pack/v1";
 /** How to recheck one entry's seal, for whoever reads the JSON. */
 export const SEAL_RECIPE = 'hash = sha256(prev + "\\n" + JSON.stringify([id, at, actor, repo, taskId, runId, action, outcome, source, detail]))';
@@ -173,13 +174,12 @@ export function* ledgerExportChunks(store, range, scope, access, who, now, evide
     yield `],"truncated":${JSON.stringify({ entries: moreEntries, packs: morePacks })}}`;
 }
 // ---- The printable page -----------------------------------------------------
-const e = (value) => String(value ?? "").replace(/[&<>"']/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
-const when = (at) => at === null ? "—" : `${e(at.slice(0, 16).replace("T", " "))} UTC`;
-const short = (hash) => hash === null ? "—" : `<code title="${e(hash)}">${e(hash.slice(0, 12))}</code>`;
+const when = (at) => at === null ? html `—` : html `${at.slice(0, 16).replace("T", " ")} UTC`;
+const short = (hash) => hash === null ? html `—` : html `<code title="${hash}">${hash.slice(0, 12)}</code>`;
 const usd = (value) => value === null ? "—" : `$${value.toFixed(value < 1 ? 4 : 2)}`;
 /** Only a web address links; anything else (a stored value that isn't one) is shown as text. */
-const link = (url) => /^https:\/\/[^\s"'<>]+$/.test(url) ? `<a href="${e(url)}">${e(url)}</a>` : e(url);
-const filer = (who) => who === null || who.name === null ? "automation" : who.kind === "person" ? e(who.name) : `${e(who.name)} (${e(who.kind)})`;
+const link = (url) => /^https:\/\/[^\s"'<>]+$/.test(url) ? html `<a href="${url}">${url}</a>` : html `${url}`;
+const filer = (who) => who === null || who.name === null ? html `automation` : who.kind === "person" ? html `${who.name}` : html `${who.name} (${who.kind})`;
 export const EVIDENCE_PACK_CSS = `.evidence-pack{max-width:960px;min-width:0}.evidence-pack h1{margin:0}.evidence-pack h2{font-size:.9375rem;margin:24px 0 8px}.evidence-pack h3{font-size:.875rem;margin:16px 0 6px}` +
     `.evidence-head{display:flex;justify-content:space-between;gap:12px;flex-wrap:wrap;align-items:baseline}.evidence-pack dl{display:grid;grid-template-columns:minmax(120px,180px) minmax(0,1fr);gap:4px 16px;margin:0}` +
     `.evidence-pack dt{color:var(--muted-foreground);font-size:.8125rem}.evidence-pack dd{margin:0;min-width:0;overflow-wrap:anywhere}.evidence-pack table{width:100%;border-collapse:collapse;font-size:.8125rem}` +
@@ -193,66 +193,62 @@ export const EVIDENCE_PACK_CSS = `.evidence-pack{max-width:960px;min-width:0}.ev
 export function evidencePackHtml(pack) {
     const task = pack.task;
     const chain = pack.ledger.chain.ok
-        ? `<p class="evidence-chain ok" data-evidence-chain="ok"><strong>Ledger chain verified</strong> · ${pack.ledger.chain.entries} entries · head ${short(pack.ledger.chain.head)}${pack.ledger.chain.checkedAt === null ? "" : ` · checked in full ${when(pack.ledger.chain.checkedAt)}`}${pack.ledger.checkpoint === null ? "" : ` · last checkpoint at entry #${pack.ledger.checkpoint.through}`}</p>`
-        : `<p class="evidence-chain problem" role="alert" data-evidence-chain="broken"><strong>Ledger chain broken</strong> · ${e(pack.ledger.chain.problem)}</p>`;
+        ? html `<p class="evidence-chain ok" data-evidence-chain="ok"><strong>Ledger chain verified</strong> · ${pack.ledger.chain.entries} entries · head ${short(pack.ledger.chain.head)}${pack.ledger.chain.checkedAt === null ? "" : html ` · checked in full ${when(pack.ledger.chain.checkedAt)}`}${pack.ledger.checkpoint === null ? "" : html ` · last checkpoint at entry #${pack.ledger.checkpoint.through}`}</p>`
+        : html `<p class="evidence-chain problem" role="alert" data-evidence-chain="broken"><strong>Ledger chain broken</strong> · ${pack.ledger.chain.problem}</p>`;
     const versions = pack.versions.map((version, index) => {
         const scope = version.scope;
         const approved = scope?.approved ?? null;
         const approvals = scope === null ? [] : scope.approvals.filter(one => one.digest === (approved?.digest ?? scope.digest));
         const rows = [
-            ["Filed", `${when(version.filedAt)} by ${filer(version.filedBy)}`],
-            ...(scope === null ? [["Scope", "None written"]] : [
-                ["Goal", e(scope.goal)],
-                ...(scope.touches.length ? [["Touches", scope.touches.map(e).join(", ")]] : []),
-                ...(scope.acceptance.length ? [["Acceptance", `<ol class="criteria">${scope.acceptance.map(one => `<li>${e(one.statement)}</li>`).join("")}</ol>`]] : []),
-                ...(scope.writtenBy.length ? [["Scope written by", [...new Set(scope.writtenBy.map(one => one.author))].map(e).join(", ")]] : []),
-                ["Approved", approved === null ? "Not approved" : `${e(approved.by)}${approved.basis === "mode" ? " (operating mode)" : ""} · ${when(approved.at)}${approved.current ? "" : " · the scope changed after this"}`],
-                ...(approvals.length > 1 ? [["Approvals", approvals.map(one => `${e(one.approver)} · ${when(one.at)}`).join("<br>")]] : []),
+            ["Filed", html `${when(version.filedAt)} by ${filer(version.filedBy)}`],
+            ...(scope === null ? [["Scope", html `None written`]] : [
+                ["Goal", html `${scope.goal}`],
+                ...(scope.touches.length ? [["Touches", joinHtml(scope.touches, ", ")]] : []),
+                ...(scope.acceptance.length ? [["Acceptance", html `<ol class="criteria">${scope.acceptance.map(one => html `<li>${one.statement}</li>`)}</ol>`]] : []),
+                ...(scope.writtenBy.length ? [["Scope written by", joinHtml([...new Set(scope.writtenBy.map(one => one.author))], ", ")]] : []),
+                ["Approved", approved === null ? html `Not approved` : html `${approved.by}${approved.basis === "mode" ? " (operating mode)" : ""} · ${when(approved.at)}${approved.current ? "" : " · the scope changed after this"}`],
+                ...(approvals.length > 1 ? [["Approvals", joinHtml(approvals.map(one => html `${one.approver} · ${when(one.at)}`), html `<br>`)]] : []),
                 ["Scope digest", short(scope.digest)],
             ]),
         ];
-        const runs = version.runs.length === 0 ? `<p class="meta">No agent ran.</p>` :
-            `<div class="evidence-table"><table><thead><tr><th>Run</th><th>Role</th><th>Agent</th><th>Outcome</th><th>Cost</th><th>Finished</th><th>Commit</th></tr></thead><tbody>` +
-                version.runs.map(run => `<tr><td><a href="/r/${run.id}">#${run.id}</a></td><td>${e(run.role)}</td><td>${e(run.agent)}${run.model ? ` · ${e(run.model)}` : ""}</td><td>${e(run.outcome ?? "running")}</td><td>${usd(run.costUsd)}</td><td>${when(run.finishedAt)}</td><td>${short(run.head)}</td></tr>`).join("") +
-                `</tbody></table></div>`;
-        const changes = version.runs.filter(run => run.role === "builder" || run.role === "repair").map(run => `<p class="meta">Run #${run.id}${run.diff === null ? "" : ` · diff ${short(run.diff.sha256)}${run.diff.complete ? "" : " (partial)"}`}</p>` +
-            (run.changedFiles === null ? `<p class="meta">Its changed files couldn't be read.</p>` : run.changedFiles.length === 0 ? `<p class="meta">No files changed.</p>` : `<ul class="files">${run.changedFiles.map(file => `<li>${e(file)}</li>`).join("")}</ul>`)).join("");
-        return `<section data-evidence-version="${e(version.id)}"><h2>${pack.versions.length > 1 ? `${index === 0 ? "Request" : `Revision ${index}`} · ` : "Request and approval · "}${e(version.id)}</h2><dl>${rows.map(([label, value]) => `<dt>${label}</dt><dd>${value}</dd>`).join("")}</dl>` +
-            `<h3>Agents</h3>${runs}${changes === "" ? "" : `<h3>Changes</h3>${changes}`}</section>`;
-    }).join("");
+        const runs = version.runs.length === 0 ? html `<p class="meta">No agent ran.</p>` :
+            html `<div class="evidence-table"><table><thead><tr><th>Run</th><th>Role</th><th>Agent</th><th>Outcome</th><th>Cost</th><th>Finished</th><th>Commit</th></tr></thead><tbody>${version.runs.map(run => html `<tr><td><a href="/r/${run.id}">#${run.id}</a></td><td>${run.role}</td><td>${run.agent}${run.model ? html ` · ${run.model}` : ""}</td><td>${run.outcome ?? "running"}</td><td>${usd(run.costUsd)}</td><td>${when(run.finishedAt)}</td><td>${short(run.head)}</td></tr>`)}</tbody></table></div>`;
+        const changes = version.runs.filter(run => run.role === "builder" || run.role === "repair").map(run => html `<p class="meta">Run #${run.id}${run.diff === null ? "" : html ` · diff ${short(run.diff.sha256)}${run.diff.complete ? "" : " (partial)"}`}</p>${run.changedFiles === null ? html `<p class="meta">Its changed files couldn't be read.</p>` : run.changedFiles.length === 0 ? html `<p class="meta">No files changed.</p>` : html `<ul class="files">${run.changedFiles.map(file => html `<li>${file}</li>`)}</ul>`}`);
+        return html `<section data-evidence-version="${version.id}"><h2>${pack.versions.length > 1 ? `${index === 0 ? "Request" : `Revision ${index}`} · ` : "Request and approval · "}${version.id}</h2><dl>${rows.map(([label, value]) => html `<dt>${label}</dt><dd>${value}</dd>`)}</dl><h3>Agents</h3>${runs}${changes.length === 0 ? "" : html `<h3>Changes</h3>${changes}`}</section>`;
+    });
     const result = pack.result;
-    const outcome = result === null ? `<section><h2>Result</h2><p class="meta">No finished result yet.</p></section>` :
-        `<section data-evidence-result><h2>Result</h2><dl>` +
-            `<dt>Checks</dt><dd>${e(result.checks.detail)}${result.checks.command ? ` <code>${e(result.checks.command)}</code>` : ""}</dd>` +
-            `<dt>Marked complete</dt><dd>${result.completedBy === null ? "Not yet" : `${e(result.completedBy)} · ${when(result.completedAt)}`}</dd>` +
-            `<dt>Published</dt><dd>${result.publication === null ? "Not published" : `${e(result.publication.state)}${result.publication.prUrl ? ` · ${link(result.publication.prUrl)}` : ""}${result.publication.remoteState ? ` · ${e(result.publication.remoteState.toLowerCase())}` : ""}`}</dd>` +
-            `<dt>Commit</dt><dd>${short(result.base)} → ${short(result.head)}</dd>` +
-            (result.caveats.length ? `<dt>Caveats</dt><dd>${result.caveats.map(e).join("<br>")}</dd>` : "") +
-            `</dl></section>`;
+    const outcome = result === null ? html `<section><h2>Result</h2><p class="meta">No finished result yet.</p></section>` :
+        joinHtml([html `<section data-evidence-result><h2>Result</h2><dl>`,
+            html `<dt>Checks</dt><dd>${result.checks.detail}${result.checks.command ? html ` <code>${result.checks.command}</code>` : ""}</dd>`,
+            html `<dt>Marked complete</dt><dd>${result.completedBy === null ? "Not yet" : html `${result.completedBy} · ${when(result.completedAt)}`}</dd>`,
+            html `<dt>Published</dt><dd>${result.publication === null ? "Not published" : html `${result.publication.state}${result.publication.prUrl ? html ` · ${link(result.publication.prUrl)}` : ""}${result.publication.remoteState ? html ` · ${result.publication.remoteState.toLowerCase()}` : ""}`}</dd>`,
+            html `<dt>Commit</dt><dd>${short(result.base)} → ${short(result.head)}</dd>`,
+            result.caveats.length ? html `<dt>Caveats</dt><dd>${joinHtml(result.caveats, html `<br>`)}</dd>` : "",
+            html `</dl></section>`]);
     const decisions = pack.ledger.entries.filter(one => one.source !== "request");
     const requests = pack.ledger.entries.length - decisions.length;
     const askedWords = `${requests} ${requests === 1 ? "request" : "requests"} made through the console (accepted or refused)`;
-    const ledger = `<section><h2>Ledger</h2>${decisions.length === 0 ? `<p class="meta">No entries.</p>` :
-        `<div class="evidence-table"><table><thead><tr><th>#</th><th>Time</th><th>Who</th><th>What</th><th>Outcome</th><th>Seal</th></tr></thead><tbody>` +
-            decisions.map(one => `<tr data-ledger-id="${one.id}"><td>${one.id}</td><td>${when(one.at)}</td><td>${e(one.actor)}</td><td>${e(one.action)}${one.detail ? `<br><span class="meta">${e(one.detail)}</span>` : ""}</td><td>${e(one.outcome)}</td><td>${short(one.seal?.hash ?? null)}</td></tr>`).join("") +
-            `</tbody></table></div>`}${requests > 0 ? `<p class="meta">Plus ${askedWords}, listed in the JSON.</p>` : ""}${pack.ledger.truncated ? `<p class="meta">This pack holds ${decisions.length} of the task's entries and the newest ${requests} requests; the ledger export has the rest.</p>` : ""}</section>`;
+    const ledger = html `<section><h2>Ledger</h2>${decisions.length === 0 ? html `<p class="meta">No entries.</p>` :
+        html `<div class="evidence-table"><table><thead><tr><th>#</th><th>Time</th><th>Who</th><th>What</th><th>Outcome</th><th>Seal</th></tr></thead><tbody>${decisions.map(one => html `<tr data-ledger-id="${one.id}"><td>${one.id}</td><td>${when(one.at)}</td><td>${one.actor}</td><td>${one.action}${one.detail ? html `<br><span class="meta">${one.detail}</span>` : ""}</td><td>${one.outcome}</td><td>${short(one.seal?.hash ?? null)}</td></tr>`)}</tbody></table></div>`}${requests > 0 ? html `<p class="meta">Plus ${askedWords}, listed in the JSON.</p>` : ""}${pack.ledger.truncated ? html `<p class="meta">This pack holds ${decisions.length} of the task's entries and the newest ${requests} requests; the ledger export has the rest.</p>` : ""}</section>`;
     const cost = pack.totals.runs === 0 ? "None ran" : `${pack.totals.runs} ${pack.totals.runs === 1 ? "run" : "runs"} · ${usd(pack.totals.costUsd)}`;
     // The rules as they stand, and each change to them (the approval above was under whichever applied then).
-    const rules = pack.rules === null ? "None" : `${e(pack.rules.now)}${pack.rules.changes.length === 0 ? "" :
-        `<ul class="criteria">${pack.rules.changes.slice(-5).map(one => `<li class="meta">${when(one.at)} · ${e(one.by)}: ${e(one.change)}</li>`).join("")}</ul>`}`;
-    return `<article class="evidence-pack" data-evidence-pack="${e(task.id)}">` +
-        `<div class="evidence-head"><h1>Evidence pack</h1><p class="evidence-actions"><a href="/t/${encodeURIComponent(task.id)}/evidence?format=json" download>Download JSON</a> · <a href="/t/${encodeURIComponent(task.id)}">Back to task</a></p></div>` +
-        `<p><strong>${e(task.title)}</strong></p>` +
-        `<dl><dt>Task</dt><dd>${e(task.id)}${task.project === null ? "" : ` · ${e(task.project)}`} · ${e(task.state)}</dd>` +
-        `<dt>Approval rules</dt><dd>${rules}</dd><dt>Agents</dt><dd>${cost}</dd>` +
-        `<dt>Prepared</dt><dd>${when(pack.generatedAt)} for ${e(pack.generatedBy)}</dd></dl>${chain}` +
-        versions + outcome + ledger +
-        `<p class="evidence-foot">Pack digest <code>${e(pack.digest)}</code>. Each ledger entry's seal can be rechecked from the JSON: ${e(pack.ledger.recipe)}.</p></article>`;
+    const rules = pack.rules === null ? html `None` : html `${pack.rules.now}${pack.rules.changes.length === 0 ? "" :
+        html `<ul class="criteria">${pack.rules.changes.slice(-5).map(one => html `<li class="meta">${when(one.at)} · ${one.by}: ${one.change}</li>`)}</ul>`}`;
+    return joinHtml([html `<article class="evidence-pack" data-evidence-pack="${task.id}">`,
+        html `<div class="evidence-head"><h1>Evidence pack</h1><p class="evidence-actions"><a href="/t/${encodeURIComponent(task.id)}/evidence?format=json" download>Download JSON</a> · <a href="/t/${encodeURIComponent(task.id)}">Back to task</a></p></div>`,
+        html `<p><strong>${task.title}</strong></p>`,
+        html `<dl><dt>Task</dt><dd>${task.id}${task.project === null ? "" : ` · ${task.project}`} · ${task.state}</dd>`,
+        html `<dt>Approval rules</dt><dd>${rules}</dd><dt>Agents</dt><dd>${cost}</dd>`,
+        html `<dt>Prepared</dt><dd>${when(pack.generatedAt)} for ${pack.generatedBy}</dd></dl>${chain}`,
+        versions, outcome, ledger,
+        html `<p class="evidence-foot">Pack digest <code>${pack.digest}</code>. Each ledger entry's seal can be rechecked from the JSON: ${pack.ledger.recipe}.</p></article>`]);
 }
 /** The page as a file on its own (the CLI's --html): the same facts with just enough style to print. */
 export function standaloneEvidenceHtml(pack) {
-    return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>Evidence pack · ${e(pack.task.id)}</title>` +
-        `<style>:root{--muted-foreground:#5c5c5c;--border:#dedede;--success:#1a7f37;--font-mono:ui-monospace,SFMono-Regular,Menlo,monospace}` +
+    const css = `:root{--muted-foreground:#5c5c5c;--border:#dedede;--success:#1a7f37;--font-mono:ui-monospace,SFMono-Regular,Menlo,monospace}` +
         `body{font:14px/1.5 system-ui,-apple-system,sans-serif;margin:32px auto;padding:0 16px;max-width:960px;color:#171717;background:#fff}.meta{color:var(--muted-foreground);font-size:.8125rem}.evidence-actions{display:none}` +
-        EVIDENCE_PACK_CSS + `</style></head><body>${evidencePackHtml(pack)}</body></html>\n`;
+        EVIDENCE_PACK_CSS;
+    // The file is the sink: its bytes.
+    return htmlString(html `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>Evidence pack · ${pack.task.id}</title>${styleElement(css)}</head><body>${evidencePackHtml(pack)}</body></html>
+`);
 }

package/dist/export-ui.d.ts

@@ -1,4 +1,9 @@
+/**
+ * Settings → Data (v105): an instance operator downloads everything Standing
+ * Orders knows as one .zip. One form: the password, typed again, and a button.
+ */
+import { type Html } from "./html.js";
 export declare const EXPORT_CSS: string;
-export declare function dataExportHtml(csrf: string, notice: {
+export declare function dataExportHtml(notice: {
     problem?: string | null;
-}): string;
+}): Html;

package/dist/export-ui.js

@@ -2,16 +2,10 @@
  * Settings → Data (v105): an instance operator downloads everything Standing
  * Orders knows as one .zip. One form: the password, typed again, and a button.
  */
-const e = (value) => String(value ?? "").replace(/[&<>"']/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
+import { html, postForm } from "./html.js";
 export const EXPORT_CSS = `.data-export{max-width:720px;min-width:0}.data-export label{display:grid;gap:4px;margin:14px 0 0;font-size:.875rem}` +
     `.data-export input[type=password]{width:100%;max-width:360px;box-sizing:border-box}.data-export button[type=submit]{margin-top:14px;min-height:44px;white-space:nowrap}`;
-export function dataExportHtml(csrf, notice) {
-    const note = notice.problem ? `<p class="problem" role="alert">${e(notice.problem)}</p>` : "";
-    return `<section class="data-export">${note}` +
-        `<p>Everything Toolroll knows, as one .zip: projects, tasks, runs and cost, the action ledger, evidence packs, chats, flows, teammates and settings. ` +
-        `Passwords, keys and tokens are never included.</p>` +
-        `<form method="post" action="/settings/data"><input type="hidden" name="csrf" value="${e(csrf)}">` +
-        `<label>Your Toolroll password<input type="password" name="password" autocomplete="current-password" required></label>` +
-        `<button type="submit">Download export</button></form>` +
-        `<p class="meta">The same export from the command line: <code>toolroll export --out &lt;path&gt; [--zip]</code></p></section>`;
+export function dataExportHtml(notice) {
+    const note = notice.problem ? html `<p class="problem" role="alert">${notice.problem}</p>` : "";
+    return html `<section class="data-export">${note}<p>Everything Toolroll knows, as one .zip: projects, tasks, runs and cost, the action ledger, evidence packs, chats, flows, subagents and settings. Passwords, keys and tokens are never included.</p>${postForm("/settings/data", html `<label>Your Toolroll password<input type="password" name="password" autocomplete="current-password" required></label><button type="submit">Download export</button>`)}<p class="meta">The same export from the command line: <code>toolroll export --out &lt;path&gt; [--zip]</code></p></section>`;
 }

package/dist/export.js

@@ -2,7 +2,7 @@
  * Full export (v105): everything Toolroll knows, for an instance
  * operator to take away — every table of the database as JSON Lines, grouped
  * by what it's about (projects, tasks, runs, the ledger, chats, flows,
- * teammates, people, settings), an evidence pack per task, the settings kept
+ * subagents, people, settings), an evidence pack per task, the settings kept
  * in files beside the database, a README explaining the layout, and a
  * manifest with each file's SHA-256. One folder, or the same files in a .zip.
  *
@@ -35,14 +35,14 @@ const DERIVED_TABLE = /^(sqlite_|memory_search)/;
 const SECRET_COLUMNS = new Set([
     "api_token.secret_hash", "lead_credential.secret_hash", "approver.credential_hash", "coordinator_credential.credential_hash", "runner.credential_hash", "invite.token_hash",
     "flow_trigger.hook_hash", "push_subscription.endpoint", "push_subscription.p256dh", "push_subscription.auth",
-    "chat_turn.credential_key", "mate_session.credential_key", "mate_turn.credential_key", "chat_runtime.push_url", "workflow_preview.token",
+    "chat_turn.credential_key", "lead_session.credential_key", "mate_turn.credential_key", "chat_runtime.push_url", "workflow_preview.token",
     "quota.credential_fp", "oauth_grant.renew_hash", "oauth_client.source_hash",
 ]);
 /** A column named like this holds a secret unless it is reviewed below; an unreviewed one is dropped. */
 const SECRET_NAME = /hash|secret|token|passw|cookie|csrf|credential|p256dh|^auth$|key|nonce|endpoint|url/i;
 /** Reviewed: named like a secret, but it isn't one (a seal, a digest, a lookup name, an address with no key). */
 const REVIEWED_COLUMNS = new Set([
-    "artifact.key", "budget.scope_key", "mate_thread.scope_key", "diff_comment.source_key", "chat_meta.key",
+    "artifact.key", "budget.scope_key", "lead_thread.scope_key", "diff_comment.source_key", "chat_meta.key",
     "flow_trigger_event.key", "installation_fact.key", "mcp_idempotency.key", "memory_gap.key", "mutation.idempotency_key", "notification.dedupe_key",
     "service_cursor.key", "ledger_checkpoint.hash", "ledger_seal.hash", "merge_intent.grant_terms_hash", "plan_revision.parent_hash",
     "publication.body_hash", "publication.pr_url", "team_message.payload_hash", "team_request.payload_hash", "backend_grant.credential_scope",
@@ -53,9 +53,9 @@ const USAGE_COLUMN = /(^|_)tokens(_|$)|output_tokens/;
 export function categoryOf(table) {
     const rules = [
         [/^(action_ledger|ledger_seal|ledger_checkpoint|sync_ledger)$/, "ledger"],
-        [/^teammate/, "teammates"],
+        [/^subagent/, "subagents"],
         [/^(flow|workflow_)/, "flows"],
-        [/^(chat_|mate_|team_|notification|push_)/, "chats"],
+        [/^(chat_|lead_|team_|notification|push_)/, "chats"],
         [/^(approver|api_token|lead_credential|invite|sso_identity|coordinator_|oauth_)/, "people"],
         [/^(run|artifact|claim|worktree$|execution_slot|criterion_review|diff_comment|proof_|review_request|repair_chain|incident|publication$|merge_|side_spend|knowledge_snapshot|learning_snapshot|skill_snapshot)/, "runs"],
         [/^(task|hold$|plan_|scope_|tool_seal|decision|external_|skill_test)/, "tasks"],
@@ -214,9 +214,9 @@ Everything this installation knew on ${now.toISOString().slice(0, 16).replace("T
 - \`runs/\`: agent runs with usage and cost (\`run\`, \`run_spend\`), their records of artifacts, proofs, reviews and publications.
 - \`ledger/\`: the action ledger (\`action_ledger\`), each entry's seal (\`ledger_seal\`) and the checkpoints (\`ledger_checkpoint\`).
 - \`evidence-packs/\`: one JSON file per task: who asked, the exact terms and who approved them, runs and cost, checks, completion and its ledger entries.
-- \`chats/\`: conversations with the lead and teammates, and Telegram, Slack, Discord and Teams messages and notifications.
+- \`chats/\`: conversations with the lead and subagents, and Telegram, Slack, Discord and Teams messages and notifications.
 - \`flows/\`: flows, their cards, scripts and triggers (schedules included) and saved recipes.
-- \`teammates/\`: teammates, their versions, memory, tools and turns.
+- \`subagents/\`: subagents, their versions, memory, tools and turns.
 - \`people/\`: accounts, API token names and invitations (no passwords or tokens).
 - \`settings/\`: models, budgets, spend and permission defaults, provider readings; \`files.json\` holds the settings kept in files.
 - \`other/\`: everything else the database keeps (workers, leases, queues).

package/dist/flow-engine.d.ts

@@ -72,8 +72,8 @@ export declare function decideFlowCard(store: Store, input: {
     draft?: string | null;
     /** The visit the person saw (a chat button's): a card that moved on since is refused. */
     entry?: number;
-    /** v92: the AI teammate (by handle) deciding a zone it staffs; `actor` is then how it reads in history. */
-    teammate?: string;
+    /** v92: the subagent (by handle) deciding a zone it staffs; `actor` is then how it reads in history. */
+    subagent?: string;
     /** Where the decision was made, for its ledger line: "the console", "the command line", "Telegram". */
     where?: string;
 }, now: Date): FlowDecision;

package/dist/flow-engine.js

@@ -18,7 +18,7 @@ import { readVerifiedReport, scanForSecrets } from "./evidence.js";
 import { cardFollowers, notifyPeople } from "./flow-people.js";
 import { DRAFT_CHARS, keptDraft } from "./flow-draft.js";
 import { chooseStep, flowPersonOf, sendStep } from "./flow-send.js";
-import { parseSoul, teammateLabel } from "./teammates.js";
+import { parseSoul, subagentLabel } from "./subagents.js";
 import { withStageHandoff } from "./contracts/stage-output.js";
 /** The flow's drawing, or null when it can't be read (the card then says so and waits). */
 export function flowDefinitionOf(flow) {
@@ -42,15 +42,15 @@ function fill(template, card) {
 }
 const titleIn = (definition, id) => definition.stages.find(one => one.id === id)?.title ?? id;
 const flowDefinitionStage = (definition, id) => definition.stages.find(one => one.id === id);
-/** A teammate's name as its soul file gives it (its handle when the file can't be read). */
-function teammateName(mate) {
+/** A subagent's name as its soul file gives it (its handle when the file can't be read). */
+function subagentName(mate) {
     const read = parseSoul(mate.soul);
     return read.ok ? read.soul.name : mate.handle;
 }
-/** What a teammate said when it handed a card to its person, or why it couldn't decide. */
+/** What a subagent said when it handed a card to its person, or why it couldn't decide. */
 function handoffWords(mate, turn) {
     const read = parseSoul(mate.soul);
-    const label = read.ok ? teammateLabel(read.soul) : mate.handle;
+    const label = read.ok ? subagentLabel(read.soul) : mate.handle;
     let note = "";
     try {
         const decided = JSON.parse(turn.decisionJson ?? "{}");
@@ -187,20 +187,20 @@ function advanceCard(store, flow, definition, card, now, options, outcome) {
         case "approval": {
             const decider = deciderOf(stage, flow);
             const who = decider ?? "an approver";
-            // v92: a zone an active teammate staffs is its to decide first (the step pass runs it). A person hears
-            // about the card only when the teammate hands it over, can't decide, or is paused or gone.
-            // v102: on a protected project an AI teammate never decides; the person does.
-            const mate = stage.teammate === undefined || store.approvalRules(flow.repo).protectProject ? null : store.teammateByHandle(flow.repo, stage.teammate);
+            // v92: a zone an active subagent staffs is its to decide first (the step pass runs it). A person hears
+            // about the card only when the subagent hands it over, can't decide, or is paused or gone.
+            // v102: on a protected project a subagent never decides; the person does.
+            const mate = stage.subagent === undefined || store.approvalRules(flow.repo).protectProject ? null : store.subagentByHandle(flow.repo, stage.subagent);
             const turn = mate === null ? null : store.flowStepRun(card.id, card.entry);
-            const handed = turn !== null && turn.kind === "teammate" && (turn.state === "failed" || turn.state === "passed");
+            const handed = turn !== null && turn.kind === "subagent" && (turn.state === "failed" || turn.state === "passed");
             if (mate !== null && mate.state === "active" && !handed) {
-                const name = teammateName(mate);
+                const name = subagentName(mate);
                 if (card.waiting !== `${name} is deciding`)
                     store.updateFlowCard(card.id, { waiting: `${name} is deciding` }, now);
                 return;
             }
             const handoff = handed && mate !== null ? handoffWords(mate, turn) : null;
-            if (card.waiting === null || (mate !== null && card.waiting === `${teammateName(mate)} is deciding`)) {
+            if (card.waiting === null || (mate !== null && card.waiting === `${subagentName(mate)} is deciding`)) {
                 // A named decider hears it alone; "anyone who approves" pages everyone who can.
                 // With a draft in front of it, the decision carries the draft itself: it can be read (and answered) where it arrives.
                 const draft = draftFor(definition, stage);
@@ -447,8 +447,8 @@ export function cancelFlowCard(store, card, actor, now) {
 /** The draft a decision is about: the draft zone that sends its cards to this one. */
 export function draftFor(definition, stage) {
     return definition.stages.find(one => one.kind === "draft" && one.next === stage.id)
-        // A teammate's zone that leads here (by its next, or one of its answers) wrote the draft this decision checks (starter kits).
-        ?? definition.stages.find(one => one.kind === "teammate" && (one.next === stage.id || (one.routes ?? []).some(route => route.to === stage.id))) ?? null;
+        // A subagent's zone that leads here (by its next, or one of its answers) wrote the draft this decision checks (starter kits).
+        ?? definition.stages.find(one => one.kind === "subagent" && (one.next === stage.id || (one.routes ?? []).some(route => route.to === stage.id))) ?? null;
 }
 /** Back to a build zone with a finished result: a revision of that same work, carrying the note; null when it isn't one. */
 export function revisionWithNote(store, card, target, note, actor, repos, evidenceRoot, now) {
@@ -478,21 +478,21 @@ export function decideFlowCard(store, input, now) {
     const stage = definition.stages.find(one => one.id === card.stage);
     if (stage === undefined || stage.kind !== "approval" || (input.entry !== undefined && input.entry !== card.entry))
         return { ok: false, message: "That card has moved on since; nothing was changed." };
-    // A teammate decides only a zone it staffs; its person (and only them) can always decide instead.
+    // A subagent decides only a zone it staffs; its person (and only them) can always decide instead.
     const decider = deciderOf(stage, flow);
-    if (input.teammate !== undefined ? stage.teammate !== input.teammate : decider !== null && decider !== input.actor)
+    if (input.subagent !== undefined ? stage.subagent !== input.subagent : decider !== null && decider !== input.actor)
         return { ok: false, message: `Only ${decider ?? "an approver"} decides here.` };
-    // v102: a protected project's decisions are a person's, never an AI teammate's.
-    if (input.teammate !== undefined && store.approvalRules(flow.repo).protectProject)
+    // v102: a protected project's decisions are a person's, never a subagent's.
+    if (input.subagent !== undefined && store.approvalRules(flow.repo).protectProject)
         return { ok: false, message: "This project is protected: a person decides here." };
     // Every decision is one ledger line, the same wherever it was made; only `via` says where.
     const ledger = (outcome) => store.recordAction({ at: now.toISOString(), actor: input.actor, repo: flow.repo, taskId: card.primaryTask, runId: null,
-        action: "flow decision", outcome, source: "request", detail: `${flow.name} · card ${card.id} · ${stage.title}${input.teammate === undefined ? "" : ` · teammate ${input.teammate}`} · via ${input.where ?? "Toolroll"}` });
+        action: "flow decision", outcome, source: "request", detail: `${flow.name} · card ${card.id} · ${stage.title}${input.subagent === undefined ? "" : ` · subagent ${input.subagent}`} · via ${input.where ?? "Toolroll"}` });
     if (input.decision === "approve") {
         // An edited draft replaces the one Claude wrote, so the steps after this send what the person approved.
         const draft = draftFor(definition, stage);
-        // A person's edit over the draft limit is refused with it, never cut. (A teammate's was asked once to shorten and is kept whole.)
-        if (draft !== null && input.teammate === undefined && typeof input.draft === "string" && input.draft.trim().length > DRAFT_CHARS) {
+        // A person's edit over the draft limit is refused with it, never cut. (A subagent's was asked once to shorten and is kept whole.)
+        if (draft !== null && input.subagent === undefined && typeof input.draft === "string" && input.draft.trim().length > DRAFT_CHARS) {
             return { ok: false, message: `Keep the draft to ${DRAFT_CHARS.toLocaleString("en-US")} characters; this is ${input.draft.trim().length.toLocaleString("en-US")}.` };
         }
         if (draft !== null && typeof input.draft === "string" && input.draft.trim() !== "" && input.draft.trim() !== card.outputs[draft.id]?.trim()) {

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

@@ -1,11 +1,12 @@
 import { type GalleryAnswers, type GalleryPreview, type GalleryTemplate, type GalleryTool } from "./flow-gallery.js";
 import { type FlowDefinition, type FlowStage } from "./flows.js";
+import { type Html } from "./html.js";
 export declare const GALLERY_CSS: 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;
+export declare function stepStrip(definition: FlowDefinition): Html;
 /** 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;
@@ -14,7 +15,7 @@ export declare function galleryHtml(input: {
         id: string;
         state: "connected" | "open" | "taken";
     }[] | null;
-}): string;
+}): Html;
 /** A template's page: its questions, then what it will do and never do, then Create. */
 export declare function galleryUseHtml(input: {
     template: GalleryTemplate;
@@ -32,4 +33,4 @@ export declare function galleryUseHtml(input: {
     /** The template's tools in this project; `said` is how the last Connect went. */
     tools?: readonly GalleryTool[];
     said?: string | null;
-}): string;
+}): Html;

package/dist/flow-gallery-ui.js

@@ -7,7 +7,7 @@
 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]);
+import { html, joinHtml, postForm } from "./html.js";
 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}` +
@@ -53,30 +53,28 @@ export function mainPath(definition) {
 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>`;
+    return html `<ol class="gallery-steps" aria-label="Steps">${mainPath(definition).map((one, i) => {
+        const name = stepName(one);
+        return html `<li>${i === 0 ? "" : html `<span aria-hidden="true">→</span>`}${one.kind === "choose" || one.kind === "approval" ? html `<b data-person>${name}</b>` : name}</li>`;
+    })}</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>`;
+const needsList = (template) => template.needs.length === 0 ? (template.tools ?? []).length > 0 ? "" : html `<ul class="gallery-needs"><li>Nothing to connect</li></ul>`
+    : html `<ul class="gallery-needs" aria-label="Needs">${template.needs.map(one => html `<li>${one}</li>`)}</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 toolState = (tool) => tool.state === null ? "" : html `<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>`;
+    : html `<ul class="gallery-tools" aria-label="Tools">${tools.map(one => html `<li data-tool="${one.id}" data-state="${one.state ?? "unknown"}">${toolMark(one)}<strong>${one.label}</strong>${toolState(one)}</li>`)}</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>` +
-            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>`;
+        return html `<article class="gallery-card" data-template="${template.id}"><h3>${template.name}</h3><p class="gallery-promise">${template.promise}</p>${stepStrip(definition)}${toolsList(galleryToolsOf(template, definition, input.repo === null ? null : input.connections ?? null))}${needsList(template)}${input.canUse && html `<a class="button-link" href="${href(template.id)}" aria-label="Use ${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("");
-    return `<section class="gallery">${groups}${input.canUse ? `<p class="gallery-blank meta"><a href="${e(href(BLANK.id))}">Start from a blank flow</a></p>` : `<p class="meta">An approver creates flows.</p>`}</section>`;
+    const groups = GALLERY_GROUPS.map(group => html `<h2 id="gallery-${group.id}">${group.label}</h2><div class="gallery-grid" data-group="${group.id}">${GALLERY.filter(one => one.group === group.id).map(card)}</div>`);
+    return html `<section class="gallery">${groups}${input.canUse ? html `<p class="gallery-blank meta"><a href="${href(BLANK.id)}">Start from a blank flow</a></p>` : html `<p class="meta">An approver creates flows.</p>`}</section>`;
 }
 /** A template's page: its questions, then what it will do and never do, then Create. */
 export function galleryUseHtml(input) {
@@ -86,43 +84,30 @@ export function galleryUseHtml(input) {
     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>`;
+        const head = html `<p class="gallery-tool-head">${toolMark(tool)} <strong>${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>`;
+            return html `<div class="gallery-connect" data-tool="${tool.id}" data-state="${String(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>`;
+        return html `<div class="gallery-connect" data-tool="${tool.id}" data-state="open">${head}${postForm("/settings/tools/connect", html `<p class="meta">${how}</p><label>Your Toolroll password<input type="password" name="password" autocomplete="current-password" required></label><button name="service" value="${tool.id}">Connect ${tool.label}</button>`, { hidden: { repo: input.repo, shown: input.repo, template: template.id } })}</div>`;
     };
-    const toolsBlock = tools.length === 0 ? "" : `<section class="gallery-tools-use" aria-label="Tools">${tools.map(connect).join("")}</section>`;
+    const toolsBlock = tools.length === 0 ? "" : html `<section class="gallery-tools-use" aria-label="Tools">${tools.map(connect)}</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 zones = (tool) => joinHtml(tool.zones.map(zone => html `“${zone}”`), " and ");
+    const needing = html `${missing.filter(one => one.zones.length > 0).map(one => html `<p class="meta" data-needs-tool="${one.id}">${zones(one)} need${one.zones.length === 1 ? "s" : ""} ${one.label}, which isn't connected.</p>`)}${tools.filter(one => one.state === "taken" && one.zones.length > 0).map(one => html `<p class="meta" data-tool-taken="${one.id}">${zones(one)} use${one.zones.length === 1 ? "s" : ""} ${one.label}, added another way.</p>`)}`;
     const field = (ask) => {
         const value = input.answers[ask.key] ?? ask.default;
-        const hint = ask.hint === undefined ? "" : ` <small>${e(ask.hint)}</small>`;
+        const hint = ask.hint === undefined ? "" : html ` <small>${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 : ask.key === "team" ? 12 : 100}"${ask.key === "command" ? ' spellcheck="false" autocapitalize="off"' : ask.key === "team" ? ' spellcheck="false" autocapitalize="characters"' : ""}></label>`;
+            return html `<label>${ask.label}<select name="outdated">${Object.entries(OUTDATED_COMMANDS).map(([id, one]) => html `<option value="${id}"${id === value && html ` selected`}>${one.label}</option>`)}</select></label>`;
+        return html `<label>${ask.label}${hint}<input name="${ask.key}" value="${value}" required maxlength="${ask.key === "command" ? 500 : ask.key === "team" ? 12 : 100}"${ask.key === "command" ? html ` spellcheck="false" autocapitalize="off"` : ask.key === "team" ? html ` 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>${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>`) + (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>` +
-        (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>`;
+        ? html `<label>Project<select name="repo">${input.projects.map(one => html `<option value="${one.path}"${one.path === input.repo && html ` selected`}>${one.name}</option>`)}</select></label>`
+        : html `<input type="hidden" name="repo" value="${input.repo}">`;
+    const preview = input.preview === null ? "" : html `<section class="gallery-preview" aria-labelledby="gallery-will"><h2 id="gallery-will">What it will do</h2><ul>${input.preview.built.does.map(one => html `<li>${one}</li>`)}</ul><p class="gallery-never">${input.preview.built.never}</p>${needing}${input.preview.startsFrom.length === 0 ? html `<p class="meta">Cards start when you add them.</p>` : input.preview.startsFrom.map(one => html `<p class="meta">Starts from: ${one}</p>`)}<details><summary>Every step</summary><ol>${input.preview.steps.map(one => html `<li>${one.replace(/^\d+\.\s/, "")}</li>`)}</ol></details></section>`;
+    const sendResult = !sendsAlready(template) && html `<label class="gallery-check"><input type="checkbox" name="${SEND_RESULT.key}" value="yes"${input.answers[SEND_RESULT.key] === "yes" && html ` checked`} data-send-result><span>${SEND_RESULT.title}<small>When a card finishes, what was done comes to you in your chat apps.</small></span></label>`;
+    const actions = html `<p class="gallery-actions">${input.preview !== null && html `<button type="submit" name="intent" value="create"${missing.length > 0 && html ` 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>`;
+    const form = postForm(`/flows/new/${template.id}`, html `${project}${template.asks.map(field)}<label>Name<input name="name" value="${input.name}" maxlength="80"></label>${sendResult}${preview}${actions}`, { attrs: { "data-gallery-use": true }, hidden: { previewed: input.preview?.digest ?? "" } });
+    return html `<section class="gallery-use" data-gallery-template="${template.id}">${input.problem !== null && html `<p class="problem" role="alert">${input.problem}</p>`}${input.said ? html `<p role="status">${input.said}</p>` : ""}<p>${template.promise}</p>${input.diagram !== null && stepStrip(input.diagram)}${needsList(template)}${toolsBlock}${form}<p class="meta"><a href="/flows/new">All templates</a></p></section>`;
 }

package/dist/flow-insights.d.ts

@@ -58,7 +58,7 @@ export type StepRunInsight = {
     entry: number;
     zone: string;
     zoneTitle: string;
-    kind: "check" | "update" | "sort" | "draft" | "request" | "email" | "tool" | "teammate";
+    kind: "check" | "update" | "sort" | "draft" | "request" | "email" | "tool" | "subagent";
     script: string | null;
     version: number | null;
     state: FlowStepRunRow["state"];