toolroll 0.9.103 → 0.9.105

package/dist/release-next.js

@@ -1,13 +1,3 @@
-/**
- * What `toolroll release <branch>` does before its journal's next step (docs/plans/plain-toolroll.md P2.6): one command,
- * so a person never chooses between --recover-deploy, --release-gate and rerunning.
- *
- * - **Another run**: a run lock per branch, by host and pid. A live one is waited for, named; two coordinators never act
- *   on one release at once. A lock whose process is proved gone on this host is taken over.
- * - **A deployment left open**: the journal decides. Before the swap: its pause is lifted, once proved. Past the new
- *   service's start: forward, by the release. Between: rolled back through its own recovery. Each of those re-proves
- *   itself, so a crash at any phase ends the same on the next run.
- */
 import { closeSync, mkdirSync, openSync, readdirSync, readFileSync, rmSync, writeSync } from "node:fs";
 import { hostname } from "node:os";
 import { dirname, join } from "node:path";
@@ -18,7 +8,6 @@ import { journalFile, readJournal } from "./release.js";
 import { autoPublishHeld, PUBLISH_ALLOWED_ACTION } from "./release-auto.js";
 import { sameMachineHost } from "./machine-identity.js";
 const lockFile = (stateDir, branch) => journalFile(stateDir, branch).replace(/\.json$/, ".running");
-/** How long a run waits for another before it says so and stops. */
 export const RELEASE_WAIT_MS = 30 * 60_000;
 const processAlive = (pid) => {
     try {
@@ -38,7 +27,6 @@ function readHolder(file) {
         return null;
     }
 }
-/** Take this branch's run lock, waiting for a live holder. Answers how to give it back, or who kept it. */
 export async function takeReleaseRun(stateDir, branch, say, seams = {}) {
     const file = lockFile(stateDir, branch);
     const host = seams.host ?? hostname(), pid = seams.pid ?? process.pid;
@@ -64,8 +52,6 @@ export async function takeReleaseRun(stateDir, branch, say, seams = {}) {
                 throw error;
         }
         const holder = readHolder(file);
-        // A lock with no readable holder, or a process proved gone on this computer, holds nothing. Another computer's can't
-        // be proved gone from here, so it is waited for.
         if (holder === null || (sameMachineHost(holder.host, host) && !alive(holder.pid))) {
             rmSync(file, { force: true });
             continue;
@@ -79,9 +65,7 @@ export async function takeReleaseRun(stateDir, branch, say, seams = {}) {
         await sleep(seams.pollMs ?? 5_000);
     }
 }
-/** The one action a deployment's journal calls for: a row of the one phase table (deploy-phase.ts). */
 export { deployActionOf };
-/** Settle what a stopped deployment left, saying what was done. A refusal stops the release before it does anything. */
 export async function settleDeployment(world, say) {
     const open = world.rescue.journals().filter(one => deployActionOf(one.journal?.["phase"]) !== "none");
     if (open.length === 0)
@@ -91,8 +75,6 @@ export async function settleDeployment(world, say) {
     const { stage, journal } = open[0];
     const action = deployActionOf(journal?.["phase"]);
     if (action === "refuse") {
-        // A word this version's table does not hold (a newer candidate's, or damage) is never acted on by itself: the
-        // deployment's own recovery knows its own phases, and the person starts it.
         const phase = journal?.["phase"];
         return typeof phase === "string"
             ? { ok: false, message: `The deployment in ${stage} stopped at a step this version doesn't know (${/^[a-z-]{1,40}$/.test(phase) ? phase : "not a plain word"}). Nothing was changed. Its own recovery can decide: \`toolroll release --recover-deploy --yes\`.` }
@@ -115,13 +97,7 @@ export async function settleDeployment(world, say) {
     say("Put back the deployment that stopped half way.");
     return { ok: true };
 }
-// ---- a held release resumes itself -----------------------------------------------------------------------------------
 export const RELEASE_RESUMED_ACTION = "release resumed";
-/**
- * A person let a held release go on (release-auto.ts allowAutoPublish; the Release sheet's button or `publish-ok`): each
- * sweep, its journal goes on from where it stopped, once per that person's act, under the same run lock. It was merged
- * already, so only the tag, publication and Homebrew are left, and each re-proves itself.
- */
 export async function resumeAllowedReleases(store, stateDir, run, now) {
     let folder;
     try {
@@ -138,7 +114,6 @@ export async function resumeAllowedReleases(store, stateDir, run, now) {
         const allowed = store.handle.prepare("SELECT id FROM action_ledger WHERE task_id = ? AND action = ? ORDER BY id DESC LIMIT 1").get(journal.task.id, PUBLISH_ALLOWED_ACTION);
         if (allowed === undefined)
             continue;
-        // Once per act: a resume that stops again waits for a person, never for the next sweep.
         const done = store.handle.prepare("SELECT 1 AS hit FROM action_ledger WHERE task_id = ? AND action = ? AND outcome = ?").get(journal.task.id, RELEASE_RESUMED_ACTION, String(allowed["id"]));
         if (done !== undefined)
             continue;

package/dist/release-recheck.js

@@ -1,25 +1,3 @@
-/**
- * Re-running only what failed, by file (docs/plans/release-once.md, part 2).
- *
- * On the second and later checks of a release generation, a check runs only what failed at the newest FULL check A of
- * that generation — the failed unit files, the failed journey groups, the failed upgrade versions — plus every test
- * changed since A and a sanity pass; never the whole suite.
- *
- * - Every outcome at A has a disposition (requiredSet): a passed, unchanged item carries from A; a failed or flaky one
- *   re-runs (each failed identity must pass); a part whose results can't be attributed (it stopped, it never said, a
- *   worker crashed, only the browser-error check failed) re-runs whole; a failed typecheck or build means a full check.
- * - Obligations are immutable: R(A) comes only from A's sealed evidence. Each targeted attempt seals an obligation
- *   snapshot of the earlier targeted runs it took into account and what failed in them; a targeted run C runs R(A),
- *   every identity that failed in the snapshot, every test changed since A and the sanity pass — never borrowing
- *   coverage from an earlier targeted run.
- * - Coverage is conserved (coverageOf): every item of the new run's inventory has either an eligible pass at A and is
- *   unchanged, or a qualifying pass now; otherwise the result is `partial`, which never passes. A required identity
- *   that is gone or newly skipped — in a targeted run or in the full run after it — is `identity-removed`: the release
- *   stops carrying and a person approves it again.
- *
- * Coverage trusts test code (Alex, 2026-10-25): these results protect against accidental damage, not a hostile test.
- * Authority never reads them; the release's own records do.
- */
 import { CHECK_CONTEXT_CAPTURE, CHECK_INVENTORY_CAPTURE, CHECK_REPORT_CAPTURE, OBLIGATION_SNAPSHOT_CAPTURE, TARGETED_PLAN_CAPTURE, checkContextOf, fullCheckProblem, isUnitFile, payloadDigest, projectGitDir, readSealedJson, treeFactsOf } from "./check-report.js";
 import { readVerifiedCommit, verifiedTreeDiff } from "./commit-extract.js";
 import { checkContextSchema, fileIdentity, groupIdentity, journeyIdentity, obligationSnapshotSchema, readCheckReport, sealedInventorySchema, targetedPlanSchema, unitIdentity, versionIdentity, } from "./contracts/release-check.js";
@@ -27,7 +5,6 @@ import { parseContract } from "./contracts/contract.js";
 import { releaseAuthority, releaseAuthorityOfTask, releaseCarries } from "./release-authority.js";
 import { liveReleaseOf, releaseCheckScope } from "./scope.js";
 import { checkAttemptOf } from "./store.js";
-/** The sanity pass every targeted check runs beside its plan: a few fast tests of the core rules, when the tree has them. */
 export const SANITY_UNITS = Object.freeze(["src/scope.test.ts", "src/contract.test.ts", "src/check-report.test.ts", "src/update-safe-migrations.test.ts"]);
 export function sealedRun(store, root, run) {
     const attempt = checkAttemptOf(store, run);
@@ -52,7 +29,6 @@ const JOURNEY_PARTS = [
     { label: "flows", script: "flows", kind: "scripted" }, { label: "app", script: "app", kind: "scripted" },
     { label: "flows-real", script: "flows", kind: "real" }, { label: "app-real", script: "app", kind: "real" },
 ];
-/** The disposition of every outcome at A (the table in the plan). */
 export function requiredSet(a) {
     const none = (full) => ({ full, units: [], parts: [], groups: [], versions: [], required: [], skipped: [] });
     const report = a.report, inventory = a.inventory;
@@ -68,7 +44,6 @@ export function requiredSet(a) {
     }
     const units = new Set(), parts = new Set(), versions = new Set(), required = new Set(), skipped = new Set();
     const groups = new Map();
-    // Units.
     const unitPart = part("unit");
     if (unitPart?.selected === true) {
         const u = report.units;
@@ -76,7 +51,6 @@ export function requiredSet(a) {
             parts.add("unit");
         else {
             const byFile = new Map(u.files.map(one => [one.file, one]));
-            // Stopped or not run: an inventory file with no outcome re-runs the whole part.
             if (inventory.sealed.units.some(file => !byFile.has(file)))
                 parts.add("unit");
             for (const file of u.files) {
@@ -99,7 +73,6 @@ export function requiredSet(a) {
             }
         }
     }
-    // Journeys: whole groups.
     for (const lane of JOURNEY_PARTS) {
         const selected = part(lane.label);
         if (selected?.selected !== true)
@@ -125,7 +98,6 @@ export function requiredSet(a) {
                     required.add(journeyIdentity(lane.script, lane.kind, group.group, journey.name));
         }
     }
-    // Upgrades: whole versions.
     const upgradePart = part("upgrade");
     if (upgradePart?.selected === true) {
         if (!upgradePart.ran || report.upgrades === null || !report.upgrades.finished)
@@ -142,7 +114,6 @@ export function requiredSet(a) {
         groups: [...groups.values()].map(one => ({ script: one.script, kind: one.kind, groups: [...one.groups].sort() })),
     };
 }
-/** The identities that failed in one run's sealed report (for an obligation snapshot). */
 export function failedIdentities(report) {
     if (report === null)
         return [];
@@ -166,7 +137,6 @@ export function failedIdentities(report) {
             out.add(versionIdentity(one.version));
     return [...out].sort();
 }
-/** The base A of a generation: the newest run with intended mode full before `before`, if it can be one. */
 function baseOf(store, root, authority, before) {
     const row = store.handle.prepare("SELECT run FROM release_check_attempt WHERE authority = ? AND mode = 'full' AND run < ? ORDER BY run DESC LIMIT 1").get(authority, before);
     if (row === undefined)
@@ -181,17 +151,14 @@ function baseOf(store, root, authority, before) {
         return { problem: obligations.full };
     return { base, obligations };
 }
-/** The earlier targeted runs of this generation after A, with their sealed report digests and what failed in them. */
 export function obligationSnapshot(store, root, authority, base, before) {
     const rows = store.handle.prepare("SELECT run FROM release_check_attempt WHERE authority = ? AND mode = 'targeted' AND run > ? AND run < ? ORDER BY run").all(authority, base, before);
     return { version: 1, authority, base, earlier: rows.map(row => {
             const sealed = sealedRun(store, root, Number(row["run"]));
-            // A targeted run with no readable report proves nothing passed: everything it was asked to run stays owed.
             const failed = sealed?.report == null ? [...(sealed?.plan?.required ?? [])] : failedIdentities(sealed.report);
             return { run: Number(row["run"]), reportDigest: sealed?.reportDigest ?? null, failed };
         }) };
 }
-/** The plan a targeted run runs: R(A), the snapshot's failures, every test changed since A, and the sanity pass. */
 export function planFrom(base, obligations, snapshot, changed, units, journeysRan) {
     const files = new Set(obligations.units);
     const parts = new Set(obligations.parts);
@@ -218,7 +185,6 @@ export function planFrom(base, obligations, snapshot, changed, units, journeysRa
     for (const path of changed) {
         if (isUnitFile(path))
             files.add(path);
-        // A changed journey script runs all its groups again: its whole part, as A ran it.
         if (path === "scripts/app-e2e.mjs" || path === "scripts/flows-e2e.mjs") {
             const script = path.includes("app") ? "app" : "flows";
             for (const lane of JOURNEY_PARTS)
@@ -232,15 +198,7 @@ export function planFrom(base, obligations, snapshot, changed, units, journeysRa
         versions: parts.has("upgrade") ? [] : [...versions].sort(), parts: [...parts].sort(), required: [...required].sort(),
     };
 }
-/**
- * Whether the check about to run for this release task may be targeted (planTargetedRecheck): only when A and this run
- * are gate tasks of the same current generation, A is the generation's newest full check with a valid report that
- * accounts for every item and reused nothing from CI, everything since A is test-only (the carry proved it), the
- * execution context matches A's, and no main-check failure is open. Otherwise a full check, told which identities it
- * must still report (watch).
- */
 export function planTargetedRecheck(store, root, input) {
-    // The nightly's open failures are reported by name by every full check, so a pass can clear exactly them.
     const mainOpen = store.handle.prepare("SELECT DISTINCT item FROM main_check_failure WHERE repo = ? AND cleared_at IS NULL").all(input.repo).map(row => String(row["item"]));
     const found = releaseAuthorityOfTask(store, input.taskId);
     if (found === null)
@@ -262,7 +220,6 @@ export function planTargetedRecheck(store, root, input) {
         return full("the nightly full check on main has open failures", watch);
     if (base.context === null || base.inventory === null)
         return full("the last full check's context can't be read", watch);
-    // Everything since A, read from verified objects: only tests may differ (a carry proved the rest).
     const gitDir = projectGitDir(input.repo);
     const baseHead = store.getRun(base.run)?.headRevision ?? null;
     if (gitDir === null || baseHead === null)
@@ -280,7 +237,6 @@ export function planTargetedRecheck(store, root, input) {
         return full("more than tests changed since the last full check", watch);
     if (found.carry === null && input.taskId !== a.anchorTask)
         return full("this task isn't part of the release", watch);
-    // The context must match A's exactly (the harness digest leaves the tests themselves out).
     const facts = treeFactsOf(gitDir, input.head);
     if (!facts.ok)
         return full("this commit can't be read", watch);
@@ -293,16 +249,11 @@ export function planTargetedRecheck(store, root, input) {
         units: [...new Set([...obligations.units, ...owed.flatMap(id => /^unit:(.+?)::/.exec(id)?.[1] ?? /^file:(.+)$/.exec(id)?.[1] ?? [])])].sort() }, snapshot, changed, facts.facts.units, journeysRan);
     return { mode: "targeted", authority: a.id, plan, snapshot, watch: plan.required };
 }
-/**
- * Whether a targeted run B, with A's sealed evidence, its plan and snapshot, covers every item of B's inventory
- * (coverage conservation), and every required identity passed — re-derived from sealed values only.
- */
 export function coverageOf(input) {
     const { a, b, plan, snapshot } = input;
     const obligations = requiredSet(a);
     if (obligations.full !== null)
         return "partial";
-    // The plan holds everything A and the snapshot owe: a plan that leaves one out is no plan for this base.
     const owed = new Set([...obligations.required, ...snapshot.earlier.flatMap(one => one.failed)]);
     if ([...owed].some(identity => !plan.required.includes(identity)))
         return "partial";
@@ -316,7 +267,6 @@ export function coverageOf(input) {
         if (one === undefined || !one.ran || one.code !== 0)
             return "partial";
     }
-    // Required identities: reported, and passed. Gone, or newly skipped, asks again.
     const passed = new Set(), skippedNow = new Set(), reported = new Set();
     for (const one of report.units?.identities ?? []) {
         const id = unitIdentity(one.file, one.name);
@@ -365,7 +315,6 @@ export function coverageOf(input) {
         return "partial";
     if (input.b.exitCode !== 0)
         return "partial";
-    // Every owed whole part ran whole and finished, its inventory complete and every item passed (review round 1).
     for (const owedPart of plan.parts) {
         const ran = report.parts.find(one => one.part === owedPart);
         if (ran === undefined || !ran.ran || ran.code !== 0)
@@ -397,7 +346,6 @@ export function coverageOf(input) {
                 return "partial";
         }
     }
-    // Conservation, unit files: passed at A (not flaky) and not owed again, or passed here.
     const aFiles = new Map((a.report.units?.files ?? []).map(one => [one.file, one]));
     const bFiles = new Map((report.units?.files ?? []).map(one => [one.file, one]));
     const rerun = new Set([...plan.units, ...plan.sanity]);
@@ -410,7 +358,6 @@ export function coverageOf(input) {
         if (!eligible && !(here !== undefined && here.state !== "failed"))
             return "partial";
     }
-    // Journey groups and upgrade versions: passed at A and not owed, or passed here.
     for (const run of a.report.journeys)
         for (const group of run.groups) {
             const owedHere = plan.parts.includes(label(run.script, run.kind)) || plan.groups.some(one => one.script === run.script && one.kind === run.kind && one.groups.includes(group.group));
@@ -427,7 +374,6 @@ export function coverageOf(input) {
     }
     return "composed";
 }
-/** A full run's own check: a required identity of the generation that is gone or newly skipped. */
 export function fullRunRemovedIdentity(report, watch, skippedAtBase) {
     if (report === null || watch.length === 0)
         return false;
@@ -453,10 +399,6 @@ export function fullRunRemovedIdentity(report, watch, skippedAtBase) {
         return state === undefined || (state === "skipped" && !skippedAtBase.includes(identity));
     });
 }
-/**
- * After the check: its coverage, and for a composed one the links its receipt names. An identity-removed result stops
- * the release carrying (a person approves it again). `gateOf` reads a run's verified receipt digest.
- */
 export function settleCoverage(store, root, input, gateOf) {
     const b = sealedRun(store, root, input.runId);
     if (b === null)
@@ -473,19 +415,13 @@ export function settleCoverage(store, root, input, gateOf) {
         return { coverage: "identity-removed", composed: null };
     };
     if (b.attempt.mode === "full") {
-        // The rule on removed or skipped required identities applies to full runs too.
         if (b.attempt.authority !== null) {
-            // Owed whatever made the last full check ineligible as a base: a failed typecheck never wipes them.
             const watch = owedIdentities(store, root, b.attempt.authority, input.runId);
             if (fullRunRemovedIdentity(b.report, watch, []))
                 return removed();
-            // Every identity that ever failed in this generation stays protected, passed since or not (review round 2).
             if (removedProtected(b.report, b.inventory, protectedIdentities(store, root, b.attempt.authority, input.runId)))
                 return removed();
         }
-        // A release's Full check (its task carries signed release terms, before or after its authority opens — an automatic
-        // approval's check runs before) counts only with a complete, valid result (check-report.ts): anything less is no result.
-        // A release check purpose (pipeline-speed.md, P0) counts too: a termsless release is held to the same rules.
         const release = b.attempt.authority !== null || releaseCheckScope(store.getScope(input.taskId));
         if (release && fullCheckProblem({ report: b.report, inventory: b.inventory, exitCode: input.exitCode }) !== null)
             return { coverage: "no-result", composed: null };
@@ -510,11 +446,6 @@ export function settleCoverage(store, root, input, gateOf) {
     return { coverage, composed: { base: a.run, baseReceipt, baseReport: a.reportDigest, authority: authority.id, carries: releaseCarries(store, authority.id).filter(one => one.taskId === input.taskId).map(one => one.id),
             artifacts: authority.artifactDigest, plan: b.planDigest, snapshot: b.snapshotDigest, report: b.reportDigest } };
 }
-/**
- * Re-prove every link a composed receipt names, from sealed artifacts and the store: A's receipt and report, this run's
- * plan (re-derived from A's sealed evidence and the sealed snapshot), its snapshot and report, the release's artifact
- * digest on every carry of this task, the generation and the grant. Null when every link holds; else why not.
- */
 export function provedComposition(store, root, runId, links, gateOf, grantOf) {
     const b = sealedRun(store, root, runId);
     if (b === null || b.attempt.mode !== "targeted" || b.attempt.baseRun !== links.base || b.attempt.authority !== links.authority)
@@ -545,7 +476,6 @@ export function provedComposition(store, root, runId, links, gateOf, grantOf) {
         return "The composed check removed a test that failed earlier in this release.";
     return null;
 }
-/** The identities a later check of this release still has to run again and pass (the anchor page's obligations). */
 export function releaseObligationsOf(store, root, authority) {
     const newest = store.handle.prepare("SELECT run FROM release_check_attempt WHERE authority = ? ORDER BY run DESC LIMIT 1").get(authority);
     if (newest === undefined)
@@ -555,12 +485,6 @@ export function releaseObligationsOf(store, root, authority) {
         return [];
     return sealed.report.exitCode === 0 ? [] : failedIdentities(sealed.report);
 }
-/**
- * The identities a release generation still owes, independent of whether a targeted check is allowed (review round
- * 1): every identity that failed in any of its checks before `before`, until a later check reported it PASSED by name.
- * A failed typecheck or build doesn't wipe them, and a full fallback keeps them: each must be reported again, and a
- * check that drops or newly skips one asks a person again.
- */
 export function owedIdentities(store, root, authority, before) {
     const owed = new Set();
     for (const row of store.handle.prepare("SELECT run FROM release_check_attempt WHERE authority = ? AND run < ? ORDER BY run").all(authority, before)) {
@@ -575,11 +499,6 @@ export function owedIdentities(store, root, authority, before) {
     }
     return [...owed].sort();
 }
-/**
- * The generation's protected identities (review round 2): every identity that failed in any of its checks before
- * `before`. Never shrinks — a later pass doesn't forgive a later removal: removing, renaming or newly skipping any of
- * them, in any later run of the generation, asks a person again. Separate from what is still owed (owedIdentities).
- */
 export function protectedIdentities(store, root, authority, before) {
     const kept = new Set();
     for (const row of store.handle.prepare("SELECT run FROM release_check_attempt WHERE authority = ? AND run < ? ORDER BY run").all(authority, before)) {
@@ -590,11 +509,6 @@ export function protectedIdentities(store, root, authority, before) {
     }
     return [...kept].sort();
 }
-/**
- * Whether a run's report removed one of the protected identities: a unit test or journey gone or newly skipped from a
- * file or group the run did report, a unit file gone from its inventory, a group or upgrade version missing from a lane
- * that finished. A lane that didn't run or finish is no pass, so it is judged by the next run that does.
- */
 export function removedProtected(report, inventory, kept) {
     if (report === null || kept.length === 0)
         return false;
@@ -623,8 +537,6 @@ export function removedProtected(report, inventory, kept) {
             const run = report.journeys.find(one => one.script === script && one.kind === kind);
             if (run === undefined || !run.finished)
                 return false;
-            // A group that ran reports every journey in it; a group missing counts only from a full run (a targeted one
-            // runs the groups it owes).
             const group = run.groups.find(one => journey[1] === "group" ? groupIdentity(run.script, run.kind, one.group) === identity : identity.startsWith(`${groupIdentity(run.script, run.kind, one.group)}::`));
             if (group === undefined)
                 return report.mode === "full";
@@ -639,7 +551,6 @@ export function removedProtected(report, inventory, kept) {
         return false;
     });
 }
-/** The identities a report shows passed by name. */
 function passedIdentities(report) {
     const out = [];
     for (const one of report.units?.identities ?? [])

package/dist/release-refusal.js

@@ -1,16 +1,8 @@
-/**
- * Why a release can't be approved now, from the plane's own state (release-approval.ts re-exports all of it): the
- * coordinator's GitHub CI reading on the exact candidate, and the one list of refusals the release sheet shows and every
- * approval road applies (scope.ts approve() reads `releaseApprovalRefusal` inside its transaction). Kept apart from
- * release-approval.ts so scope.ts reads it without importing the card machinery (an import cycle through store.ts).
- */
 import { releaseCiHoldOf, releaseCiHoldWords } from "./release-ci-hold.js";
 import { taskArchived } from "./task-archive.js";
 import { cleanTerminalLine } from "./terminal-text.js";
-/** The ledger act holding the coordinator's latest reading of the pull request's CI on the exact candidate. */
 export const RELEASE_CI_SEEN_ACTION = "release CI observed";
 export const ciName = (value) => cleanTerminalLine(String(value ?? "")).trim().slice(0, 120);
-/** The coordinator's latest CI reading for this task on exactly `candidate`, or null (not read yet, or another commit). */
 export function releaseCiOf(store, taskId, candidate) {
     const row = store.handle.prepare("SELECT detail, at FROM action_ledger WHERE task_id = ? AND action = ? ORDER BY id DESC LIMIT 1").get(taskId, RELEASE_CI_SEEN_ACTION);
     if (row === undefined)
@@ -28,7 +20,6 @@ export function releaseCiOf(store, taskId, candidate) {
     return { candidate, at: String(row["at"]), state: one.state, failed: one.failed.map(ciName),
         runs: one.runs.map(run => { const r = run; return { id: typeof r["id"] === "number" ? r["id"] : null, name: ciName(r["name"]), status: ciName(r["status"]), conclusion: r["conclusion"] == null ? null : ciName(r["conclusion"]) }; }) };
 }
-/** GitHub CI in one line, as the sheet and the CLI say it. */
 export function ciWords(ci, candidate) {
     const short = candidate.slice(0, 7);
     if (ci === null)
@@ -40,11 +31,9 @@ export function ciWords(ci, candidate) {
     const finished = ci.runs.filter(run => run.status === "completed").length;
     return `GitHub CI is running on ${short}: ${finished} of ${ci.runs.length} checks finished.`;
 }
-/** The release check failed on this task already (the coordinator's record): nobody approves it again here. */
 function checkFailed(store, taskId) {
     return store.handle.prepare("SELECT 1 FROM release_step WHERE task_id = ? AND step = 'check' AND state = 'failed' LIMIT 1").get(taskId) !== undefined;
 }
-/** Why a release can't be approved now, from the plane's own state, or null. */
 export function refusalOf(store, taskId, scope, ci) {
     if (taskArchived(store, taskId))
         return "This release is put away. Restore it before approving.";
@@ -59,14 +48,7 @@ export function refusalOf(store, taskId, scope, ci) {
         return "The release's terms changed after an earlier approval. Read them again.";
     return null;
 }
-/**
- * The release refusals every approval road shares (scope.ts approve(), read inside its transaction): for a scope
- * sealing release terms or a release check's purpose, the sheet's own reasons in the sheet's own words, so the task
- * page, Home's in-place yes, chat and `toolroll task approve` refuse exactly what `/t/<id>/release` refuses. Null for
- * every other scope, and for a release nothing stops. The sheet's card digest binding stays the sheet's.
- */
 export function releaseApprovalRefusal(store, taskId, scope) {
-    // A sealed form, as release-card.ts releaseSealOf reads it (release terms, or a release check's purpose).
     if (scope.releaseTerms == null && scope.releaseCheck == null)
         return null;
     return refusalOf(store, taskId, scope, scope.candidate == null ? null : releaseCiOf(store, taskId, scope.candidate));

package/dist/release-view.js

@@ -1,8 +1,3 @@
-/**
- * What a release task's page shows (docs/plans/release-once.md, "What people see"): for the approved task, the release
- * it's approved for, every later commit carried under it, the open check obligations and the last nightly result for
- * main; for a carried task, whose release approval it was carried from. Read-only, from the store.
- */
 import { liveReleaseOf } from "./scope.js";
 import { nightlyReleaseLines } from "./nightly-github.js";
 import { releaseAuthorityOfTask, releaseCarries } from "./store.js";