toolroll 0.9.91 → 0.9.93

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Changelog
 
+## 0.9.93 — 2026-11-06
+
+- **Approve a release with one tap.** When a release is ready for your yes,
+  your phone gets one notification ("A release is ready for your approval")
+  that opens a single screen: what changed since the last release, the
+  GitHub checks, the full terms, and one **Approve release** button. Approve
+  and walk away: it deploys only after everything passes, and you hear back
+  only if something fails. In the terminal, `toolroll release approve` finds
+  the release itself — no task names or codes to copy.
+- **No more "Confirm it stopped".** When a finished build's process record
+  is incomplete, Toolroll now checks the computer itself, stops anything left
+  over that it can prove is that build's, and carries on. The task says
+  "Making sure build #N stopped. This clears on its own." Releases wait
+  through it instead of stopping.
+- **Checks record what they saw.** Each finished check now keeps an advisory
+  record of the exact code, conditions and failures, groundwork for a list
+  of flaky tests and for lessons from fixed failures. It never changes a
+  check's result.
+
+## 0.9.92 — 2026-11-05
+
+- **Toolroll learns which cheaper models do the job.** Every task now gets a
+  result record (see it on the task page, or run `toolroll models results`).
+  Once a cheaper model has done well on a project's small or routine tasks,
+  Settings → Models suggests it, with the evidence. Accepting needs your
+  password and only affects that project's eligible tasks; if the cheaper
+  model then does badly, Toolroll switches back on its own and tells you.
+  Approvals show a line saying why a model was picked. Also in the terminal:
+  `toolroll models suggestions`, `accept`, `dismiss`, `turn-off`.
+- **Try a cheaper model on the next 10 tasks.** When a cheaper model has no
+  track record yet, Settings → Models offers a trial. Each trial task says
+  "trial 3 of 10" and must be approved by a person; Stop ends it any time
+  (`toolroll models try` / `stop`).
+- **See what it saved.** The Spend page and `toolroll spend` show cost per
+  task before and after each rule or trial — observed, not a promise, and
+  only once there are enough priced results.
+- **Project memory is changed by a person only.** A personal API token used
+  from the remote CLI could record or retire project decisions without a
+  password; now it can't, and neither can the lead. Reading memory works as
+  before.
+
 ## 0.9.91 — 2026-11-04
 
 - **A deploy checks your HTTPS console before it changes anything.** If the

package/dist/approval-authority.d.ts

@@ -1,7 +1,15 @@
 /** SQL over a `task_scope` alias and a repo expression: whether that row's approval authority stands at `now` (an SQL
  * expression, used exactly three times: the mode and grant clauses, and the release's expiry). It never asks whether the row is approved.
  * COALESCE: a NULL basis would make the OR chain NULL, and NOT NULL reads as "not dead"; NULL stands on nothing. */
-export declare const authorityStandsSql: (scope: string, repo: string, now: string) => string;
+export declare function authorityStandsSql(scope: string, repo: string, now: string): string;
+/**
+ * SQL, conjunctive with every alternative above (results routing slice 3): a task whose sealed route tries a cheaper
+ * model (its build leg's selection is a trial) stands only on a PERSON's own yes to these exact bytes — the ceremony
+ * (`password`) or their paired-chat tap (`chat`), with that person's proof at the seal's instant, and no machine's.
+ * A mode, a grant, a schedule, a carry, an automatic seal or the lead never stand for one, whatever else allows them.
+ * The route is matched as text, so a route that can't be read as JSON is held to it too (fail closed).
+ */
+export declare function trialSealStandsSql(scope: string): string;
 /**
  * SQL, conjunctive with every alternative above (easy-start plan C5): a seal a local owner gave (its proof row at the
  * seal's instant says `local-owner`) stands only while local mode is on, for that owner, at the local generation its

package/dist/approval-authority.js

@@ -20,7 +20,8 @@ const PERSON_PROOFS = "('password-now', 'sso-now', 'fresh-password', 'fresh-sso'
 /** SQL over a `task_scope` alias and a repo expression: whether that row's approval authority stands at `now` (an SQL
  * expression, used exactly three times: the mode and grant clauses, and the release's expiry). It never asks whether the row is approved.
  * COALESCE: a NULL basis would make the OR chain NULL, and NOT NULL reads as "not dead"; NULL stands on nothing. */
-export const authorityStandsSql = (scope, repo, now) => `COALESCE((((COALESCE(${scope}.approval_basis, '') IN ('password', 'chat') AND NOT ${machineSealSql(scope)}
+export function authorityStandsSql(scope, repo, now) {
+    return `COALESCE((((COALESCE(${scope}.approval_basis, '') IN ('password', 'chat') AND NOT ${machineSealSql(scope)}
         AND (${personSealSql(scope)} OR NOT ${automationSql(scope)} OR ${approverStandsSql(scope, repo)}))
     OR (${scope}.approval_basis = 'carried' AND ${carrySealSql(scope)})
     OR (${scope}.approval_basis = 'mode' AND EXISTS (SELECT 1 FROM operating_mode om
@@ -30,7 +31,19 @@ export const authorityStandsSql = (scope, repo, now) => `COALESCE((((COALESCE(${
     OR (${scope}.approval_basis = 'grant' AND ${grantStandsSql(`${scope}.mode_digest`, now, repo)})
     OR (${scope}.approval_basis = 'schedule' AND ${approverStandsSql(scope, repo)})
     OR (${scope}.approval_basis IN ('auto-check', 'auto-green') AND ${autoSealSql(scope, repo)} AND ${approverStandsSql(scope, repo)}))
-    AND ${releaseStandsSql(scope, now)} AND ${localSealStandsSql(scope, repo)}), 0)`;
+    AND ${releaseStandsSql(scope, now)} AND ${localSealStandsSql(scope, repo)}
+    AND (instr(COALESCE(${scope}.approved_route_json, ''), '"trial"') = 0 OR ${trialSealStandsSql(scope)})), 0)`;
+}
+/**
+ * SQL, conjunctive with every alternative above (results routing slice 3): a task whose sealed route tries a cheaper
+ * model (its build leg's selection is a trial) stands only on a PERSON's own yes to these exact bytes — the ceremony
+ * (`password`) or their paired-chat tap (`chat`), with that person's proof at the seal's instant, and no machine's.
+ * A mode, a grant, a schedule, a carry, an automatic seal or the lead never stand for one, whatever else allows them.
+ * The route is matched as text, so a route that can't be read as JSON is held to it too (fail closed).
+ */
+export function trialSealStandsSql(scope) {
+    return `(COALESCE(${scope}.approval_basis, '') IN ('password', 'chat') AND NOT ${machineSealSql(scope)} AND ${personSealSql(scope)})`;
+}
 /**
  * SQL, conjunctive with every alternative above (easy-start plan C5): a seal a local owner gave (its proof row at the
  * seal's instant says `local-owner`) stands only while local mode is on, for that owner, at the local generation its

package/dist/assignment-status.d.ts

@@ -23,7 +23,7 @@ export declare function assignmentStatusBrief(assignment: AssignmentSnapshot): {
     } | null;
     runId: number | null;
     primaryAction: {
-        code: "answer-agent" | "confirm-stopped" | "inspect-decisions" | "inspect-run" | "inspect-stop" | "inspect-task" | "open-pr" | "reconcile-run" | "sign-in" | import("./dispatch.js").DispatchAction;
+        code: "answer-agent" | "inspect-decisions" | "inspect-run" | "inspect-stop" | "inspect-task" | "open-pr" | "recheck-stopped" | "reconcile-run" | "sign-in" | import("./dispatch.js").DispatchAction;
         label: string;
         target: import("./work-summary.js").WorkTarget;
     } | null;

package/dist/assignment-ui.js

@@ -31,8 +31,8 @@ export function assignmentActionHref(assignment) {
     if (action.code === 'sign-in')
         return '/settings/agents#providers';
     // The confirmation sits on the task page, behind the password.
-    if (action.code === 'confirm-stopped')
-        return `/t/${encodeURIComponent(assignment.rootId)}#confirm-stopped`;
+    if (action.code === 'recheck-stopped')
+        return `/t/${encodeURIComponent(assignment.rootId)}#recheck-stopped`;
     if (action.code === 'open-pr' && /^https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/pull\/\d+$/.test(assignment.publication?.prUrl ?? ''))
         return assignment.publication.prUrl;
     if (runId !== null && (action.code === 'open-result' || action.code === 'open-pr' || action.code === 'retry-review')) {

package/dist/assignment.js

@@ -252,13 +252,14 @@ export function assignmentOf(store, taskId, now, access, root, memo) {
             : { code: "inspect-task", label: `Open ${successor}`, target: { taskId: successor, runId: null, decisionId: null }, access: "read", retry: "read-again" };
     }
     else if (!live && processFact !== null && result !== null) {
-        // Toolroll can't confirm the build stopped. A person confirms it when
-        // nothing of it may still run; otherwise the work waits, needing no one.
+        // Toolroll hasn't yet proven the build stopped. It proves that itself
+        // (stop-proof.ts), so the work waits, needing no one; only when this
+        // computer can't look is it held, offering Check again — never a vouch.
         const process = processNeedOf(processFact);
         if ("need" in process) {
             state = "needs-decision";
             detail = NEEDS[process.need].sentence({ build: process.build });
-            primaryAction = { code: "confirm-stopped", label: NEEDS[process.need].action.label, target: { taskId: current.id, runId: process.build, decisionId: null },
+            primaryAction = { code: "recheck-stopped", label: NEEDS[process.need].action.label, target: { taskId: current.id, runId: process.build, decisionId: null },
                 access: access.principal === "operator" ? "operator-control" : "operator-handoff", retry: "refresh-before-acting" };
             need = { key: process.need, build: process.build };
         }
@@ -480,6 +481,11 @@ function acknowledgeCurrent(store, current, receiptDigest, actor, now, root, acc
     // The nightly check of main is a check only (release-once.md, part 3): nobody completes it.
     if (store.handle.prepare("SELECT 1 AS hit FROM nightly_check WHERE task = ?").get(current.receipt.taskId) !== undefined)
         return { ok: false, reason: "check-only", message: "The nightly check of main is only a check; it isn't completed." };
+    // Toolroll is still proving its build stopped (stop-proof.ts): a wait that clears on its own, said as one, so a
+    // release waits for it instead of stopping.
+    if (current.state !== "ready-to-check" && current.state !== "complete" && current.need != null && "wait" in current.need && STOP_WAITS.has(current.need.wait)) {
+        return { ok: false, reason: "stopping", message: `Toolroll is still making sure ${current.need.build === null ? "the build" : `build #${current.need.build}`} stopped. This clears on its own.` };
+    }
     if (current.state !== "ready-to-check" && current.state !== "complete")
         return { ok: false, reason: "not-ready", message: "This assignment still has unresolved execution, scope or decisions." };
     // A release task completes only while its release approval stands for it (release-once.md, liveReleaseOf).
@@ -674,3 +680,5 @@ export function assignmentUpdates(store, now, access, query, root) {
     });
     return { events, nextCursor: page.length === 0 ? after : Number(page.at(-1)["id"]), hasMore: rows.length > limit };
 }
+/** The waits of a build Toolroll is still proving stopped by itself (needs-you.ts processNeedOf). */
+const STOP_WAITS = new Set(["build-finishing", "build-checking", "build-stopping"]);