toolroll 0.9.103 → 0.9.105

package/dist/writes-mode.js

@@ -1,6 +1,5 @@
 export const WRITES_DEFAULT = "workspace";
 export const isWritesMode = (value) => value === "workspace" || value === "anywhere";
-/** What an approval card and the CLI say of where a build may write (absent: sealed before write allowlists). */
 export function writesWords(writes) {
     return writes === "workspace" ? "only its checkout, its caches and its temp folder"
         : writes === "anywhere" ? "anywhere outside Toolroll's fenced folders (an approver's choice)"

package/dist/youiyoux-intake.js

@@ -1,64 +1,3 @@
-/**
- * youiyoux change and options requests become tasks (docs/guide/getting-started.md, "Change requests from youiyoux").
- *
- * youiyoux is a design-system tool: in its hub a person points at a component on a screenshot of their app and asks
- * for a change, and it saves the request as `<project>/.youi/requests/<id>.json` (`youi.request/v1`). A project that
- * uses youiyoux (a `youi.project.json` at its root, or a `.youi/requests` folder) has this intake on with no step of
- * its own, unless a person turned it off in Settings → Integrations.
- *
- * On the worker's flow pass this reads the project's main checkout — the path from Toolroll's own records, resolved
- * with realpath — and files each open change request with a task exactly once, keyed by the project and the request
- * id in `youiyoux_request`: never again, whatever the file says later. Everything in the folder is outside text,
- * written by whoever can write the project's folder:
- *
- * - the folders and files must be real (never a link), a file a single link to itself, at most 64 KB, read without
- *   following a link or waiting on a pipe, and at most 200 are read in one pass;
- * - a file whose name, schema or id is wrong is counted (the integration says so) and never filed;
- * - text that looks like a key or password is left out (recorded once, never filed), as flow triggers do;
- * - a path the task may touch is kept only when youiyoux knew them all and every one is a plain relative path;
- * - the task is filed through the one filing door (proposal.ts) by the "youiyoux" automation, unplanned, and waits
- *   for a person: its provenance (`filed_via = 'youiyoux'`) keeps every seal no person looked at off it (store.ts,
- *   the outside-request quarantine), so no operating mode, grant, schedule or automatic seal approves it. A person
- *   approves it in Toolroll, or with their own two taps in their paired chat where they turned approving from chat
- *   on (chat-decide.ts), bound to the exact scope the card showed.
- *
- * Beside each request it writes `<id>.task.json` (`youi.request-task/v1`): the task and its status, and, when the
- * console has an address (the one the installation names, else this machine's own console where `up` serves it, on
- * loopback), the task's link and `home`, where a person approves all waiting work. It is written when filed, whenever
- * the status changes, and once more when that address changes. Beside an options request's options file (below), it is
- * the only file it writes in the checkout: written whole (a temporary file in the same folder, then renamed over),
- * refused when the folder or the target is a link, never the request itself. The status is also kept in the store;
- * nothing Toolroll decides reads the file back.
- *
- * Status words (task-status.ts headline → youiyoux): Queued → queued; Planning, Building and Waiting (work going on
- * by itself) → building; Needs you → needs-you; Ready for review → ready; Complete → done; Failed → failed;
- * Stopped → stopped.
- *
- * An options request (`kind: "options"`) asks an agent for two to four options for one component, which youiyoux shows
- * on its Screens canvas. It is filed the same way, once, waiting for a person, and only as youiyoux's contract has it:
- * its offer names `p-<its own hex>`, that proposal's file `.youi/proposals/p-<hex>.json`, and the task may touch that
- * one file (anything else is counted as a file that couldn't be read, and never filed). The proposal it names is kept
- * when filed; the request is never read for it again. Then (runYouiyoux, the worker's pass):
- *
- * - When the task is Ready for review (or Complete), its result is read: the file at the result's commit, the commit
- *   Toolroll recorded for the build (never the checkout the agent had, which it controls and the pool hands on), read
- *   with the hardened git (teardown-git.ts). It must be a plain file in that commit (never a link), at most 64 KB, a
- *   `youi.proposal/v1` file whose id is the proposal, which answers this request, still open (an agent proposes; only a
- *   person decides), by an agent, with no key-like text. Then it is copied, byte for byte, into the project's main
- *   checkout as `.youi/proposals/<id>.json` the way the status file is written (folders real, never through a link;
- *   a temporary file, then linked into place, which never replaces a file already there: a person may have decided on
- *   it). A file missing from the result, or one that isn't safe, is said in the status file and never copied; a newer
- *   result is read again.
- * - Only a file Toolroll copied is read for a decision: one already at that name is left as it was (a person may
- *   have decided on it) and never read for one, unless it is byte for byte the result's (an earlier pass's copy).
- * - When that copy says a person chose an option or dismissed them all (youiyoux's hub writes that), and it is still
- *   the proposal copied (only its status, choice, decidedBy, decidedAt, request and updatedAt may differ), decided by
- *   a person, at a time, the task is marked complete by Toolroll, as landed work is (result-completion.ts LANDED_ACTOR), without
- *   merging or publishing its branch: its deliverable was the options, and youiyoux has used them. Only the exact
- *   result whose file was copied, and only through every guard a person's completion passes (landed-cleanup.ts
- *   completionProblem): otherwise it stays Ready for review and the ledger says why. The ledger keeps who decided
- *   what, as youiyoux wrote it (outside text, cleaned). A decision never approves, publishes or merges anything.
- */
 import { createHash, randomBytes } from "node:crypto";
 import { closeSync, constants, fstatSync, fsyncSync, linkSync, lstatSync, mkdirSync, openSync, readdirSync, readSync, realpathSync, renameSync, unlinkSync, writeSync } from "node:fs";
 import { join } from "node:path";
@@ -76,18 +15,14 @@ import { COMPLETION_ACTION, LANDED_ACTOR } from "./result-completion.js";
 import { optionsProblem, PROPOSAL_ID, proposalFileOf, proposalIdOf, readYouiyouxProposal, readYouiyouxRequest, readYouiyouxRequestTask, YOUIYOUX_CARD_KIND, YOUIYOUX_FILED_VIA, YOUIYOUX_HOME_PATH } from "./contracts/youiyoux-request.js";
 import { FolderUnavailable } from "./folder-gate.js";
 export { YOUIYOUX_FILED_VIA };
-/** Who files the tasks: an automation, like a flow trigger. */
 export const YOUIYOUX_ACTOR = "youiyoux";
 export const REQUEST_BYTES = 64 * 1024;
 export const REQUESTS_PER_PASS = 200;
 export const FILED_PER_PASS = 10;
 const STATUS_PER_PASS = 50;
-/** Options requests whose result is read, or whose copy in the hub is read for a decision, in one pass (each). */
 const OPTIONS_PER_PASS = 20;
-/** The ledger's word for a decision youiyoux's hub made on a task's options. */
 export const OPTIONS_DECIDED_ACTION = "youiyoux options decided";
 export const OPTIONS_COPIED_ACTION = "youiyoux options copied";
-/** The flow pass runs every 15 seconds; the folder is read at most this often. */
 export const INTAKE_EVERY_MS = 30_000;
 const REQUEST_FILE = /^(r-[0-9a-f]{10})\.json$/;
 export const STATUS_OF_HEADLINE = {
@@ -96,9 +31,6 @@ export const STATUS_OF_HEADLINE = {
 };
 const plural = (count, one) => `${count} ${one}${count === 1 ? "" : "s"}`;
 const isMissing = (error) => error?.code === "ENOENT";
-// ------------------------------------------------------------ the project
-/** Whether a project uses youiyoux: a `youi.project.json` at its root, or a `.youi` folder. Only their presence is
- * read here (a link counts, so the integration can say it is Broken); requestsFolder decides what may be read. */
 export function usesYouiyoux(repo) {
     const there = (path) => { try {
         lstatSync(path);
@@ -109,8 +41,6 @@ export function usesYouiyoux(repo) {
     } };
     return there(join(repo, "youi.project.json")) || there(join(repo, ".youi"));
 }
-/** `.youi/<part>` of a recorded project, checked now: null when there is none. Links are refused, never followed.
- * `create`: a missing `<part>` (never `.youi` itself) is made, as a real folder, and checked again. */
 function youiFolder(repo, part, create = false) {
     const what = part === "requests" ? "its requests aren't read" : "nothing is written in it";
     let root;
@@ -159,7 +89,6 @@ function youiFolder(repo, part, create = false) {
 const requestsFolder = (repo) => youiFolder(repo, "requests");
 const NOFOLLOW = constants.O_NOFOLLOW ?? 0;
 const NONBLOCK = constants.O_NONBLOCK ?? 0;
-/** One request file's text: a real file with one link, at most REQUEST_BYTES, read without following a link. */
 function readRequestFile(dir, name) {
     const path = join(dir, name);
     let stats;
@@ -201,8 +130,6 @@ function readRequestFile(dir, name) {
         closeSync(fd);
     }
 }
-/** The open change and options requests in the folder not yet taken, and the files that couldn't be read as requests
- * (an options request that doesn't hold to youiyoux's contract among them). */
 function readRequests(dir, taken) {
     const names = readdirSync(dir).filter(name => REQUEST_FILE.test(name) && !taken.has(name.slice(0, 12))).sort();
     const out = { requests: [], invalid: [], more: names.length > REQUESTS_PER_PASS };
@@ -230,7 +157,6 @@ function readRequests(dir, taken) {
             out.invalid.push(`${name}: its id is ${parsed.value.id}`);
             continue;
         }
-        // Comments, requests already addressed or closed, and changes with no task are someone else's to act on.
         if (parsed.value.kind === "comment" || parsed.value.status !== "open")
             continue;
         const options = optionsProblem(parsed.value);
@@ -244,28 +170,22 @@ function readRequests(dir, taken) {
     }
     return out;
 }
-// ------------------------------------------------------------ the task
-/** One line of outside text: control and hidden characters out, runs of space as one, at most `max` characters. */
 function line(text, max) {
     const clean = text.replace(/[\p{Cc}\p{Cf}\u2028\u2029]+/gu, " ").replace(/\s+/g, " ").trim();
     return clean.length > max ? `${clean.slice(0, max - 1).trimEnd()}…` : clean;
 }
-/** Outside paragraphs: control characters out (newlines and tabs kept), hidden characters out. */
 function paragraphs(text) {
     return text.replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f\p{Cf}\u2028\u2029]/gu, "").trim();
 }
-/** The paths a request may touch: every one a plain relative path inside the project, or none at all. */
 export function safeTouches(touches) {
     const ok = (path) => path !== "" && path.length <= 200 && !path.includes("\u0000") && !/[\p{Cc}\p{Cf}]/u.test(path)
         && !path.startsWith("/") && !path.startsWith("\\") && !/^[A-Za-z]:/.test(path) && !path.startsWith("~")
         && !path.split(/[\\/]/).some(part => part === ".." || part === "") && path.trim() === path;
     return touches.every(ok) ? [...new Set(touches)] : null;
 }
-/** A criterion statement in a rubric's own terms: one line, and no `|` (the rubric's field separator). */
 function statement(text) {
     return line(text.replace(/\|/g, "/"), 300);
 }
-/** The task a request asks for, in Toolroll's terms. Text is cleaned here; whether it may be filed is decided by the caller. */
 export function requestTask(request) {
     const task = request.task;
     const touches = task.touchesKnown ? safeTouches(task.touches) ?? [] : [];
@@ -280,15 +200,12 @@ export function requestTask(request) {
         pointed: { route: line(request.target.route, 300), component: line(request.target.name, 200), at: pointedAt(request.target) },
     };
 }
-/** `file:line` (or the file alone) where youiyoux knew a plain relative path; null otherwise. */
 function pointedAt(target) {
     const file = target.file === undefined ? null : safeTouches([target.file])?.[0] ?? null;
     return file === null ? null : target.line === undefined ? file : `${file}:${target.line}`;
 }
-/** Why a request's task can't be filed as it stands, or null. */
 function refusalOf(request, task) {
     const given = request.task;
-    // Read as written and as cleaned: cleaning must never be what lets a key through.
     const raw = [given.title, given.goal, request.target.route, request.target.name, request.target.file ?? "", ...given.not, ...given.touches, ...given.acceptance.map(one => one.statement)];
     const all = [task.title, task.goal, task.outOfScope ?? "", ...task.touches, ...task.acceptance.map(one => one.statement), task.pointed.route, task.pointed.component, task.pointed.at ?? ""];
     if ([...raw, ...all].some(one => scanForSecrets(one).length > 0))
@@ -310,7 +227,6 @@ function recordPass(store, repo, now, uses, invalid, problem) {
     store.handle.prepare(`INSERT INTO youiyoux_intake (repo, uses, checked_at, invalid, problem) VALUES (?, ?, ?, ?, ?)
     ON CONFLICT (repo) DO UPDATE SET uses = excluded.uses, checked_at = excluded.checked_at, invalid = excluded.invalid, problem = excluded.problem`).run(repo, uses ? 1 : 0, now.toISOString(), invalid, problem);
 }
-/** A person turns the intake off or back on for a project; the ledger keeps who. */
 export function setYouiyouxIntake(store, repo, on, by, now) {
     store.transact(() => {
         store.handle.prepare(`INSERT INTO youiyoux_intake (repo, enabled, changed_by, changed_at) VALUES (?, ?, ?, ?)
@@ -318,8 +234,6 @@ export function setYouiyouxIntake(store, repo, on, by, now) {
         store.recordAction({ at: now.toISOString(), actor: by, repo, taskId: null, runId: null, action: on ? "youiyoux requests on" : "youiyoux requests off", outcome: "changed", source: "access" });
     });
 }
-/** How the intake stands for one project, from the store alone: a page reads it on every render, so it never reads the
- * project's folder (one that doesn't answer must not hold the console). Whether it uses youiyoux is the last pass's. */
 export function youiyouxState(store, repo) {
     const row = intakeRow(store, repo);
     const uses = row.uses;
@@ -328,16 +242,11 @@ export function youiyouxState(store, repo) {
     return { uses, on: uses && row.enabled !== false, off: row.enabled === false, queued: Number(counts?.["queued"] ?? 0), filed: Number(counts?.["filed"] ?? 0),
         invalid: row.invalid, problem: row.problem, checkedAt: row.checkedAt };
 }
-/** The one line `toolroll onboard` says for a project that uses youiyoux; null when it doesn't. */
 export function youiyouxOnboardLine(store, repo) {
     if (!usesYouiyoux(repo))
         return null;
     return intakeRow(store, repo).enabled === false ? "change requests: off (turn on in Settings → Integrations)" : "change requests become tasks that wait for your approval";
 }
-// ------------------------------------------------------------ the status file
-/** The console the links name: the address the installation names (CONSOLE_URL or the console-url file), else, with
- * none named, this machine's own console where `up` serves it (loopback http only, never a guessed host); null without
- * either. Either way http(s) with no credentials, query or fragment. */
 export function consoleBase(env, dir) {
     if (dir === null)
         return null;
@@ -355,16 +264,10 @@ export function consoleBase(env, dir) {
         return null;
     return `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
 }
-/** The task's page in that console; null without one. */
 export function taskLink(env, dir, taskId) {
     const base = consoleBase(env, dir);
     return base === null ? null : `${base}/t/${encodeURIComponent(taskId)}`;
 }
-/**
- * Write `<id>.task.json` beside its request, whole. The folders are checked again now (a link is refused), the request
- * must still be a plain file, the target must be a plain file or absent, and the content goes to a fresh temporary file
- * in the same folder (created exclusively, never through a link) that is then renamed over the target.
- */
 export function writeStatusFile(repo, body) {
     const folder = requestsFolder(repo);
     if (folder === null)
@@ -393,7 +296,6 @@ export function writeStatusFile(repo, body) {
         fsyncSync(fd);
         closeSync(fd);
         fd = null;
-        // At the moment of use: the folder and the target are still what was checked.
         const again = requestsFolder(repo);
         if (again === null || !again.ok || again.dir !== folder.dir || plain(target) === false)
             throw new Error("The requests folder changed while the status was written.");
@@ -405,22 +307,14 @@ export function writeStatusFile(repo, body) {
             try {
                 closeSync(fd);
             }
-            catch { /* already closed */ }
+            catch { }
         try {
             unlinkSync(temporary);
         }
-        catch { /* never made, or already renamed */ }
+        catch { }
         return { ok: false, problem: error instanceof Error && error.message.startsWith("The requests folder") ? error.message : "The status couldn't be written beside the request." };
     }
 }
-/**
- * Put an options file into the project's main checkout as `.youi/proposals/<id>.json`, whole, and never over a file
- * already there (a person may have decided on it). The folders are checked as the status file's are (`.youi/proposals`
- * is made, as a real folder, when missing), the content goes to a fresh temporary file in the same folder (created
- * exclusively, never through a link), the folders are checked again, and the temporary file is linked into place, which
- * fails rather than replace anything at that name, a link included. `same`: that exact content was already there;
- * `taken`: something else was, and is left as it was.
- */
 export function writeProposalFile(repo, id, text) {
     if (!PROPOSAL_ID.test(id))
         return { ok: false, problem: "The options file's name isn't youiyoux's." };
@@ -453,7 +347,6 @@ export function writeProposalFile(repo, id, text) {
         fsyncSync(fd);
         closeSync(fd);
         fd = null;
-        // At the moment of use: the folder is still what was checked.
         const again = youiFolder(repo, "proposals");
         if (again === null || !again.ok || again.dir !== folder.dir)
             throw new Error("The proposals folder changed while the options were written.");
@@ -475,21 +368,18 @@ export function writeProposalFile(repo, id, text) {
             try {
                 closeSync(fd);
             }
-            catch { /* already closed */ }
+            catch { }
         try {
             unlinkSync(temporary);
         }
-        catch { /* never made */ }
+        catch { }
     }
 }
 function statusOf(store, taskId, repo, now, root) {
-    // With the saved evidence, so a completed task reads Complete (its completion is bound to the receipt read with it).
     const read = storedTaskStatus(store, taskId, repo, now, root ?? undefined);
     return read === null ? null : { status: STATUS_OF_HEADLINE[read.status.headline], detail: read.status.headline };
 }
 const clip = (text) => text.length > 200 ? `${text.slice(0, 199).trimEnd()}…` : text;
-/** The status file's words for an options request, where its options stand (else the headline): what a person decided
- * in the hub, and while the result is Ready (or Complete), whether its options went to the hub, and why not. */
 function optionsDetail(row, status, headline) {
     if (row?.["kind"] !== "options")
         return headline;
@@ -507,8 +397,6 @@ function optionsDetail(row, status, headline) {
         default: return headline;
     }
 }
-/** Write a filed task's status where it changed, where its last write failed, or where the console its links name
- * changed since (`written_base`: '' for none), so a file written before a console address existed gets its links. */
 function writeStatus(store, repo, request, taskId, now, io, force) {
     const known = store.handle.prepare(`SELECT status, detail, written_at, written_base, kind, proposal_state, proposal_note, decided, decided_note
     FROM youiyoux_request WHERE repo = ? AND request = ?`).get(repo, request);
@@ -529,8 +417,6 @@ function writeStatus(store, repo, request, taskId, now, io, force) {
 }
 export const NO_YOUIYOUX_PASS = Object.freeze({ filed: 0, skipped: 0, invalid: 0, updated: 0, copied: 0, decided: 0, problems: [] });
 const NOTHING = () => ({ ...NO_YOUIYOUX_PASS, problems: [] });
-/** File one request's task, exactly once: the claim and the filing are one transaction (two passes, in two processes
- * or one, make one task). */
 export function fileYouiyouxRequest(store, repo, request, now) {
     const task = requestTask(request);
     return store.transact(() => {
@@ -558,12 +444,6 @@ export function fileYouiyouxRequest(store, repo, request, now) {
         return { made: "filed", taskId: filed.id };
     });
 }
-/**
- * One message for what a pass filed, however many: the person's paired chats draw it as one card (chat-decide.ts) that
- * lists each new task, with Approve all and each one's own Approve and Open, and a phone push links to what needs
- * them. Keyed by the pass's first task, so a pass says it once; the tasks are the ones filed with it (one project, one
- * moment: requestPassOf). Titles are cleaned outside text, as filed.
- */
 export function noteYouiyouxFiled(store, taskIds, now) {
     const first = store.lookupRef(taskIds[0]);
     if (first === null)
@@ -576,38 +456,27 @@ export function noteYouiyouxFiled(store, taskIds, now) {
         body: titles.map(title => `• ${title}`).join("\n"),
     }, now);
 }
-/** What a pass's tasks were asked for, in a word: "change request", "options request", or "request" for both. */
 export function requestKindWord(store, taskIds) {
     const kinds = new Set(taskIds.map(id => store.youiyouxOriginOf(id)?.kind ?? "change"));
     return kinds.size > 1 ? "request" : kinds.has("options") ? "options request" : "change request";
 }
-/** The tasks one pass filed beside this one (one project, one moment), in request order; empty for any other task. */
 export function requestPassOf(store, taskId) {
     return store.handle.prepare(`SELECT r.task_id FROM youiyoux_request me JOIN youiyoux_request r ON r.repo = me.repo AND r.filed_at = me.filed_at
     WHERE me.task_id = ? AND r.task_id IS NOT NULL ORDER BY r.request LIMIT ?`).all(taskId, FILED_PER_PASS).map(row => String(row["task_id"]));
 }
-/**
- * One project's pass: read new requests and file them, then write each filed task's status where it changed (no
- * options moved: runYouiyoux does that too). The folder read is the project in Toolroll's records that `given`
- * resolves to; anything else is left alone.
- */
 export function runYouiyouxIntake(store, given, now, io, options = {}) {
     return intake(store, given, now, io, options).pass;
 }
-/** The worker's pass for one project (flow-cadence.ts): the intake, then each options request's options, both ways. */
 export async function runYouiyoux(store, given, now, io, options = {}) {
     const { pass, repo } = intake(store, given, now, io, options);
     if (repo !== null)
         await optionsPass(store, repo, now, io, pass);
     return pass;
 }
-/** The intake's pass; `repo` is the project when its requests folder was read whole (and options may move). */
 function intake(store, given, now, io, options) {
     const pass = NOTHING();
     const none = { pass, repo: null };
-    // The project as Toolroll recorded it, resolved: a folder that isn't one of its projects is never read.
     let repo;
-    // A folder the console's gate holds back (folder-gate.ts) isn't read this pass.
     try {
         repo = canonicalProject(given);
     }
@@ -663,7 +532,6 @@ function intake(store, given, now, io, options) {
     }
     if (filedNow.length > 0)
         noteYouiyouxFiled(store, filedNow, now);
-    // Each filed task's status, where it changed, its last write failed, or the console its links name changed.
     const filed = store.handle.prepare(`SELECT request, task_id FROM youiyoux_request WHERE repo = ? AND task_id IS NOT NULL
     AND (status IS NULL OR status <> 'done' OR written_at IS NULL OR written_base IS NOT ?) ORDER BY status_at LIMIT ?`).all(repo, consoleBase(io.env, io.dir) ?? "", STATUS_PER_PASS);
     for (const one of filed) {
@@ -683,10 +551,7 @@ function intake(store, given, now, io, options) {
 const optionsRow = (row) => ({ request: String(row["request"]), taskId: String(row["task_id"]), proposal: String(row["proposal"]),
     state: row["proposal_state"] == null ? null : String(row["proposal_state"]), run: row["proposal_run"] == null ? null : Number(row["proposal_run"]),
     digest: row["proposal_digest"] == null ? null : String(row["proposal_digest"]) });
-/** What a person's decision in the hub may change in an options file (youiyoux seals it, with a key only the person
- * holds: `seal`); everything else must stay as Toolroll copied it. */
 const DECISION_FIELDS = new Set(["status", "choice", "decidedBy", "decidedAt", "request", "seal", "updatedAt"]);
-/** The digest of an options file apart from what a decision changes: the proposal itself, every other key included. */
 export function proposalIdentity(raw) {
     if (raw === null || typeof raw !== "object" || Array.isArray(raw))
         return null;
@@ -694,8 +559,6 @@ export function proposalIdentity(raw) {
     return createHash("sha256").update(canonicalJson(kept)).digest("hex");
 }
 const SHA = /^[0-9a-f]{40}$/;
-/** The task's current result, as its assignment reads it (with the saved evidence where the worker has it): the run and
- * the commit Toolroll recorded for it. Null without a finished result. */
 function resultOf(store, taskId, repo, now, root) {
     const assignment = assignmentOf(store, taskId, now, { principal: "operator", repos: [repo] }, root ?? undefined);
     const receipt = assignment?.receipt ?? null;
@@ -703,8 +566,6 @@ function resultOf(store, taskId, repo, now, root) {
         return null;
     return { assignment, receipt, head: receipt.head };
 }
-/** Why an agent's options file can't go to the hub as it stands, or null. Toolroll checks what makes it safe to copy
- * and this request's; youiyoux checks each option against the component's contract when it reads it. */
 export function proposalProblem(text, proposal, request) {
     let raw;
     try {
@@ -723,7 +584,6 @@ export function proposalProblem(text, proposal, request) {
         return `its id isn't ${proposal}`;
     if (doc.for !== request)
         return `it doesn't answer ${request}`;
-    // An agent proposes; only a person decides, in the hub. A file that arrives decided would decide for them.
     if (doc.status !== "open" || doc.choice !== undefined || doc.decidedBy !== undefined || doc.decidedAt !== undefined || doc.request !== undefined || Object.hasOwn(raw, "seal"))
         return "it arrived already decided, and only a person decides";
     if (doc.author.kind !== "agent")
@@ -732,7 +592,6 @@ export function proposalProblem(text, proposal, request) {
         return "it looked like it held a key or password";
     return null;
 }
-/** Read the options file from the result's commit (never the agent's checkout) and copy it to the hub. */
 async function bringProposal(git, repo, request, proposal, head) {
     const file = proposalFileOf(proposal);
     const listed = await git(repo, ["ls-tree", "-z", "--full-tree", head, "--", file]);
@@ -765,14 +624,10 @@ async function bringProposal(git, repo, request, proposal, head) {
     const wrote = writeProposalFile(repo, proposal, blob.stdout);
     if (!wrote.ok)
         return { state: "retry", note: wrote.problem.replace(/\.$/, "") };
-    // Only Toolroll's own copy (written now, or byte for byte an earlier pass's) is ever read for a decision.
     if (wrote.made === "taken")
         return { state: "taken", note: "a file was already there; the task waits for its review" };
     return { state: "copied", note: null, digest: proposalIdentity(JSON.parse(blob.stdout)) };
 }
-/** What a person decided on the options in the hub, read from the copy in the main checkout; null while they are open or
- * the file can't be read as this request's. Who and the option's label are youiyoux's words: cleaned, and left out
- * when they look like a key. */
 function decisionOf(repo, proposal, request, copied) {
     const folder = youiFolder(repo, "proposals");
     if (folder === null || !folder.ok)
@@ -790,13 +645,11 @@ function decisionOf(repo, proposal, request, copied) {
     const parsed = readYouiyouxProposal(raw);
     if (!parsed.ok || parsed.value.id !== proposal || parsed.value.for !== request)
         return null;
-    // Still the proposal Toolroll copied: its options, ask, target and every other key, apart from what deciding changes.
     if (proposalIdentity(raw) !== copied)
         return null;
     const doc = parsed.value;
     if (doc.status === "open" || (doc.status === "chosen" && doc.choice === undefined))
         return null;
-    // A person's decision, at a time: an agent proposes, and never decides.
     if (doc.decidedBy?.kind !== "person" || doc.decidedAt === undefined)
         return null;
     const said = (text, max) => {
@@ -808,11 +661,6 @@ function decisionOf(repo, proposal, request, copied) {
     return { status: doc.status, choice: doc.choice ?? null, label: said(doc.options.find(one => one.id === doc.choice)?.label, 60),
         by: said(doc.decidedBy?.name, 100), at: doc.decidedAt ?? null };
 }
-/**
- * A person decided in the hub: mark the task complete as landed work is, bound to the exact result whose options were
- * copied, through every guard a person's completion passes, or leave it Ready for review and say why. Once per request,
- * in one transaction with the read. Waits (false) while the task isn't Ready, Complete or cancelled.
- */
 export function actOnDecision(store, repo, row, decision, now, root) {
     return store.transact(() => {
         const current = store.handle.prepare("SELECT decided, proposal_run FROM youiyoux_request WHERE repo = ? AND request = ?").get(repo, row.request);
@@ -863,7 +711,6 @@ export function actOnDecision(store, repo, row, decision, now, root) {
         return true;
     });
 }
-/** Each options request's options, both ways: a Ready result's file to the hub, and a decision in the hub back. */
 async function optionsPass(store, repo, now, io, pass) {
     const root = io.evidenceRoot ?? null;
     if (io.git === undefined || root === null)
@@ -875,7 +722,6 @@ async function optionsPass(store, repo, now, io, pass) {
             const result = resultOf(store, row.taskId, repo, now, root);
             if (result === null)
                 continue;
-            // Said once for each result: a newer one (a revision, a build again) is read again.
             if ((row.state === "missing" || row.state === "unsafe") && row.run === result.receipt.runId)
                 continue;
             const brought = await bringProposal(io.git, repo, row.request, row.proposal, result.head);
@@ -899,7 +745,6 @@ async function optionsPass(store, repo, now, io, pass) {
             pass.problems.push(`youiyoux ${row.request}: ${error instanceof Error ? error.message : "options unreadable"}`);
         }
     }
-    // Only Toolroll's own copies: a file that was already there (`taken`) is never read for a decision.
     const watch = store.handle.prepare(`SELECT request, task_id, proposal, proposal_state, proposal_run, proposal_digest FROM youiyoux_request WHERE repo = ? AND kind = 'options' AND task_id IS NOT NULL
     AND proposal_state = 'copied' AND proposal_digest IS NOT NULL AND decided IS NULL ORDER BY proposal_at LIMIT ?`).all(repo, OPTIONS_PER_PASS).map(optionsRow);
     for (const row of watch) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "toolroll",
-  "version": "0.9.103",
-  "description": "A control plane for unattended coding agents — queue tasks, walk away, come back to pull requests. Agents build in leased worktrees, never touch your default branch, and interrupt you only for decisions that need a human.",
+  "version": "0.9.105",
+  "description": "Your agents build. You decide. A control plane for coding agents — Claude Code, Codex, Gemini: approve the exact scope once, get results back Ready with the diff, the passing check and screenshots. Runs on your machine.",
   "directories": {
     "doc": "docs"
   },
@@ -58,7 +58,7 @@
   "bugs": {
     "url": "https://github.com/ap9000/toolroll/issues"
   },
-  "homepage": "https://github.com/ap9000/toolroll#readme",
+  "homepage": "https://toolroll.dev",
   "bin": {
     "toolroll": "dist/bin.js",
     "standing-orders": "dist/bin.js"
@@ -137,11 +137,12 @@
     "@slack/socket-mode": "3.1.1",
     "@xterm/addon-serialize": "0.14.0",
     "@xterm/headless": "6.0.0",
-    "discord.js": "14.28.0",
+    "discord.js": "14.28.1",
     "imapflow": "2.10.0",
     "mailparser": "3.14.1",
     "nodemailer": "10.3.1",
     "typescript-parser": "npm:typescript@6.0.3",
+    "undici": "7.30.1",
     "ws": "8.22.1",
     "yaml": "2.9.1",
     "zod": "^4.6.7"

package/dist/accent-colors.d.ts

@@ -1,51 +0,0 @@
-/**
- * The accent a person can choose (Settings → Appearance): the signal colour
- * that marks what waits on a person. Any colour from the picker, with
- * Pantone's Colours of the Year as presets. The default is ink — no hue, like Vercel, Linear and GitHub:
- * the page is black, white and grey, and colour is left to status (building, complete, warning, danger).
- * Chart magenta (the default until 2026-09-30) and violet stay presets. The default's tokens are set by
- * hand in serve.ts (ink and near-white), not derived: derivation would stop at a mid grey in dark.
- * A per-browser preference, like the theme: it lives in the person's
- * `so-accent` cookie (six hex digits) and never in the database.
- *
- * Pure and shared: the server derives the tokens it prints for the cookie's
- * colour, and the picker derives the same tokens to preview a colour live.
- *
- * Each colour keeps its hue and gives up only lightness (and, when needed,
- * chroma to stay in sRGB) until it reads: in light, its text passes 4.5:1 on
- * its own soft wash; in dark, 6:1 on the dark paper. The swatch is the chosen
- * colour; the page uses the readable one.
- *
- * Preset names are Pantone LLC's; the hex values are the published screen
- * approximations. Pantone is not affiliated with Toolroll.
- */
-export type AccentTokens = {
-    signal: string;
-    hover: string;
-    on: string;
-    soft: string;
-    selection: string;
-};
-export type AccentPreset = {
-    id: string;
-    name: string;
-    year: number | null;
-    hex: string;
-};
-export declare const DEFAULT_ACCENT = "#171717";
-/** Ink (the default), violet, chart magenta, then Pantone's colours of the year, newest first. The greys and whites (Sand Dollar 2006,
- * Ultimate Gray 2021, Cloud Dancer 2026) are left out: a grey can't mark what needs a person here. */
-export declare const ACCENT_PRESETS: AccentPreset[];
-export declare function contrast(a: string, b: string): number;
-/** "#rrggbb" from "#rgb", "rgb", "#rrggbb" or "rrggbb" (any case); null otherwise. */
-export declare function normalHex(raw: string): string | null;
-/** The readable tokens a colour resolves to, light and dark. */
-export declare function accentTokens(hex: string): {
-    light: AccentTokens;
-    dark: AccentTokens;
-};
-export declare function accentNote(hex: string): string | null;
-/** The person's chosen colour from their own cookie ("#rrggbb"); null is chart magenta. */
-export declare function pinnedAccent(cookieHeader: string | undefined): string | null;
-/** The token overrides for a chosen colour, light and dark, for the page head. */
-export declare function accentStyle(hex: string): string;

package/dist/acp-agents.d.ts

@@ -1,43 +0,0 @@
-/**
- * The coding agents Toolroll runs over the Agent Client Protocol
- * (docs/plans/acp-adapter.md). Each is its own provider id — readiness,
- * sign-in pauses, routing and spend stay per agent — but they share one
- * transport (acp-client.ts), and a row here is the only place an agent is
- * described.
- *
- * Nothing in a row is trusted to be true of the binary on this machine: an
- * agent runs only after its conformance check passed against that exact
- * binary (attestation), and the check is what proves the argv, the name it
- * gives in `initialize`, and the models it offers. Until then it is listed
- * and refused.
- */
-import type { ProviderId } from "./contracts/provider.js";
-export declare const ACP_PROVIDER_IDS: readonly ["opencode", "cursor", "cline", "qwen", "goose"];
-export type AcpProviderId = (typeof ACP_PROVIDER_IDS)[number];
-/** The providers with their own adapter and key: everything that is not an ACP agent. */
-export type KeyedProviderId = Exclude<ProviderId, AcpProviderId>;
-export type AcpAgent = {
-    /** How people know it. */
-    name: string;
-    /** The command looked up on PATH. */
-    binary: string;
-    /** What starts its ACP server on stdio. */
-    argv: readonly string[];
-    /** What the operator runs to sign in. */
-    signIn: string;
-    /** Folders under the home directory that hold its own configuration and sign-in (fenced like other agents' homes). */
-    home: readonly string[];
-    /** What still reaches a run beside the brief: its own configuration surfaces, in words. */
-    configSurface: readonly string[];
-};
-export declare const ACP_AGENTS: Readonly<Record<AcpProviderId, AcpAgent>>;
-export declare function isAcpProvider(provider: string): provider is AcpProviderId;
-/** Whether a profile (or anything carrying a provider) is an ACP agent's: narrows the union. */
-export declare function isAcpProfile<P extends {
-    provider: string;
-}>(profile: P): profile is Extract<P, {
-    provider: AcpProviderId;
-}>;
-export declare function isKeyedProvider(provider: ProviderId): provider is KeyedProviderId;
-/** Build a per-provider record whose ACP entries all come from one function of the agent's row. */
-export declare function withAcp<K extends KeyedProviderId, V>(keyed: Record<K, V>, acp: (agent: AcpAgent, provider: AcpProviderId) => V): Record<K | AcpProviderId, V>;

package/dist/acp-attest.d.ts

@@ -1,44 +0,0 @@
-/** What makes an interpreter load code beside the script it was given: never passed to an ACP launch. */
-export declare const INTERPRETER_INJECTION_ENV: readonly string[];
-/** Bumped whenever the conformance probe changes what it proves: every attestation made under another version is void. */
-export declare const ACP_CONFORMANCE_VERSION = 2;
-export type FileBinding = {
-    role: "launcher" | "interpreter" | "package" | "entry";
-    path: string;
-    sha256: string;
-    dev: number;
-    ino: number;
-    ctimeMs: number;
-    size: number;
-};
-/** How the attested binary is started, and every file that start depends on. */
-export type AcpLaunch = {
-    /** What is executed: the launcher itself, or the pinned interpreter. */
-    file: string;
-    /** Arguments before the agent's own ACP argv: a script's shebang arguments and the script itself. */
-    prefix: string[];
-    bindings: FileBinding[];
-};
-/** sha256 of a regular file, read without following a final symlink. */
-export declare function hashFile(path: string): string | null;
-/** The interpreter and its arguments a shebang line names — `#!/abs/interp [arg]` or `#!/usr/bin/env [-S] name [args]` — or null. */
-export declare function parseShebang(line: string, path: string): {
-    interpreter: string;
-    args: string[];
-} | null;
-/**
- * How to launch a binary found at `launcher` (a realpath), with every file bound — or why it can't be. `path` is the
- * PATH a `#!/usr/bin/env name` shebang is resolved on, once, here.
- */
-export declare function launchOf(launcher: string, path: string): AcpLaunch | {
-    problem: string;
-};
-/** Whether every bound file is still the one that passed: same stat, or on any change the same sha256. */
-export declare function verifyLaunch(launch: AcpLaunch): {
-    ok: true;
-} | {
-    ok: false;
-    problem: string;
-};
-/** A stored launch, read strictly: anything this code never writes reads as null. */
-export declare function launchFromJson(json: string): AcpLaunch | null;