toolroll 0.5.0

package/dist/models-cli.js

@@ -0,0 +1,66 @@
+/** `toolroll models …`: what each CLI can run, whether the CLIs are
+ * current, and the automatic check. The same saved catalog as Settings → Models. */
+import { envelopeJson } from "./envelope.js";
+import { checkModels, isNewModel, modelOptions, priceWords, RUNTIME_TOOLS, runtimeStates, seenModels, setWatch, updateRuntime, watchState } from "./model-catalog.js";
+import { isProviderId } from "./provider.js";
+const flags = [
+    { name: "provider", takesValue: true, meaning: "claude, codex, gemini or openrouter, for models list" },
+    { name: "json", takesValue: false, meaning: "versioned structured response" },
+    { name: "db", takesValue: true, meaning: "local Toolroll database" },
+];
+export const MODELS_DESCRIPTORS = [
+    { action: "status", synopsis: "installed CLI versions, available updates, new models and the automatic check", mutation: "none", takesQuery: false, flags },
+    { action: "list", synopsis: "models a provider can run, newest first, with prices (--provider claude|codex|gemini|openrouter)", mutation: "none", takesQuery: false, flags },
+    { action: "check", synopsis: "fetch the public model lists and check CLI versions now", mutation: "unkeyed", takesQuery: false, flags },
+    { action: "update", synopsis: "update one CLI while no work is running: models update claude|codex|gemini", mutation: "unkeyed", takesQuery: true, flags },
+    { action: "watch", synopsis: "turn the 6-hourly check and its messages on or off: models watch on|off", mutation: "unkeyed", takesQuery: true, flags },
+];
+export async function runModelsCommand(positional, options, context) {
+    const action = positional[0] ?? "status";
+    const command = `models ${action}`;
+    const fail = (reason, message) => { context.write(context.json ? envelopeJson({ ok: false, command, reason, message }) : message); return reason === "usage" ? 2 : 1; };
+    const ok = (result, lines) => { context.write(context.json ? envelopeJson({ ok: true, command, ...result }) : lines.join("\n")); return 0; };
+    if (!MODELS_DESCRIPTORS.some(one => one.action === action))
+        return fail("usage", "Use models status | list --provider <p> | check | update <claude|codex|gemini> | watch on|off.");
+    if (context.actor === null)
+        return fail("unauthenticated", "Sign in first: the remembered local login drives models commands.");
+    const { store, now } = context;
+    if (action === "status") {
+        const runtimes = runtimeStates(store), watch = watchState(store);
+        const fresh = ["claude", "codex", "gemini"].flatMap(source => seenModels(store, source)).filter(model => isNewModel(model, now));
+        return ok({ runtimes, watch, newModels: fresh }, [
+            ...(runtimes.length === 0 ? ["No CLI versions checked yet. Run: toolroll models check"] : runtimes.map(one => `${one.name} ${one.installed ?? "?"}${one.behind ? ` · ${one.latest} available${one.updateCommand === null ? "" : ` (toolroll models update ${one.tool})`}` : " · up to date"}`)),
+            ...fresh.map(model => `New: ${model.name} · ${priceWords(model)}`),
+            `Automatic checks: ${watch.enabled ? "on" : "off"} · last checked ${watch.checkedAt ?? "never"}`,
+        ]);
+    }
+    if (action === "list") {
+        const provider = options.get("provider");
+        if (typeof provider !== "string" || !isProviderId(provider))
+            return fail("usage", "Use --provider claude, codex, gemini or openrouter.");
+        const models = modelOptions(store, provider, now);
+        return ok({ provider, models }, models.length === 0 ? ["No models saved yet. Run: toolroll models check"] : models.map(one => `${one.value}  ${one.label}`));
+    }
+    if (action === "check") {
+        const checked = await checkModels(store, now, context.seams);
+        const notable = checked.added.filter(one => one.source !== "openrouter");
+        if (!checked.ok)
+            return fail("refused", checked.problem ?? "The model lists could not be fetched.");
+        return ok({ added: notable, runtimes: checked.runtimes }, [
+            notable.length === 0 ? "No new models." : `New: ${notable.map(one => one.name).join(", ")}`,
+            ...checked.runtimes.filter(one => one.behind).map(one => `${one.name} ${one.latest} is available (you have ${one.installed}).`),
+        ]);
+    }
+    if (action === "update") {
+        const tool = positional[1] ?? "";
+        if (!(tool in RUNTIME_TOOLS))
+            return fail("usage", "Name one CLI: models update claude|codex|gemini.");
+        const updated = await updateRuntime(store, tool, context.actor, now, context.seams);
+        return updated.ok ? ok({ tool, message: updated.message }, [updated.message]) : fail("refused", updated.message);
+    }
+    const wanted = positional[1];
+    if (wanted !== "on" && wanted !== "off")
+        return fail("usage", "Use models watch on or models watch off.");
+    setWatch(store, wanted === "on", context.actor, now);
+    return ok({ enabled: wanted === "on" }, [wanted === "on" ? "Automatic checks are on: every 6 hours, with a message for each new model or CLI update." : "Automatic checks are off."]);
+}

package/dist/models-ui.d.ts

@@ -0,0 +1,34 @@
+/** Settings → Models: the CLIs on this computer, the default agent for each
+ * role picked from live lists, and the models that just arrived. */
+import type { ModelOption, RuntimeState, SeenModel, WatchState } from "./model-catalog.js";
+export declare const MODELS_CSS = ".models{max-width:780px;min-width:0;overflow-wrap:anywhere}.models .card{padding:16px 20px;margin:12px 0;min-width:0}.models h2{margin:24px 0 8px}.models form{margin:0}.models label{display:grid;gap:6px}.models select,.models input[type=search]{box-sizing:border-box;width:100%;max-width:100%;min-width:0}.models button,.models summary,.models .button-link{min-height:44px}.models button{white-space:nowrap}.models summary{padding:12px 0;cursor:pointer}.models .tool{display:flex;gap:12px;align-items:center;justify-content:space-between;flex-wrap:wrap}.models .role{display:grid;grid-template-columns:minmax(0,1fr);gap:8px}.models .role-row{display:flex;gap:12px;align-items:end;flex-wrap:wrap}.models .role-row select{flex:1 1 240px;width:auto;min-width:0}.models .role-name{font-weight:600}.models .new{font-weight:600}.models ul{padding-left:20px}.models .meta{font-size:.86rem}@media(max-width:600px){.models .card{padding:14px}}";
+export type RoleView = {
+    phase: "plan" | "build" | "review" | "repair";
+    label: string;
+    /** "provider|model", or "inherit" for a repair that follows the builder. */
+    current: string;
+    words: string;
+    groups: {
+        label: string;
+        provider: string;
+        options: ModelOption[];
+    }[];
+    /** Repair only: offer "Same as the builder". */
+    inherit?: boolean;
+};
+export type ModelsView = {
+    runtimes: RuntimeState[];
+    watch: WatchState;
+    roles: RoleView[];
+    chat: {
+        words: string;
+    } | null;
+    fresh: SeenModel[];
+    csrf: string;
+    canManage: boolean;
+    said: string | null;
+    problem: string | null;
+};
+export declare function modelsHtml(view: ModelsView): string;
+/** Filters one long picker as you type; the saved choice always stays listed. */
+export declare function modelsScript(): string;

package/dist/models-ui.js

@@ -0,0 +1,68 @@
+import { priceWords } from "./model-catalog.js";
+const e = (s) => String(s ?? "").replace(/[&<>"']/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
+const hidden = (data) => Object.entries(data).map(([k, v]) => `<input type="hidden" name="${e(k)}" value="${e(v)}">`).join("");
+const when = (iso) => iso === null ? "never" : `${iso.slice(0, 16).replace("T", " ")} UTC`;
+export const MODELS_CSS = `.models{max-width:780px;min-width:0;overflow-wrap:anywhere}.models .card{padding:16px 20px;margin:12px 0;min-width:0}.models h2{margin:24px 0 8px}.models form{margin:0}.models label{display:grid;gap:6px}.models select,.models input[type=search]{box-sizing:border-box;width:100%;max-width:100%;min-width:0}.models button,.models summary,.models .button-link{min-height:44px}.models button{white-space:nowrap}.models summary{padding:12px 0;cursor:pointer}.models .tool{display:flex;gap:12px;align-items:center;justify-content:space-between;flex-wrap:wrap}.models .role{display:grid;grid-template-columns:minmax(0,1fr);gap:8px}.models .role-row{display:flex;gap:12px;align-items:end;flex-wrap:wrap}.models .role-row select{flex:1 1 240px;width:auto;min-width:0}.models .role-name{font-weight:600}.models .new{font-weight:600}.models ul{padding-left:20px}.models .meta{font-size:.86rem}@media(max-width:600px){.models .card{padding:14px}}`;
+function toolRow(one, manage, csrf) {
+    const state = one.installed === null ? "Version unknown"
+        : one.behind ? `${e(one.installed)} · <strong>${e(one.latest)} available</strong>`
+            : `${e(one.installed)} · Up to date`;
+    const action = manage && one.behind && one.updateCommand !== null
+        ? `<form method="post" action="/settings/models/update">${hidden({ csrf, tool: one.tool })}<button type="submit">Update ${e(one.name)}</button></form>`
+        : one.behind ? `<span class="meta">Update it the way you installed it</span>` : "";
+    return `<div class="card tool"><span><strong>${e(one.name)}</strong> ${state}${one.problem === null ? "" : `<br><span class="meta">${e(one.problem)}</span>`}</span>${action}</div>`;
+}
+function roleForm(role, manage, csrf) {
+    if (!manage)
+        return `<div class="card role"><strong>${e(role.label)}</strong><span>${e(role.words)}</span></div>`;
+    const known = role.groups.some(group => group.options.some(option => `${group.provider}|${option.value}` === role.current));
+    const saved = !known && role.current !== "inherit" && role.current !== "" ? `<option value="${e(role.current)}" selected>${e(role.words)} · current</option>` : "";
+    const groups = role.groups.map(group => `<optgroup label="${e(group.label)}">${group.options.map(option => {
+        const value = `${group.provider}|${option.value}`;
+        return `<option value="${e(value)}"${value === role.current ? " selected" : ""}>${e(option.label)}</option>`;
+    }).join("")}</optgroup>`).join("");
+    const inherit = role.inherit ? `<option value="inherit"${role.current === "inherit" ? " selected" : ""}>Same as the builder</option>` : "";
+    const long = role.groups.reduce((sum, group) => sum + group.options.length, 0) > 40;
+    const count = role.groups.reduce((sum, group) => sum + group.options.length, 0);
+    const id = `role-${role.phase}`;
+    return `<form method="post" action="/settings/models/agent" class="card role">${hidden({ csrf, phase: role.phase })}` +
+        `<label class="role-name" for="${id}">${e(role.label)}</label>` +
+        (long ? `<input type="search" data-model-filter hidden aria-label="Search ${e(role.label.toLowerCase())} models" placeholder="Search ${count} models" autocomplete="off">` : "") +
+        `<div class="role-row"><select id="${id}" name="agent">${inherit}${saved}${groups}</select><button type="submit" class="secondary">Save</button></div></form>`;
+}
+export function modelsHtml(view) {
+    const manage = view.canManage && view.csrf !== "";
+    const status = view.said === null ? "" : `<p role="status">${e(view.said)}</p>`;
+    const problem = view.problem === null ? "" : `<p class="problem" role="alert">${e(view.problem)}</p>`;
+    const tools = view.runtimes.length === 0
+        ? `<p class="meta">No Claude, Codex or Gemini CLI found on this computer yet.</p>`
+        : view.runtimes.map(one => toolRow(one, manage, view.csrf)).join("");
+    const check = manage
+        ? `<form method="post" action="/settings/models/check" class="inline">${hidden({ csrf: view.csrf })}<button type="submit" class="secondary">Check now</button></form>`
+        : "";
+    const fresh = view.fresh.length === 0 ? "" :
+        `<h2>New models</h2><ul>${view.fresh.map(model => `<li><span class="new">${e(model.name)}</span> <span class="meta">${e(priceWords(model))}${model.releasedAt === null ? "" : ` · released ${e(model.releasedAt.slice(0, 10))}`}</span></li>`).join("")}</ul>`;
+    const watch = manage
+        ? `<details><summary>Automatic checks · ${view.watch.enabled ? "On" : "Off"}</summary><form method="post" action="/settings/models/watch">${hidden({ csrf: view.csrf, enabled: view.watch.enabled ? "0" : "1" })}` +
+            `<p>Check every 6 hours and send a message when a new model or CLI update appears. It uses public lists and sends nothing about you or your projects.</p>` +
+            `<button type="submit" class="secondary">${view.watch.enabled ? "Turn off" : "Turn on"}</button></form></details>`
+        : "";
+    return `<section class="models">${status}${problem}` +
+        `<h2>AI tools</h2>${tools}<p class="meta">Checked ${e(when(view.watch.checkedAt))} ${check}</p>` +
+        fresh +
+        `<h2>Default agents</h2><p class="meta">New tasks use these. Approved tasks keep the agents they were approved with.</p>` +
+        view.roles.map(role => roleForm(role, manage, view.csrf)).join("") +
+        (view.chat === null ? "" : `<h2>Chat</h2><p>${e(view.chat.words)} · <a href="/chat?settings=1#chat-settings">Change</a></p>`) +
+        watch + `</section>`;
+}
+/** Filters one long picker as you type; the saved choice always stays listed. */
+export function modelsScript() {
+    return `(function(){document.querySelectorAll('.models form.role').forEach(function(form){
+    var search=form.querySelector('[data-model-filter]'),select=form.querySelector('select');
+    if(!search||!select)return;search.hidden=false;
+    var groups=Array.from(select.querySelectorAll('optgroup')).map(function(g){return{g:g,options:Array.from(g.children)}});
+    search.addEventListener('input',function(){var q=search.value.trim().toLowerCase(),chosen=select.value;
+      groups.forEach(function(entry){entry.g.replaceChildren();entry.options.forEach(function(o){if(!q||o.value===chosen||(o.textContent+' '+o.value).toLowerCase().includes(q))entry.g.appendChild(o)})});
+      select.value=chosen;});
+  })})();`;
+}

package/dist/modes.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Operating modes (v29, the modes chain v1–v7): a per-repository,
+ * password-signed, expiring envelope that pre-authorizes the SIGNER'S OWN
+ * future acts. The absence of a mode is 'locked' — every act keeps its
+ * own ceremony, today's world, the default forever.
+ *
+ * The doctrine (v4 ruling): RAISING authority is a password ceremony;
+ * LOWERING it is one click for any approver; on revocation or expiry
+ * every mode-derived flow falls back to the human ceremony at its next
+ * gate, and running work is never fenced.
+ *
+ * This module owns the terms shape, the digest, and the words. The store
+ * owns the transactions; the tick owns the rails; serve owns the
+ * ceremony screens.
+ */
+export type ModeName = "standard" | "hands-off";
+export type ModeTerms = {
+    name: ModeName;
+    /** The filing default per provider (C7 matrix): "safe" = auto /
+     * auto_edit; "escalated" = bypassPermissions / yolo. Codex-shaped
+     * providers have one posture and the ceremony words say escalation
+     * changes nothing for them. */
+    permissionDefault: "safe" | "escalated";
+    /** Auto-approve the SIGNER'S OWN credentialed filings (C1's predicate
+     * and road table). */
+    autoApproveFiling: boolean;
+    /** Explicit opt-in: a verified planner may approve a plan that preserves
+     * the signer's pre-authorized filed contract and execution terms exactly. */
+    planAuto: boolean;
+    /** Attended mint without the per-mint password — signer only (D8). */
+    quickMint: boolean;
+    /** Historical signed field; new modes leave it false and no worker consumes it. */
+    reviewAuto: boolean;
+    /** Historical signed retry term, retained for digest and audit compatibility. */
+    reviewRetryAuto: boolean;
+    /** Stamped into filings that name no budget of their own. */
+    perAttemptBudgetMicrousd: number | null;
+    /** SOFT rail: new admissions stop once the day's MEASURED spend has
+     * reached this; running work may finish past it (D4). */
+    dailyMeasuredCapMicrousd: number | null;
+    /** HARD rail: reservation-counted admissions per UTC day, covering
+     * unmeasured providers too (D4). */
+    dailyRunCap: number | null;
+    /** "notify" = merges wait for a human even under a merge grant;
+     * "automerge" = the mode's signature substitutes for the per-merge
+     * human authorization, through the grant machinery only (D1/E1). */
+    publication: "notify" | "automerge";
+    /** Whether this mode AUTHORIZES automatic PAID fallback (a
+     * subscription->api-key or api-key->api-key switch that spends). v30,
+     * fallback chains R8: legacy modes default FALSE — a paid substitution
+     * must be an explicit, freshly-signed grant. A subscription->subscription
+     * fallback is not "paid" and needs no grant. */
+    allowPaidFallback: boolean;
+    /** Whether this mode AUTHORIZES the bounded repair loop to draft AND
+     * auto-approve its own repair attempts (v40, evidence-review-v1) — the
+     * allowPaidFallback precedent, verbatim: legacy modes default FALSE, a
+     * new authority is never inherited, only freshly signed. Without it, a
+     * short/refuted run with named unresolved criteria still gets exactly
+     * one drafted repair — it simply waits unapproved. */
+    repairAuto: boolean;
+    /** The signed cap on repair attempts per chain (0..3), counted over the
+     * chain rooted at the original task. Meaningless (read as 0) unless
+     * `repairAuto` is also true — a mode may sign a cap without signing the
+     * authority, but never the reverse. */
+    repairMaxAttempts: number;
+    absoluteExpiry: string;
+};
+export declare const MODE_MAX_DAYS = 7;
+/** The presets are STARTING POINTS the ceremony renders in full — the
+ * signature always covers the resolved terms, never a label. */
+export declare function presetTerms(name: ModeName, absoluteExpiry: string): ModeTerms;
+export declare function modeTermsJson(terms: ModeTerms): string;
+/** sha256 over a domain-separated canonical encoding, 32 hex like every
+ * other safety digest here. */
+export declare function modeDigestOf(terms: ModeTerms): string;
+/** Strict rehydration — anything unexpected is null, never a guess. */
+export declare function modeTermsFromJson(json: string | null): ModeTerms | null;
+/** Every term in words — what the ceremony renders and the password
+ * signs. The reversal sentence is verbatim from the chain (C1). */
+export declare function modeWords(terms: ModeTerms): string[];

package/dist/modes.js

@@ -0,0 +1,182 @@
+/**
+ * Operating modes (v29, the modes chain v1–v7): a per-repository,
+ * password-signed, expiring envelope that pre-authorizes the SIGNER'S OWN
+ * future acts. The absence of a mode is 'locked' — every act keeps its
+ * own ceremony, today's world, the default forever.
+ *
+ * The doctrine (v4 ruling): RAISING authority is a password ceremony;
+ * LOWERING it is one click for any approver; on revocation or expiry
+ * every mode-derived flow falls back to the human ceremony at its next
+ * gate, and running work is never fenced.
+ *
+ * This module owns the terms shape, the digest, and the words. The store
+ * owns the transactions; the tick owns the rails; serve owns the
+ * ceremony screens.
+ */
+import { createHash } from "node:crypto";
+export const MODE_MAX_DAYS = 7;
+/** The presets are STARTING POINTS the ceremony renders in full — the
+ * signature always covers the resolved terms, never a label. */
+export function presetTerms(name, absoluteExpiry) {
+    return name === "standard"
+        ? {
+            name,
+            permissionDefault: "safe",
+            autoApproveFiling: false,
+            planAuto: false,
+            quickMint: true,
+            reviewAuto: false,
+            reviewRetryAuto: false,
+            perAttemptBudgetMicrousd: null,
+            dailyMeasuredCapMicrousd: null,
+            dailyRunCap: null,
+            publication: "notify",
+            allowPaidFallback: false,
+            repairAuto: false,
+            repairMaxAttempts: 0,
+            absoluteExpiry,
+        }
+        : {
+            name,
+            permissionDefault: "escalated",
+            autoApproveFiling: true,
+            planAuto: false,
+            quickMint: true,
+            reviewAuto: false,
+            reviewRetryAuto: false,
+            perAttemptBudgetMicrousd: null,
+            dailyMeasuredCapMicrousd: null,
+            dailyRunCap: null,
+            publication: "notify",
+            allowPaidFallback: false,
+            repairAuto: false,
+            repairMaxAttempts: 0,
+            absoluteExpiry,
+        };
+}
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (value !== null && typeof value === "object") {
+        const entries = Object.entries(value)
+            .filter(([, v]) => v !== undefined)
+            .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+            .map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`);
+        return `{${entries.join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+export function modeTermsJson(terms) {
+    return canonicalJson(terms);
+}
+/** sha256 over a domain-separated canonical encoding, 32 hex like every
+ * other safety digest here. */
+export function modeDigestOf(terms) {
+    return createHash("sha256")
+        .update(`standing-orders:mode:${modeTermsJson(terms)}`, "utf8")
+        .digest("hex")
+        .slice(0, 32);
+}
+/** Strict rehydration — anything unexpected is null, never a guess. */
+export function modeTermsFromJson(json) {
+    if (json === null)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch {
+        return null;
+    }
+    if (parsed === null || typeof parsed !== "object")
+        return null;
+    const t = parsed;
+    const optMoney = (v) => v === null ? null : typeof v === "number" && Number.isInteger(v) && v > 0 ? v : undefined;
+    const budget = optMoney(t["perAttemptBudgetMicrousd"]);
+    const measured = optMoney(t["dailyMeasuredCapMicrousd"]);
+    const runs = optMoney(t["dailyRunCap"]);
+    if ((t["name"] === "standard" || t["name"] === "hands-off") &&
+        (t["permissionDefault"] === "safe" || t["permissionDefault"] === "escalated") &&
+        typeof t["autoApproveFiling"] === "boolean" &&
+        (t["planAuto"] === undefined || typeof t["planAuto"] === "boolean") &&
+        typeof t["quickMint"] === "boolean" &&
+        typeof t["reviewAuto"] === "boolean" &&
+        (t["reviewRetryAuto"] === undefined || typeof t["reviewRetryAuto"] === "boolean") &&
+        budget !== undefined &&
+        measured !== undefined &&
+        runs !== undefined &&
+        (t["publication"] === "notify" || t["publication"] === "automerge") &&
+        // allowPaidFallback: a legacy mode has NO such field — that MUST read
+        // as false (R8: a paid substitution is only ever an explicit,
+        // freshly-signed grant). A present value must be a strict boolean;
+        // anything else is a bad envelope, null.
+        (t["allowPaidFallback"] === undefined || typeof t["allowPaidFallback"] === "boolean") &&
+        // repairAuto/repairMaxAttempts: the SAME precedent, verbatim (v40). A
+        // legacy mode has NO such fields — that MUST read as false/0, never
+        // inherited. A present repairAuto must be a strict boolean; a present
+        // repairMaxAttempts must be an integer 0..3. Anything else is a bad
+        // envelope, null.
+        (t["repairAuto"] === undefined || typeof t["repairAuto"] === "boolean") &&
+        (t["repairMaxAttempts"] === undefined ||
+            (typeof t["repairMaxAttempts"] === "number" && Number.isInteger(t["repairMaxAttempts"]) && t["repairMaxAttempts"] >= 0 && t["repairMaxAttempts"] <= 3)) &&
+        typeof t["absoluteExpiry"] === "string" &&
+        !Number.isNaN(Date.parse(t["absoluteExpiry"]))) {
+        return {
+            name: t["name"],
+            permissionDefault: t["permissionDefault"],
+            autoApproveFiling: t["autoApproveFiling"],
+            planAuto: t["planAuto"] === true,
+            quickMint: t["quickMint"],
+            reviewAuto: t["reviewAuto"],
+            reviewRetryAuto: t["reviewRetryAuto"] === true,
+            perAttemptBudgetMicrousd: budget,
+            dailyMeasuredCapMicrousd: measured,
+            dailyRunCap: runs,
+            publication: t["publication"],
+            allowPaidFallback: t["allowPaidFallback"] === true,
+            repairAuto: t["repairAuto"] === true,
+            repairMaxAttempts: typeof t["repairMaxAttempts"] === "number" ? t["repairMaxAttempts"] : 0,
+            absoluteExpiry: t["absoluteExpiry"],
+        };
+    }
+    return null;
+}
+/** Every term in words — what the ceremony renders and the password
+ * signs. The reversal sentence is verbatim from the chain (C1). */
+export function modeWords(terms) {
+    return [
+        terms.permissionDefault === "escalated"
+            ? "new filings default to FULL permissions: claude runs with --dangerously-skip-permissions, gemini with --approval-mode yolo (codex-shaped lanes have one posture; this changes nothing for them)"
+            : "new filings use safe unattended permissions: routine project commands and edits proceed; risky acts stop for approval",
+        terms.autoApproveFiling
+            ? "every scope YOU file — signed-in console or credentialed CLI — is approved the moment you file it; while this mode is active, your signed-in browser session becomes a spend credential for this repository"
+            : "filings still wait for their own approval ceremony",
+        terms.quickMint
+            ? "you start watched sessions without re-typing your password — the confirm screen still shows every term"
+            : "watched sessions keep the per-session password",
+        terms.planAuto
+            ? "plans for your pre-authorized filings auto-approve only when the goal, exclusions, paths, acceptance criteria, risk, budget, and agent route remain exactly unchanged; provide a goal, paths and acceptance criteria upfront; amendments and unresolved questions still wait for you"
+            : "planner-generated plans wait for your approval",
+        "finished work and saved checks go to the lead or user; no separate model review runs",
+        ...(terms.reviewAuto || terms.reviewRetryAuto
+            ? ["historical review grants are retained on record but no longer schedule work"] : []),
+        terms.perAttemptBudgetMicrousd === null
+            ? "filings carry no default dollar cap"
+            : `filings that name no budget get a $${(terms.perAttemptBudgetMicrousd / 1_000_000).toFixed(2)} per-attempt cap`,
+        terms.dailyMeasuredCapMicrousd === null
+            ? "no daily dollar rail"
+            : `new admissions stop once the day's MEASURED spend reaches $${(terms.dailyMeasuredCapMicrousd / 1_000_000).toFixed(2)} — running work may finish past it, and unmeasured providers ride outside this number`,
+        terms.dailyRunCap === null
+            ? "no daily run rail"
+            : `at most ${terms.dailyRunCap} agent starts per UTC day, every provider counted, reserved at admission`,
+        terms.publication === "automerge"
+            ? "pull requests merge THEMSELVES when CI is seen green on the exact commit — you are told afterwards (requires a merge-capable publication grant)"
+            : "merges wait for you — even where a grant could merge on its own, while this mode is active",
+        terms.allowPaidFallback
+            ? "when a subscription is exhausted mid-build, an approved fallback that spends (an API key) may run automatically — spend moves to that account"
+            : "automatic fallback never switches to a paid API key on its own; a subscription that runs out stops and waits for you",
+        ...(terms.repairAuto
+            ? ["historical automatic repair grants are retained on record but no longer schedule work"] : []),
+        `everything above ends at ${terms.absoluteExpiry.slice(0, 16).replace("T", " ")} — revoking it earlier is one click, and every act it covered falls back to its own ceremony`,
+    ];
+}

package/dist/monitoring-settings.d.ts

@@ -0,0 +1,44 @@
+/** Where an address points, without its path or query (a webhook may carry a key in either). */
+export declare const origin: (address: string) => string;
+export type MonitoringSettings = {
+    webhook: {
+        url: string;
+        secret: string;
+    } | null;
+    folder: {
+        path: string;
+    } | null;
+    traces: {
+        endpoint: string;
+        header: {
+            name: string;
+            value: string;
+        } | null;
+    } | null;
+};
+export declare const NO_MONITORING: MonitoringSettings;
+/** An address Toolroll may send to: https anywhere, http only to this machine (a collector beside it). */
+export declare function sendableAddress(value: string): string | null;
+export declare function readMonitoring(dir: string | null | undefined): MonitoringSettings;
+/** A fresh signing secret for the webhook (shown once; the receiver keeps it to check each request). */
+export declare function newSigningSecret(): string;
+export type MonitoringForm = {
+    webhook: string;
+    folder: string;
+    tracesEndpoint: string;
+    headerName: string;
+    headerValue: string;
+    rotate: boolean;
+};
+export declare function saveMonitoring(dir: string, form: MonitoringForm, previous: MonitoringSettings, forbidden?: readonly string[]): {
+    ok: true;
+    settings: MonitoringSettings;
+    secret: string | null;
+} | {
+    ok: false;
+    said: string;
+};
+/** The change in words for the ledger: where things go and header names, never a secret or a full address. */
+export declare function monitoringWords(settings: MonitoringSettings): string;
+/** A change for the ledger: before → after, and what changed that the words alone don't show (never the values). */
+export declare function monitoringChange(before: MonitoringSettings, after: MonitoringSettings, newSecret: boolean): string | null;