toolroll 0.9.0 → 0.9.2

package/CHANGELOG.md

@@ -2,6 +2,52 @@
 
 ## Unreleased
 
+## 0.9.2 — 2026-10-01
+
+- **Flows from a terminal.** `toolroll flows` lists and shows flows (zones
+  with their next and failure paths, triggers, recent cards) and sets them
+  up under the console's own rules: `create` from a template, a starter flow
+  or the lead's step format, `edit`, `trigger add|pause|resume|remove|check`,
+  `script save`, `card add` and `archive`. Writes take an approver's
+  password (`--as/--token` or the remembered login) and land in the ledger;
+  create, edit, archive and trigger add preview until `--yes`. It is in
+  `contract --commands` and `skills get operating`.
+- **Toolroll reviews its own last day, every morning.** A new plane review
+  trigger reads the last 24 hours from the store at 07:30 and makes one card
+  per problem worth fixing — failed runs by cause, tasks waiting on a person,
+  sign-in and plan-limit pauses, chat delivery failures, Broken integrations,
+  failed release checks and worker breakages — with counts, run ids and
+  redacted excerpts. A problem that comes back joins its card; a clean day
+  adds nothing. The **Morning plane review** starter (Settings → Flows, or
+  `toolroll onboard --starter plane-review`) researches each one, builds a fix
+  under the usual approvals and opens a pull request; failures wait in
+  **Needs a look**. Flow insights show which problems recur.
+- **Flows that test Toolroll.** `scripts/flows/real-model-journeys.mjs` runs
+  the journeys that use real models (unit tests and CI never do), retrying a
+  failure once before calling it real, and `scripts/flows/weekly-upkeep.mjs`
+  reports outdated or vulnerable dependencies and new agent CLI versions.
+  Both run in a flow's check zone. A Toolroll started inside the agents'
+  fence now runs its agents inside that outer fence instead of failing to
+  nest a second one.
+
+## 0.9.1 — 2026-09-30
+
+- **Phones show more on a screen.** On a phone the console is about a third
+  denser: a row's action sits on its title line, status chips beside the
+  name, facts on one line, and times shorten to "16:39", "Yesterday 16:39"
+  or "Sep 28" (the full time stays on desktop and on hover). Every tap target
+  is still at least 44px and text fields 16px; nothing scrolls sideways at
+  320px, and the desktop layout is unchanged.
+- **Flows open pull requests, and starter flows are one yes away.** A new
+  Pull request zone opens a PR for a card's built result under the project's
+  pull request setup, waits for CI, moves on when it passes and takes the
+  failure path (naming the failing check) when it fails; it can merge, squash
+  by default, only after a person approved the card. The Issues to PRs
+  template runs labelled GitHub issues through build, approval, pull request
+  and a closing comment. Settings → Flows and `toolroll onboard --starter`
+  switch on Fix failing CI, Issues become tasks and Overnight queue; a task's
+  "Do this every time…" and chat offer the matching one.
+
 ## 0.9.0 — 2026-09-30
 
 - **Chat pings only when you're needed.** In Telegram, Slack, Discord and

package/dist/agent-fence.d.ts

@@ -27,8 +27,17 @@ export declare function claudeFenceSettings(fence: readonly string[]): string;
 /** A Seatbelt profile that allows everything except reading or writing the fenced paths. */
 export declare function macosFenceProfile(fence: readonly string[]): string;
 export declare const SANDBOX_EXEC = "/usr/bin/sandbox-exec";
-/** Whether this machine can run an agent inside the macOS fence. */
-export declare function macosFenceAvailable(platform?: NodeJS.Platform): boolean;
+/**
+ * Whether this machine can run an agent inside the macOS fence (checked once). Not from inside another
+ * sandbox: a Toolroll a fenced process starts (the end-to-end journeys a flow's check zone runs) can't nest
+ * its fence, and would otherwise fail every launch. Its agents stay inside the outer fence, which every
+ * child inherits, and are recorded with the fence they actually got. Any other probe failure keeps the
+ * fence on, so a launch fails loudly rather than running unfenced.
+ */
+export declare function macosFenceAvailable(platform?: NodeJS.Platform, probe?: () => {
+    status: number | null;
+    stderr: string;
+}): boolean;
 /** The spawn that runs `file args` inside the macOS fence (same process: sandbox-exec replaces itself with the agent). */
 export declare function macosFenced(file: string, args: readonly string[], fence: readonly string[]): {
     file: string;

package/dist/agent-fence.js

@@ -144,9 +144,35 @@ export function macosFenceProfile(fence) {
     return ["(version 1)", "(allow default)", `(deny file-read* file-write* ${fence.map(path => `(subpath ${seatbelt(path)})`).join(" ")})`].join("\n");
 }
 export const SANDBOX_EXEC = "/usr/bin/sandbox-exec";
-/** Whether this machine can run an agent inside the macOS fence. */
-export function macosFenceAvailable(platform = process.platform) {
-    return platform === "darwin" && existsSync(SANDBOX_EXEC);
+/** A process already inside a Seatbelt sandbox (an agent's, or a flow check zone's) can't apply another: sandbox-exec says so. */
+const NESTED_SANDBOX = /sandbox_apply: Operation not permitted/;
+let seatbeltWorks = null;
+/**
+ * Whether this machine can run an agent inside the macOS fence (checked once). Not from inside another
+ * sandbox: a Toolroll a fenced process starts (the end-to-end journeys a flow's check zone runs) can't nest
+ * its fence, and would otherwise fail every launch. Its agents stay inside the outer fence, which every
+ * child inherits, and are recorded with the fence they actually got. Any other probe failure keeps the
+ * fence on, so a launch fails loudly rather than running unfenced.
+ */
+export function macosFenceAvailable(platform = process.platform, probe) {
+    if (platform !== "darwin" || !existsSync(SANDBOX_EXEC))
+        return false;
+    const works = (check) => {
+        try {
+            const ran = check();
+            return !(ran.status !== 0 && NESTED_SANDBOX.test(ran.stderr));
+        }
+        catch {
+            return true;
+        }
+    };
+    if (probe !== undefined)
+        return works(probe);
+    seatbeltWorks ??= works(() => {
+        const ran = spawnSync(SANDBOX_EXEC, ["-p", "(version 1)(allow default)", "/usr/bin/true"], { timeout: 5_000, encoding: "utf8" });
+        return { status: ran.status, stderr: ran.stderr ?? "" };
+    });
+    return seatbeltWorks;
 }
 /** The spawn that runs `file args` inside the macOS fence (same process: sandbox-exec replaces itself with the agent). */
 export function macosFenced(file, args, fence) {

package/dist/agent-onboard.d.ts

@@ -8,13 +8,16 @@
  * without running it, and ends with a handoff the agent can relay.
  *
  * Adding the project and writing the skill both need --yes or one yes
- * typed at a terminal. The project is the main checkout (never a linked
+ * typed at a terminal. Then it offers the starter flows (flow-starters.ts),
+ * each switched on by its own yes at a terminal or by --starter; --yes alone
+ * never switches one on. The project is the main checkout (never a linked
  * worktree, the home folder, or one of Toolroll's own worktrees). The skill
  * is replaced by the next onboard and deleted by `onboard --remove` only
  * while it is exactly a version Toolroll wrote; a file of the same name
  * that is not ours, or ours with the person's edits, is never touched.
  */
 import type { ProviderConnection } from "./provider-connection.js";
+import type { StarterView, SwitchedOn } from "./flow-starters.js";
 export type OnboardAgent = "claude" | "codex";
 export declare const ONBOARD_AGENTS: readonly OnboardAgent[];
 export declare const AGENT_NAMES: Record<OnboardAgent, string>;
@@ -122,6 +125,23 @@ export type OnboardIo = {
     /** Whether the project can open pull requests at Complete, in one line: on, the one command that turns it on, or
      * what to fix first. Turning it on stays a person's password step. */
     pullRequests?: (repo: string) => Promise<string>;
+    /** --starter, as typed: a comma list of starter flow ids to switch on. */
+    starterFlag?: string | undefined;
+    /** The project's starter flows, and switching one on — its trigger and zones. */
+    starters?: {
+        list: (repo: string) => Promise<StarterView[]>;
+        switchOn: (repo: string, id: string) => Promise<SwitchedOn>;
+    };
+};
+export type StarterAnswer = {
+    id: string;
+    name: string;
+    summary: string;
+    does: string[];
+    never: string;
+    state: "on" | "switched-on" | "off" | "unavailable" | "failed";
+    flow?: number;
+    said?: string;
 };
 /** Why a found repository cannot be the project, or null when it can. */
 export declare function projectRefusal(found: {

package/dist/agent-onboard.js

@@ -8,7 +8,9 @@
  * without running it, and ends with a handoff the agent can relay.
  *
  * Adding the project and writing the skill both need --yes or one yes
- * typed at a terminal. The project is the main checkout (never a linked
+ * typed at a terminal. Then it offers the starter flows (flow-starters.ts),
+ * each switched on by its own yes at a terminal or by --starter; --yes alone
+ * never switches one on. The project is the main checkout (never a linked
  * worktree, the home folder, or one of Toolroll's own worktrees). The skill
  * is replaced by the next onboard and deleted by `onboard --remove` only
  * while it is exactly a version Toolroll wrote; a file of the same name
@@ -215,6 +217,48 @@ export function loginAccount(file) {
 export function agentReport(agent, connection) {
     return { agent, name: AGENT_NAMES[agent], state: connection.state, words: connectionWords(connection), ...(connection.plan === undefined ? {} : { plan: connection.plan }) };
 }
+/** Offer each starter flow: switch on the ones --starter names, or ask one yes each at a terminal. */
+async function offerStarters(io, repo) {
+    if (io.starters === undefined)
+        return [];
+    const list = await io.starters.list(repo);
+    const named = io.starterFlag === undefined ? null : io.starterFlag.split(",").map(one => one.trim()).filter(one => one !== "");
+    const unknown = named?.filter(one => !list.some(starter => starter.id === one)) ?? [];
+    if (named !== null && (named.length === 0 || unknown.length > 0))
+        return { usage: `--starter takes ${list.map(one => one.id).join(", ")}` };
+    const answers = [];
+    for (const one of list) {
+        const base = { id: one.id, name: one.name, summary: one.summary, does: one.does, never: one.never };
+        if (one.on !== null) {
+            answers.push({ ...base, state: "on", flow: one.on.flow });
+            continue;
+        }
+        if (one.blocked !== null) {
+            answers.push({ ...base, state: "unavailable", said: one.blocked });
+            continue;
+        }
+        const wanted = named !== null ? named.includes(one.id) : io.interactive && !io.json && await io.confirm(`Switch on ${one.name}? ${one.summary} ${one.never} [y/N]`);
+        if (!wanted) {
+            answers.push({ ...base, state: "off" });
+            continue;
+        }
+        const switched = await io.starters.switchOn(repo, one.id);
+        answers.push(switched.ok ? { ...base, state: switched.already ? "on" : "switched-on", flow: switched.flow } : { ...base, state: "failed", said: switched.said });
+    }
+    return answers;
+}
+function starterLines(answers) {
+    return answers.map((one, index) => {
+        const head = index === 0 ? "starters " : "         ";
+        switch (one.state) {
+            case "on": return `${head} ${one.name}: on`;
+            case "switched-on": return `${head} ${one.name}: switched on`;
+            case "unavailable": return `${head} ${one.name}: ${one.said}`;
+            case "failed": return `${head} ${one.name}: ${one.said}`;
+            case "off": return `${head} ${one.name}: ${one.summary} ${one.never} Switch on: toolroll onboard --starter ${one.id}`;
+        }
+    });
+}
 const real = (path) => {
     try {
         return realpathSync(path);
@@ -334,6 +378,9 @@ export async function runOnboard(io) {
     const mcp = agents.map(agent => ({ agent, command: mcpLine(agent) }));
     const projectData = project.state === "added" || project.state === "already" ? { path: project.path, added: project.state === "added" } : null;
     const pullRequests = projectData === null || io.pullRequests === undefined ? null : await io.pullRequests(projectData.path);
+    const offered = projectData === null ? [] : await offerStarters(io, projectData.path);
+    if (!Array.isArray(offered))
+        return refuse("usage", offered.usage, 2);
     const projectProblem = (() => {
         switch (project.state) {
             case "none": return "not inside a git repository";
@@ -351,6 +398,7 @@ export async function runOnboard(io) {
             project: projectData,
             ...(projectProblem === null ? {} : { projectProblem }),
             ...(pullRequests === null ? {} : { pullRequests }),
+            ...(offered.length === 0 ? {} : { starters: offered.map(one => ({ ...one, ...(one.state === "off" ? { command: `toolroll onboard --starter ${one.id}` } : {}) })) }),
             agents: reports,
             skill: skillData,
             mcp,
@@ -364,6 +412,7 @@ export async function runOnboard(io) {
     io.write([
         projectLine,
         ...(pullRequests === null ? [] : [`pull requests ${pullRequests}`]),
+        ...starterLines(offered),
         `agents    ${reports.map(one => `${one.name}: ${[one.words, one.plan].filter(Boolean).join(" · ")}`).join("; ")}`,
         skillLine(),
         ...mcp.map((one, index) => `${index === 0 ? "tools    " : "         "} ${one.command}   (add Toolroll as tools; not run)`),

package/dist/backup-ui.js

@@ -1,9 +1,11 @@
 import { bytesWords } from "./storage.js";
+import { whenUtc } from "./when-html.js";
 /** The schedules on offer and the most copies kept. Here rather than in backup.ts so the page never loads `node:sqlite`. */
 export const BACKUP_EVERY_HOURS = [1, 6, 12, 24];
 export const MAX_KEEP = 100;
 const e = (value) => String(value ?? "").replace(/[&<>"']/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
-const when = (at) => `${e(at.slice(0, 16).replace("T", " "))} UTC`;
+const when = (at) => whenUtc(at);
+const whenWords = (at) => `${at.slice(0, 16).replace("T", " ")} UTC`;
 const everyWords = (hours) => hours === 1 ? "Every hour" : hours === 24 ? "Every day" : `Every ${hours} hours`;
 const fileName = (path) => path.slice(path.lastIndexOf("/") + 1);
 export const BACKUP_CSS = `.backups{max-width:720px;min-width:0;overflow-wrap:anywhere}.backups .backup-state{display:flex;gap:16px;align-items:flex-start;justify-content:space-between;flex-wrap:wrap}` +
@@ -22,7 +24,7 @@ function state(view) {
     const good = view.runs.find(one => one.ok === true);
     const next = !view.settings.enabled ? "Scheduled backups are off."
         : good === undefined ? "The first scheduled backup runs within a minute or two of the console starting."
-            : `Next one about ${when(new Date(Date.parse(good.startedAt) + view.settings.everyHours * 3_600_000).toISOString())}.`;
+            : `Next one about ${whenWords(new Date(Date.parse(good.startedAt) + view.settings.everyHours * 3_600_000).toISOString())}.`;
     if (last === undefined)
         return `<h2>No backups yet</h2><p class="meta">${e(next)}</p>`;
     if (last.ok === null)