tumwater 0.1.2 → 0.2.0

package/dist/src/{fleet/fleet-state.js → team/team-state.js}

@@ -4,30 +4,31 @@ import { finiteNumber, stringList } from "../files/json-object.js";
 import { removeQuiet } from "../files/files.js";
 import { withStateLock } from "../concurrency/lock.js";
 import { collapseWhitespace, truncate } from "../text/text.js";
-import { pausedPath, pausedRolesLockPath, pausedRolesPath } from "../paths.js";
+import { pausedPath, pausedRolesLockPath, pausedRolesPath, scheduledStopPath } from "../paths.js";
 import { pendingScheduledWakes } from "../operator/operator-requests.js";
-/** The operator pause markers: the fleet-wide pause (`tumwater pause`/`resume`) and the
+import { canonicalRoleId } from "../roles/legacy-role-ids.js";
+/** The operator pause markers: the team-wide pause (`tumwater pause`/`resume`) and the
  * per-role pause set (`pause --role <id>`/`resume --role <id>`), their writers and read-side
  * wrappers together so producer (CLI, GUI) and every consumer read one module. The running
- * orchestrator's info file is the other fleet-state domain and lives in orchestrator-info.ts. */
-/** The fleet pause marker read once as the standing pause it represents: non-null while the
+ * orchestrator's info file is the other team-state domain and lives in orchestrator-info.ts. */
+/** The team pause marker read once as the standing pause it represents: non-null while the
  * operator's pause stands, null when absent/unreadable/expired. Snapshot-style callers that
- * need both "is the fleet paused" and its deadline read this once instead of paying two
- * full marker reads (isFleetPaused + pausedUntil each re-read the same file) per poll —
+ * need both "is the team paused" and its deadline read this once instead of paying two
+ * full marker reads (isTeamPaused + pausedUntil each re-read the same file) per poll —
  * the TUI and GUI poll snapshot every second. Never throws (a missing .tumwater/ reads
  * null). Lives here beside the read-half wrappers below: one module, one marker, one read
  * per poll per observer. */
-export function standingFleetPause(root) {
+export function standingTeamPause(root) {
     return standingMarker(pausedPath(root));
 }
-/** True while the operator has paused the fleet (`tumwater pause` wrote its marker). The
+/** True while the operator has paused the team (`tumwater pause` wrote its marker). The
  * marker is persistent state, not a one-shot request: presence means paused until `resume`
- * removes it — pausing before startup starts an already-paused fleet. Never throws (a missing
+ * removes it — pausing before startup starts an already-paused team. Never throws (a missing
  * .tumwater/ reads false). Lives here because both the scheduler and every observer must
  * evaluate it from disk without importing each other's modules — the same "single
  * definition" rule that put the daily-cost budget in src/budget/budget.ts. */
-export function isFleetPaused(root) {
-    return standingFleetPause(root) !== null;
+export function isTeamPaused(root) {
+    return standingTeamPause(root) !== null;
 }
 /** The reason cap every writer of a pause reason shares (chars): one constant so the CLI
  * path and any later GUI path cannot drift on how long an operator note may be — a writer
@@ -38,18 +39,18 @@ export const PAUSE_REASON_MAX = 200;
  * timed pause: every consumer (scheduler, dashboards, a follow-up `pause`) treats an expired
  * marker as absent, so the deadline releases the pause with no new scheduler code — the
  * orchestrator's poll-diff sees an ordinary unpaused transition. Never throws. The reason is
- * folded and capped here too — the same shape pauseFleet writes — so the marker's reason
+ * folded and capped here too — the same shape pauseTeam writes — so the marker's reason
  * reads as the operator's one-line why whoever wrote it: a pause standing across the
  * write-side fold (or a hand edit) must not hand the status header's badge a raw newline
  * (BUGS.md 2026-09-30). A non-string reason reads as no reason — src/files/json-files.ts's
  * wrong-shape-reads-as-absent policy — and the type guard is what keeps this function's
  * never-throws contract intact: normalizePauseReason would throw on a number or object,
- * and this read sits on the scheduler's per-cycle isFleetPaused poll and every dashboard
+ * and this read sits on the scheduler's per-cycle isTeamPaused poll and every dashboard
  * snapshot.
  *
  * A non-finite `until` (a hand edit's `1e999` parses to Infinity) is the same wrong-shape
  * read: it is dropped, so the marker stands as an indefinite pause rather than a pause that
- * never lapses with its countdown rendered `Infinityd`. The fleet stays stopped — a corrupt
+ * never lapses with its countdown rendered `Infinityd`. The team stays stopped — a corrupt
  * deadline must not resume it — but it no longer claims a deadline no clock can reach. */
 function standingMarker(path) {
     const m = readJsonFile(path);
@@ -69,21 +70,21 @@ function standingMarker(path) {
         delete m.reason;
     return m;
 }
-/** The fleet marker's standing deadline (ms epoch) while a timed pause holds; undefined when
- * the fleet is not timed-paused — no marker, an indefinite `pause` (no `until`), or an expired
+/** The team marker's standing deadline (ms epoch) while a timed pause holds; undefined when
+ * the team is not timed-paused — no marker, an indefinite `pause` (no `until`), or an expired
  * `until` (standingMarker already reads that as unpaused, so the field cannot outlive the
- * pause it describes). Fleet-scoped on purpose: the FLEET marker's deadline is what a header
- * badge may claim, since only it covers the whole fleet. Lives here beside isFleetPaused —
+ * pause it describes). Team-scoped on purpose: the TEAM marker's deadline is what a header
+ * badge may claim, since only it covers the whole team. Lives here beside isTeamPaused —
  * one module for every marker consumer. */
 export function pausedUntil(root) {
-    return standingFleetPause(root)?.until;
+    return standingTeamPause(root)?.until;
 }
-/** The standing fleet pause's operator reason (`tumwater pause --reason <text>`), undefined
- * when the fleet is not paused or the standing pause carries none — same read (and the same
+/** The standing team pause's operator reason (`tumwater pause --reason <text>`), undefined
+ * when the team is not paused or the standing pause carries none — same read (and the same
  * never-throws, expiry-honoring contract) as pausedUntil beside which it lives, so a caller
- * wanting both pays one standingFleetPause read, not two. */
+ * wanting both pays one standingTeamPause read, not two. */
 export function pausedReason(root) {
-    return standingFleetPause(root)?.reason;
+    return standingTeamPause(root)?.reason;
 }
 /** Fold an operator pause reason to the one line every pause surface renders (the marker
  * doc's "one-line reason", the status header's badge, the alerts title, the CLI's
@@ -93,13 +94,13 @@ export function pausedReason(root) {
  * that would split an astral character and marks the cut with an ellipsis), so the CLI
  * confirmation, the marker, and every read side quote the same bounded line — a cap applied
  * only at the writer let `pause --reason <over-cap text>` print a note longer than the one
- * persisted. One home beside pauseFleet so the CLI path and any later GUI writer cannot
+ * persisted. One home beside pauseTeam so the CLI path and any later GUI writer cannot
  * drift on the shape the marker stores. */
 export function normalizePauseReason(reason) {
     const oneLine = reason === undefined ? undefined : collapseWhitespace(reason);
     return oneLine ? truncate(oneLine, PAUSE_REASON_MAX) : undefined;
 }
-/** Pause the fleet by writing its marker, the writer half of isFleetPaused's contract; the
+/** Pause the team by writing its marker, the writer half of isTeamPaused's contract; the
  * marker format ({ at: number }, pretty-printed JSON) is the one `tumwater pause` has always
  * written. `reason` is the operator's one-line why (`tumwater pause --reason <text>`):
  * folded to one line and capped at PAUSE_REASON_MAX (both normalizePauseReason) — the
@@ -109,8 +110,8 @@ export function normalizePauseReason(reason) {
  * indefinite pause lands on an already-standing one, so the CLI can report "already paused"
  * and the dashboard's toggle stays idempotent — a no-op never touches the standing reason
  * (a timed `--for` on a standing pause overwrites the deadline instead). Lives here beside
- * isFleetPaused so the producer (CLI, GUI) and every consumer read the same path. */
-export function pauseFleet(root, untilMs, reason) {
+ * isTeamPaused so the producer (CLI, GUI) and every consumer read the same path. */
+export function pauseTeam(root, untilMs, reason) {
     const marker = pausedPath(root);
     // An already-standing pause is the idempotent no-op it has always been — except under a
     // fresh `--for`, which overwrites the deadline (extend or shorten): the operator asked for
@@ -126,22 +127,46 @@ export function pauseFleet(root, untilMs, reason) {
     writeJsonAtomic(marker, body);
     return true;
 }
-/** Resume the fleet by removing its marker (a no-op if absent); returns whether a marker was
- * there to lift, mirroring pauseFleet's changed-state contract. Uses removeQuiet's
+/** Resume the team by removing its marker (a no-op if absent); returns whether a marker was
+ * there to lift, mirroring pauseTeam's changed-state contract. Uses removeQuiet's
  * never-throws delete: a marker vanishing between the check and the unlink is success, not a
  * failure worth surfacing from a toggle. */
-export function resumeFleet(root) {
+export function resumeTeam(root) {
     const marker = pausedPath(root);
     if (!fs.existsSync(marker))
         return false;
     removeQuiet(marker);
     return true;
 }
+/** Schedule a graceful team stop at `untilMs` (epoch ms): `tumwater stop --in`. Overwrites the
+ * marker, so the last write wins. */
+export function scheduleStop(root, untilMs) {
+    writeJsonAtomic(scheduledStopPath(root), { at: Date.now(), until: untilMs });
+}
+/** The scheduled stop's deadline (epoch ms), or undefined. Never throws: a missing, unreadable,
+ * or non-finite marker reads as no stop scheduled. */
+export function scheduledStopAt(root) {
+    try {
+        const body = readJsonFile(scheduledStopPath(root));
+        return typeof body?.until === "number" && Number.isFinite(body.until) ? body.until : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Drop the scheduled stop; returns whether a marker was there (resumeTeam's contract). */
+export function cancelScheduledStop(root) {
+    const marker = scheduledStopPath(root);
+    if (!fs.existsSync(marker))
+        return false;
+    removeQuiet(marker);
+    return true;
+}
 /** The roles the operator has individually paused (`tumwater pause --role <id>`): a role in
  * this set starts no new ticks — in-flight ones finish, every other role keeps ticking, the
- * director included (the operator named it deliberately). Never throws, like isFleetPaused:
+ * director included (the operator named it deliberately). Never throws, like isTeamPaused:
  * a missing or unreadable file reads as no paused roles, so observers (scheduler, dashboards)
- * can poll it every cycle without a guard. Lives here beside pauseFleet for the same
+ * can poll it every cycle without a guard. Lives here beside pauseTeam for the same
  * single-definition reason: producer (CLI, GUI) and every consumer read one module. */
 export function pausedRoles(root) {
     return readPausedRoles(pausedRolesPath(root)).roles;
@@ -176,7 +201,7 @@ function readPausedRoles(path) {
     const until = finiteNumber(state.until, undefined);
     if (until !== undefined && until <= Date.now())
         return { roles: [] };
-    return { roles: stringList(state.roles), until };
+    return { roles: stringList(state.roles).map((r) => canonicalRoleId(r)), until };
 }
 /** The paused-roles marker is structured state several processes rewrite read-modify-write
  * (the CLI's pause/resume --role and the dashboard's per-row toggle are separate processes),
@@ -204,7 +229,7 @@ function withPausedRolesLock(root, fn) {
  * command that named a different role (BUGS.md 2026-09-30). undefined when the file is
  * missing, unreadable, or carries no `until` — or a non-numeric, non-finite, or already-
  * expired one, the same wrong-shape-reads-as-absent discipline standingMarker applies to the
- * fleet marker. Dropping a non-finite value here matters beyond the read: a rewrite carries
+ * team marker. Dropping a non-finite value here matters beyond the read: a rewrite carries
  * this value into the next marker body, where JSON.stringify turns Infinity into null — which
  * the expiry rule then reads as a past deadline and resumes every role. */
 function standingRolesUntil(path) {
@@ -223,7 +248,7 @@ function writePausedRoles(path, roles, until) {
     writeJsonAtomic(path, until === undefined ? { roles, at: Date.now() } : { roles, at: Date.now(), until });
 }
 /** Pause one role by adding it to the paused-roles marker; returns whether this call changed
- * state (false when the role was already paused — idempotent like pauseFleet, so the CLI and
+ * state (false when the role was already paused — idempotent like pauseTeam, so the CLI and
  * a dashboard toggle can report "already paused"). Custom-loop ids are stored verbatim: the
  * marker must survive config edits, which is why callers resolve built-in ids without
  * touching tumwater.json (namedRole in src/operator/operator-commands.ts). */
@@ -252,8 +277,8 @@ export function pauseRole(root, role, untilMs) {
     });
 }
 /** Resume one role by removing it from the paused-roles marker; returns whether it was there
- * to lift (resume's changed-state contract, mirroring resumeFleet). The last removal deletes
- * the file outright, so a fully-resumed fleet leaves no marker behind for observers to read. */
+ * to lift (resume's changed-state contract, mirroring resumeTeam). The last removal deletes
+ * the file outright, so a fully-resumed team leaves no marker behind for observers to read. */
 export function resumeRole(root, role) {
     return withPausedRolesLock(root, () => {
         const current = pausedRoles(root);

package/dist/src/text/datetime.js

@@ -1,3 +1,4 @@
+// vocabulary: plain
 /** Local date/time formatting and calendar-day arithmetic — the zero-padded clock and
  * calendar parts, local-midnight day math, and the report-window header every display and
  * report surface (transcript run separators, the status table's last-tick cell, daily-budget
@@ -14,12 +15,18 @@ import { EVENTS_LOG_BASENAME } from "../paths.js";
 export function pad2(n) {
     return String(n).padStart(2, "0");
 }
+/** The local wall-clock `HH:MM` of an instant, the hours/minutes-only shape the burn-rate
+ * forecast, the window badge, and the role view's fallback line share. */
+export function clockHm(ms) {
+    const d = new Date(ms);
+    return `${pad2(d.getHours())}:${pad2(d.getMinutes())}`;
+}
 /** Whole seconds between two epoch-ms instants, rounded to the nearest second: `secondsSince`
  * clamps at zero (an age never goes negative when the clock skews), `secondsUntil` clamps at
  * zero the same way for the future direction (a countdown never reads negative once its
  * deadline has passed). The one home of the clamp + rounding behind every elapsed age and
  * countdown — status-render.ts's lastTickCell and nextRunCell, the queued-prompt age and
- * deliver-in suffix, the fleet pause's auto-resume countdown, and status-model.ts's sleeping
+ * deliver-in suffix, the team pause's auto-resume countdown, and status-model.ts's sleeping
  * phase label (which re-floors at 1s) all render through. The GUI page's browser
  * script keeps its own one-line twins (gui-client.ts's ageSec and its inline countdown
  * rounding — a separate runtime that cannot import TypeScript), pinned by its marked regions'
@@ -60,6 +67,15 @@ export function formatTime(d) {
 export function dayKey(ms) {
     return formatDate(new Date(ms));
 }
+/** Whole days from one `YYYY-MM-DD` key to another (negative when `toKey` is earlier). Parsed with
+ * Date.UTC so a DST shift cannot move the count by one. */
+export function daysBetween(fromKey, toKey) {
+    const utc = (key) => {
+        const [y = 0, m = 1, d = 1] = key.split("-").map(Number);
+        return Date.UTC(y, m - 1, d);
+    };
+    return Math.round((utc(toKey) - utc(fromKey)) / 86_400_000);
+}
 /** The `MM-DD` half of a `YYYY-MM-DD` day key (dayKey/formatDate): the redundant year
  * dropped for a line whose date lies inside the current window. Shared by the failure
  * digest's cluster ranges and transition stamps (failure-render.ts) and the usage report's
@@ -98,7 +114,7 @@ export function dayWindow(days, now) {
 }
 /** Compact whole-second duration: `45s`, `12m`, `3h`, or `2d` — the phrasing every relative
  * time renders through (ago labels, sleeping-remaining countdowns, `prompt --list`'s queued
- * age, the fleet pause's auto-resume countdown), so the s/m/h/d bucketing and rounding cannot
+ * age, the team pause's auto-resume countdown), so the s/m/h/d bucketing and rounding cannot
  * drift per consumer. A day or more reads days, not an hour count (`pause --for 90d`'s
  * countdown reads `90d`, not `2160h`). Lives here, beside the other time phrasing, so core
  * modules (which may not import src/ui) share the same bucketing too. */
@@ -119,6 +135,30 @@ export function humanSeconds(s) {
     }
     return `${Math.round(s / 86400)}d`;
 }
+/** Humanized duration from `now` until a future epoch-ms instant — the "how long until it
+ * happens" phrase (a scheduled wake, a timed pause's auto-resume, a hold's re-open):
+ * humanSeconds over secondsUntil in one call, collapsing the ten sites that spelled the
+ * two-step composition out, so the s/m/h/d bucketing and the past-deadline zero-clamp for
+ * the future direction have one home. Reads `0s` once the instant has passed (secondsUntil
+ * clamps at zero), matching every countdown's existing behavior. */
+export function humanUntil(atMs, now) {
+    return humanSeconds(secondsUntil(atMs, now));
+}
+/** The shared "when may this loop next act" phrase — the `next run` cell (status-render.ts's
+ * nextRunCell) and the `Next tick` line (role-render.ts's scheduleLine) render their schedule
+ * through it, so the two surfaces cannot drift on the backoff prefix or the humanSeconds
+ * bucketing. `remainSeconds` is the seconds until the next run (non-positive = due); `backoff`
+ * adds the `backoff ` prefix the wake action clears; `dueWord` names the due case and `withIn`
+ * selects the prose `in <duration>` form (the role view) over the cell's bare `<duration>`.
+ * Callers keep their own surrounding logic on either side — the status cell's in-flight `-`
+ * and its yield-scaled `×N` suffix, the role view's `not scheduled yet`. */
+export function nextRunPhrase(remainSeconds, backoff, dueWord, withIn) {
+    if (remainSeconds <= 0)
+        return dueWord;
+    const label = humanSeconds(remainSeconds);
+    const base = withIn ? `in ${label}` : label;
+    return backoff ? `sleeping ${base}` : base;
+}
 /** `N days`, singular at 1 — the window label both report headers render, so a one-day window
  * reads the same on either surface. Rendered through text/phrases.ts's plural, like every other
  * count-plus-noun phrase in the harness. */

package/dist/src/text/format.js

@@ -11,6 +11,15 @@ import { textOr } from "./text.js";
  * home of the token display format shared by the status table's gen/peak-ctx columns and the
  * commit trailer's ctx field — pinned here so those surfaces cannot drift even though they
  * live in different modules. */
+/** Append a section note to a running prompt, separated from what precedes it by a blank line.
+ * The tick and authoring-tick prompt assemblers (tick-prompt.ts, loop-tick.ts) build a prompt by
+ * stacking nameless sections — assignment, held-entry, rejected-review, conflict-discard,
+ * conflict-handback, revision and cut-off notes — each appended the same way. This is the single
+ * append so the `\n\n` section separator stays in one place. The note is appended unconditionally,
+ * exactly as the call sites appended the literal, so behavior is unchanged for any note. */
+export function appendPromptNote(prompt, note) {
+    return `${prompt}\n\n${note}`;
+}
 export function compactTokens(n) {
     if (n >= 1_000_000)
         return `${(n / 1_000_000).toFixed(1)}M`;
@@ -48,7 +57,7 @@ export function usdCap(n) {
 }
 /** A disk size in GB for display: one decimal and the unit (`12.3 GB`) — the single home of
  * the disk-size format shared by the event feed's disk lines (event-format.ts), the status
- * header's disk badge (badges.ts's `diskBadge`), the fleet's low-disk alert (fleet-alerts.ts),
+ * header's disk badge (badges.ts's `diskBadge`), the team's low-disk alert (team-alerts.ts),
  * the doctor's disk check detail (doctor-checks.ts), and `tumwater reclaim`'s freed-size line
  * (operator-commands.ts), so the decimal width and unit cannot drift per consumer. A caller
  * reading the value from an untrusted event field applies event-format.ts's `gigabytes`

package/dist/src/text/markdown.js

@@ -22,7 +22,7 @@ export function markdownTable(header, rows, align = []) {
  * the `map((item, i) => `${i + 1}. ${item}`).join("\n")` step, shared by the review prompt's
  * prior objections, its stage-fix findings, and the rejected/revision notes
  * (prompt/gate-prompts.ts) and `tumwater questions`' open-question list
- * (cli/question-commands.ts), so the numbering shape cannot drift between the surfaces that
+ * (backlog/question-answer.ts), so the numbering shape cannot drift between the surfaces that
  * read a numbered list. `empty` is returned verbatim when `items` is empty (the reasons
  * sites pass `(no reasons recorded)`; the others keep the default empty string). */
 export function numberedList(items, empty = "") {

package/dist/src/text/phrases.js

@@ -1,8 +1,9 @@
+// vocabulary: plain
 import path from "node:path";
 import { finiteNumber, isJsonObject, stringList } from "../files/json-object.js";
 import { squash } from "./text.js";
 import { shortSha, usd } from "./format.js";
-/** The single home of each human-facing PHRASE the fleet renders — the wording fragments (a pause
+/** The single home of each human-facing PHRASE the team renders — the wording fragments (a pause
  * reason's suffix, a rate-limit hold's "for 60s", a backend hold's kind, a budget transition's "$x
  * of $y", main's red-tip naming, a tool call's one-line label, the plural helper) shared by the
  * event feed (event-format.ts), the failure digest (src/failure/failure-render.ts and
@@ -14,11 +15,11 @@ import { shortSha, usd } from "./format.js";
 const NO_REASONS_GIVEN = "no reasons given";
 /** The reason an over-long prompt or config field carries: the text rides into a tick's
  * prefill, so a longer value bloats every tick's context. The single home of that tail,
- * shared by init's seed check (init/init.ts) and config-validation's customLoops task and
+ * shared by init's seed check (init/init.ts) and config-validation's customRoles task and
  * roles-instructions caps (config/config-validation.ts), so the three cannot drift on the
  * wording. inbox-submit's promptLengthProblem renders a role-scoped variant ("it rides into
  * the <role> tick's prefill") and keeps its own wording. */
-export const PREFILL_REASON = "it rides into every tick's prefill";
+export const PREFILL_REASON = "it rides into every run's prefill";
 /** The reason a review rejection leads with — its first listed reason, or `no reasons given`
  * when the list is empty or its first entry is not a string. One home so the fallback cannot
  * drift across the four surfaces that show just that first reason: the review gate's returned
@@ -33,7 +34,7 @@ export function firstReason(reasons) {
 /** A count and its noun as one phrase (`plural(3, "tick")` → `3 ticks`) — the single home of
  * the singular/plural selection the CLI's once summary (cli/cli-run.ts), the day window's day label
  * (datetime.ts), the failure digest's loss-cause lines (src/failure/failure-render.ts), and the
- * fleet alerts' banner titles (ui/fleet-alerts.ts, whose local copy this replaces), and the
+ * team alerts' banner titles (ui/team-alerts.ts, whose local copy this replaces), and the
  * build_stale lines' "N commit(s) ahead" (event-format.ts, src/failure/failure-state-change.ts —
  * the singular/plural wording their tests pin, once "N commit(s)" with the old literal, now "N
  * commits"/"1 commit"), and the stage self-check and dropped-attachment notes
@@ -48,7 +49,7 @@ export function plural(n, one, many = `${one}s`) {
  * → `is`, `agree(2, "cause", "causes")` → `causes` — the companion to plural for the slots
  * plural's count-plus-noun shape cannot fill: a subject or noun whose count is printed elsewhere in
  * the sentence (a subject phrase such as listRoles's role list, a count named earlier) still needs
- * the right number form. The fleet alerts' banner titles (ui/fleet-alerts.ts), the resume
+ * the right number form. The team alerts' banner titles (ui/team-alerts.ts), the resume
  * confirmation's still-paused note (operator/operator-commands.ts), the dropped-attachment note
  * (inbox-attachments.ts), the failure digest's loss-cause and cluster remainders
  * (failure/failure-render.ts), the doctor's oh-my-pi and model notes
@@ -59,8 +60,8 @@ export function agree(n, one, many) {
     return n === 1 ? one : many;
 }
 /** The spine of every phrase naming main's tip as red — `main <short-sha> is red` — built here
- * once so the fleet-wide red-main warning (main-red.ts), the review gate's attribution detail
- * (review.ts), the landing check's attribution error (landing-check-failures.ts), and the redeploy
+ * once so the team-wide red-main warning (main-red.ts), the review gate's attribution detail
+ * (review.ts), the merge check's attribution error (merge-check-failures.ts), and the redeploy
  * hold's block reason (src/redeploy/redeployer.ts) cannot drift over how main's red is worded. Each
  * caller appends its own consequence — the gate's "— not this change's failure", the hold's "
  * — holding the restart until main is green". */
@@ -68,8 +69,8 @@ export function mainRedPhrase(sha) {
     return `main ${shortSha(sha)} is red`;
 }
 /** The main-red attribution detail — main's redness is not this change's failure — the review
- * pre-check's reject detail (review-precheck.ts) and the landing check's lastError
- * (landing-check-failures.ts) both build as mainRedPhrase plus the consequence suffix. One
+ * pre-check's reject detail (review-precheck.ts) and the merge check's lastError
+ * (merge-check-failures.ts) both build as mainRedPhrase plus the consequence suffix. One
  * home beside mainRedPhrase so the two attribution surfaces cannot drift over the wording
  * their tests pin. The other mainRedPhrase callers keep their own consequences: main-red.ts
  * names the failing script and its action, src/redeploy/redeployer.ts holds the restart. */
@@ -78,7 +79,7 @@ export function mainRedNotMine(sha) {
 }
 /** The ` — "<reason>"` suffix the operator's pause reason (`pause --reason <text>`) rides on —
  * one home so the CLI's confirmation line (operator/operator-commands.ts), the status header's
- * pause badge (ui/badges.ts), and the paused alert's title (ui/fleet-alerts.ts) cannot drift on the
+ * pause badge (ui/badges.ts), and the paused alert's title (ui/team-alerts.ts) cannot drift on the
  * quoting. No reason, no suffix: every caller's reasonless phrasing keeps today's byte-exact form.
  * (The GUI keeps its own JS copies in gui-client.ts: a separate runtime that cannot import
  * TypeScript.) */
@@ -87,48 +88,48 @@ export function pauseReasonSuffix(reason) {
 }
 /** The harness warning a loop crossing the error-streak threshold raises — `3 consecutive
  * tick failures: <reason>` — shared by the tick-side crossing (tick-finalize.ts, an error or
- * recovery failure) and the landing-side crossing a review rejection resolves
- * (landing-slot.ts), the two sites that build the message, so the operator-facing wording
+ * recovery failure) and the merge-side crossing a review rejection resolves
+ * (merge-slot.ts), the two sites that build the message, so the operator-facing wording
  * their tests pin cannot drift between them. */
 export function consecutiveFailuresWarning(count, reason) {
-    return `${count} consecutive tick failures: ${reason}`;
+    return `${count} runs failed in a row: ${reason}`;
 }
-/** The base line for an operator fleet pause — `fleet paused — role loops stop starting new
+/** The base line for an operator team pause — `team paused — role loops stop starting new
  * ticks` — built here so the event feed (event-format.ts, which appends its own `(director
- * keeps running)` consequence) and the failure digest's Fleet state changes lines
+ * keeps running)` consequence) and the failure digest's Team state changes lines
  * (src/failure/failure-state-change.ts, which keeps the short form) cannot drift on the base
  * wording. `tumwater pause`'s confirmation (operator/operator-commands.ts) interleaves its
  * `--for`/`--reason` spans before the dash, so it composes its own line and keeps that wording
  * inline. */
-export function fleetPausePhrase() {
-    return "fleet paused — role loops stop starting new ticks";
+export function teamPausePhrase() {
+    return "team paused — roles start no new runs";
 }
-/** The base line for lifting the fleet pause — `fleet resumed — role loops tick again` —
- * shared by the event feed (event-format.ts), the failure digest's Fleet state changes lines
+/** The base line for lifting the team pause — `team resumed — roles run again` —
+ * shared by the event feed (event-format.ts), the failure digest's Team state changes lines
  * (src/failure/failure-state-change.ts), and `tumwater resume`'s confirmation
  * (operator/operator-commands.ts, which appends its `--for` and still-paused-role spans), so the
  * three cannot drift. */
-export function fleetResumePhrase() {
-    return "fleet resumed — role loops tick again";
+export function teamResumePhrase() {
+    return "team resumed — roles run again";
 }
-/** The base line for a per-role pause — `role <id> paused — it stops starting new ticks` —
- * shared by the event feed (event-format.ts, which appends `(the rest of the fleet keeps running)`)
- * and the failure digest's Fleet state changes lines (src/failure/failure-state-change.ts, which
+/** The base line for a per-role pause — `role <id> paused — it starts no new runs` —
+ * shared by the event feed (event-format.ts, which appends `(the rest of the team keeps running)`)
+ * and the failure digest's Team state changes lines (src/failure/failure-state-change.ts, which
  * deliberately keeps the short form), so the two cannot drift on the base wording. The role is
  * coerced, so the digest's byte-sliced `field()` output and the feed's raw field both render. */
 export function rolePausePhrase(role) {
-    return `role ${String(role)} paused — it stops starting new ticks`;
+    return `role ${String(role)} paused — it starts no new runs`;
 }
-/** The base line for a per-role resume — `role <id> resumed — it ticks again` — shared by the
- * event feed (event-format.ts) and the failure digest's Fleet state changes lines
+/** The base line for a per-role resume — `role <id> resumed — it runs again` — shared by the
+ * event feed (event-format.ts) and the failure digest's Team state changes lines
  * (src/failure/failure-state-change.ts), so the two cannot drift. The role is coerced, like
  * rolePausePhrase. */
 export function roleResumePhrase(role) {
-    return `role ${String(role)} resumed — it ticks again`;
+    return `role ${String(role)} resumed — it runs again`;
 }
 /** The line for an orchestrator shutdown — the event feed (event-format.ts) and the failure
- * digest's Fleet state changes lines (src/failure/failure-state-change.ts) both render it. */
-export const ORCHESTRATOR_STOPPED = "orchestrator stopped";
+ * digest's Team state changes lines (src/failure/failure-state-change.ts) both render it. */
+export const ORCHESTRATOR_STOPPED = "tumwater stopped";
 /** A HarnessEvent's loosely typed `roles` list as a `A, B, C` phrase — the single home of the
  * array coercion and join, shared by the event feed (event-format.ts: counters_reset's scope,
  * budget_handback's handed-back list, the rate_limit_hold line) and the failure digest's state-
@@ -145,7 +146,7 @@ export function rolesPhrase(roles, fallback, max, format = String) {
     return list.length > 0 ? list.join(", ") : fallback;
 }
 /** The `$<spent> of $<cap>` fragment every budget-transition event renders — the one home of that
- * phrasing, shared by the event feed (event-format.ts) and the failure digest's Fleet state changes
+ * phrasing, shared by the event feed (event-format.ts) and the failure digest's Team state changes
  * lines (src/failure/failure-state-change.ts), so a budget transition reads the same on both
  * surfaces. Both fields arrive loosely typed on HarnessEvent, so each is coerced through
  * finiteNumber (a non-number or non-finite value reads as 0, exactly as event-read.ts's eventUsage
@@ -164,7 +165,7 @@ export function shortSpanPhrase(ms) {
     return seconds < 120 ? `${seconds}s` : `${Math.round(ms / 60_000)}m`;
 }
 /** The `for <duration>[ (relapse N)]` fragment the rate_limit_hold event renders — the one home
- * of that phrasing, shared by the event feed (event-format.ts) and the failure digest's Fleet state
+ * of that phrasing, shared by the event feed (event-format.ts) and the failure digest's Team state
  * changes lines (src/failure/failure-state-change.ts), like budgetPhrase. The duration is
  * shortSpanPhrase (seconds under two minutes, so the one-minute base hold reads `60s`); the relapse
  * count is named only when the storm resumed right after an earlier hold, the one fact that says
@@ -175,8 +176,8 @@ export function holdPhrase(holdMs, escalation) {
     const relapse = Number(escalation ?? 0);
     return `for ${span}${relapse > 0 ? ` (relapse ${relapse})` : ""}`;
 }
-/** The human phrase for a fleet hold's backend-failure kind — the one home of that phrasing,
- * shared by the event feed (event-format.ts) and the failure digest's Fleet state changes
+/** The human phrase for a team hold's backend-failure kind — the one home of that phrasing,
+ * shared by the event feed (event-format.ts) and the failure digest's Team state changes
  * lines (src/failure/failure-state-change.ts), like holdPhrase above. A "rate-limit" hold (or a
  * hold with no readable kind — a torn line) never renders through this: those keep the 429
  * wording, which is the shape every historical event already has. */

package/dist/src/text/suggest.js

@@ -54,8 +54,9 @@ export function didYouMean(suggestion) {
 /** suggestClosest and didYouMean composed: the " — did you mean `x`?" suffix for a mistyped
  * `input` against `candidates`, the empty string when nothing is close enough to suggest. The
  * unknown-X error sites (roles.ts's unknownRoleMessage, config-write.ts's
- * unknownConfigKeyError and its role-field error, config-field-checks.ts's checkKnownKeys
- * and checkKnownRoleId, gui/gui-args.ts's rejectBadRole, init-templates.ts's
+ * unknownConfigKeyError and its role-field error, config-field-checks.ts's checkKnownKeys,
+ * checkKnownRoleId and its thinking-level problem, config-validation.ts's backend problem,
+ * gui/gui-args.ts's rejectBadRole, init-templates.ts's
  * unknownTemplateError) render the hint
  * through this one composition so the two-step pairing cannot drift; callers still print the
  * full valid list themselves — a suggestion only annotates it. (cli.ts's unknown-command and

package/dist/src/text/text.js

@@ -4,7 +4,7 @@
  * integer parsing. (Number, money, and hash formats — compactTokens, shortSha, usd, usdCap —
  * live in format.ts; local date/time formatting and calendar-day arithmetic live in
  * datetime.ts; terminal-column geometry — the wcwidth table and the displayWidth/
- * padToWidth/clipToWidth clippers — lives in text-width.ts; the fleet's shared wording
+ * padToWidth/clipToWidth clippers — lives in text-width.ts; the team's shared wording
  * fragments — the red-main phrase, the pause-reason suffix, the hold, budget, and backend
  * phrasings, tool-call labels — live in text/phrases.ts; the did-you-mean suggestion layer —
  * suggestClosest, didYouMean, typoSuffix — lives in text/suggest.ts; the Markdown table
@@ -191,7 +191,7 @@ export function parseNonNegativeInt(raw) {
  * with `tail` naming where the text rides once accepted. The one home of that phrasing, used
  * by init's seed check (init.ts, "the initial prompt … every tick's prefill"), inbox-submit's
  * promptLengthProblem ("the prompt … the <role> tick's prefill"), and config-validation's
- * customLoops task and roles instructions caps (both "every tick's prefill"), so the four
+ * customRoles task and roles instructions caps (both "every tick's prefill"), so the four
  * too-long messages cannot drift apart in shape. Callers keep their own subject, cap, and
  * tail; this owns only the sentence around them. */
 export function tooLongMessage(subject, n, max, tail) {

package/dist/src/tick/qa-coverage.js

@@ -1,3 +1,4 @@
+// vocabulary: plain
 import { readJsonFile, writeJsonAtomic } from "../files/json-files.js";
 import { qaCoveragePath } from "../paths.js";
 import { isJsonObject } from "../files/json-object.js";
@@ -101,7 +102,7 @@ export function renderCoverageBlock(coverage, now = Date.now()) {
         return `  ${name} — ${age} ago, ${status}`;
     });
     return [
-        "Flow coverage (from this fleet's own record; least recently exercised first):",
+        "Flow coverage (from this team's own record; least recently exercised first):",
         ...lines,
     ].join("\n");
 }