tumwater 0.2.0 → 0.4.0

package/dist/src/operator/operator-intent.js

@@ -1,21 +1,23 @@
-// vocabulary: plain
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { cancelScheduledStop, isTeamPaused, scheduleStop } from "../team/team-state.js";
 import { orchestratorAlive, readOrchestratorInfo } from "../team/orchestrator-info.js";
 import { durationLabel } from "../cli/cli-args.js";
-import { formatDate, formatTime, humanUntil } from "../text/datetime.js";
+import { formatDate, formatTime, humanUntil, DAY_MS } from "../text/datetime.js";
 import { submitRolePrompt } from "../inbox/inbox-submit.js";
 import { questionAsker } from "../backlog/question-answer.js";
-import { knownRoleIdsCached } from "../config/config.js";
+import { knownRoleIdsCached, loadConfigCached } from "../config/config.js";
+import { baseRoleOf } from "../roles/runner-ids.js";
 import { DIRECTOR_ROLE } from "../roles/roles.js";
-import { loadLoopState, saveLoopState, zeroCounters } from "../loop/loop-state.js";
+import { saveRunnerState, zeroCounters } from "../runner/runner-state.js";
+import { loadRunnerState } from "../runner/runner-state-load.js";
 import { clearBackoff } from "../scheduling/backoff.js";
 import { writeJsonAtomic } from "../files/json-files.js";
 import { reclaimPass } from "../team/reclaim.js";
 import { formatGB } from "../text/format.js";
 import { plural } from "../text/phrases.js";
+import { numberedList } from "../text/markdown.js";
 import { cancelScheduledWakes, pendingScheduledWakes } from "./operator-requests.js";
 import { abortRequestPath, reclaimRequestPath, resetRequestPath, restartRequestPath, scheduledWakeDir, wakeRequestPath, } from "../paths.js";
 /** The marker-writing cores of the operator-intent protocol, shared by every surface that writes
@@ -60,13 +62,13 @@ export function requestResetCounters(root, roles) {
     // the affected runners' in-memory copies and the runners save them, and writes the file for a
     // requested role that has no runner (a disabled role). Rewriting the files here too would be
     // a second writer racing those whole-file saves — an overwrite from a snapshot the
-    // orchestrator has since moved past (a just-ended tick's result, a claim, a schedule), which
+    // orchestrator has since moved past (a just-ended run's result, a claim, a schedule), which
     // the lost update discards. So with a live team only the marker is written; with none there
     // is no concurrent writer and the direct write is what carries the reset to the next run.
     const { live, when } = markerApplyNote(root);
     if (!live)
         for (const r of roles)
-            saveLoopState(root, zeroCounters(loadLoopState(root, r)));
+            saveRunnerState(root, zeroCounters(loadRunnerState(root, r)));
     // Atomic: a concurrent poll reading the marker mid-write would see a torn file, which
     // readJsonFile folds to null — the corrupt-marker superset that wakes/resets EVERY runner.
     // For a scheduled wake (`--in`) that superset drops notBeforeMs, firing the wake hours early.
@@ -78,32 +80,28 @@ export function requestResetCounters(root, roles) {
 }
 /** The empty-list wording both wake-list renderers share — `cancelWakes`'s no-op arm and
  * `renderWakeList`'s empty list: one literal so the two surfaces cannot drift on what an
- * operator sees when nothing is pending, plus a ` for <role>` suffix when the view was
+ * operator sees when nothing is pending, plus a ` for <roles>` suffix when the view was
  * role-scoped. */
-function noWakePending(role) {
-    return `no scheduled wake pending${role ? ` for ${role}` : ""}`;
+function noWakePending(roles) {
+    return `no scheduled wake pending${roles ? ` for ${roles.join(", ")}` : ""}`;
 }
 /** Drop pending scheduled wakes (`tumwater wake --cancel`, the dashboard's POST /api/wake-cancel):
- * every pending wake, or only `role`'s share of them. Returns the confirmation the CLI prints
- * verbatim and the GUI flashes, so the surfaces cannot drift on wording. */
-export function cancelWakes(root, role) {
-    const n = cancelScheduledWakes(root, role);
-    const forRole = role ? ` for ${role}` : "";
-    return n > 0 ? `cancelled ${plural(n, "scheduled wake")}${forRole}` : noWakePending(role);
+ * every pending wake, or only the named roles' share of them. Returns the confirmation the CLI
+ * prints verbatim and the GUI flashes, so the surfaces cannot drift on wording. */
+export function cancelWakes(root, roles) {
+    const n = cancelScheduledWakes(root, roles);
+    const forRole = roles ? ` for ${roles.join(", ")}` : "";
+    return n > 0 ? `cancelled ${plural(n, "scheduled wake")}${forRole}` : noWakePending(roles);
 }
-/** The pending scheduled wakes (`tumwater wake --list`), earliest first; with `role`, only the
- * wakes naming that loop. Entries keep their full roles list. Read-only. */
-export function listWakes(root, role, now) {
+/** The pending scheduled wakes (`tumwater wake --list`), earliest first; with `roles`, only the
+ * wakes naming any of them. Entries keep their full roles list. Read-only. */
+export function listWakes(root, roles, now) {
     const wakes = pendingScheduledWakes(root, now);
-    return role ? wakes.filter((w) => w.roles.includes(role)) : wakes;
+    return roles ? wakes.filter((w) => w.roles.some((r) => roles.includes(r))) : wakes;
 }
 /** `wake --list`'s text: one numbered line per wake, or the empty wording `cancelWakes` uses. */
-export function renderWakeList(wakes, now, role) {
-    if (wakes.length === 0)
-        return noWakePending(role);
-    return wakes
-        .map((w, i) => `${i + 1}. in ${humanUntil(w.atMs, now)} — ${w.roles.join(", ")}`)
-        .join("\n");
+export function renderWakeList(wakes, now, roles) {
+    return numberedList(wakes.map((w) => `in ${humanUntil(w.atMs, now)} — ${w.roles.join(", ")}`), noWakePending(roles));
 }
 /** The marker-writing core of `wake [--in <duration>]`, shared with the GUI's POST /api/wake:
  * clear the named roles' backoff and pull nextRunAt to now (touching ONLY the schedule —
@@ -114,9 +112,9 @@ export function renderWakeList(wakes, now, role) {
  * team stopped at submit (or restarted before the deadline) does not wake early;
  * consumeWakeRequest clears the schedules when it consumes the marker at or after the
  * deadline. The "wakes in" phrase is inMs itself, not the deadline minus a second clock read
- * (the rule timedPauseBits follows): a caller-computed deadline let a millisecond tick between
- * the two reads print "wakes in 2699999ms" for `--in 45m`. Returns the confirmation the CLI
- * prints verbatim and the GUI flashes. */
+ * (the rule timedPauseBits follows): a caller-computed deadline let a millisecond of clock
+ * time between the two reads print "wakes in 2699999ms" for `--in 45m`. Returns the
+ * confirmation the CLI prints verbatim and the GUI flashes. */
 export function requestWake(root, roles, inMs) {
     const now = Date.now();
     // Deferred only for a genuinely positive delay: zero or less reads as immediate, so the
@@ -131,7 +129,7 @@ export function requestWake(root, roles, inMs) {
     const { live, when } = markerApplyNote(root);
     if (!deferred && !live)
         for (const r of roles)
-            saveLoopState(root, clearBackoff(loadLoopState(root, r), now));
+            saveRunnerState(root, clearBackoff(loadRunnerState(root, r), now));
     // Atomic — see requestResetCounters: a torn wake marker reads as corrupt and wakes every
     // runner immediately, dropping a scheduled wake's notBeforeMs on the floor. A scheduled wake
     // gets its own file so a later wake request, immediate or scheduled, cannot overwrite it.
@@ -143,12 +141,35 @@ export function requestWake(root, roles, inMs) {
         writeJsonAtomic(wakeRequestPath(root), { at: now, roles });
     // Same liveness contract as reset-counters and pause/resume: only a live team consumes the
     // marker, so say so instead of promising a poll that will not happen.
+    const disabledNote = disabledWakeNote(root, roles);
     if (deferred)
         return (`wake scheduled for ${roles.join(", ")} — wakes in ${durationLabel(inMs)} — ` +
             (live
                 ? "the running team applies it within one poll after the deadline"
-                : "tumwater is not running — the next `tumwater start` applies it after the deadline"));
-    return `wake requested for ${roles.join(", ")} — ${applyClause(live, when, "applies it")}`;
+                : "tumwater is not running — the next `tumwater start` applies it after the deadline") +
+            disabledNote);
+    return `wake requested for ${roles.join(", ")} — ${applyClause(live, when, "applies it")}${disabledNote}`;
+}
+/** The ids among `roles` whose config entry is `enabled: false`; empty when the config
+ * cannot be read. */
+function disabledOf(root, roles) {
+    const { config } = loadConfigCached(root);
+    if (!config)
+        return [];
+    return roles.filter((id) => config.roles[baseRoleOf(id)]?.enabled === false);
+}
+/** The confirmation clause naming the woken roles that are disabled: a disabled role has no
+ * runner, so the wake only ends its sleep. Empty when none is disabled or the config
+ * cannot be read (the cached read, so a broken tumwater.json never makes a wake throw). */
+function disabledWakeNote(root, roles) {
+    const disabled = disabledOf(root, roles);
+    if (disabled.length === 0)
+        return "";
+    const one = disabled.length === 1;
+    return (`; ${disabled.join(", ")} ${one ? "is" : "are"} disabled, so the wake only ends ` +
+        `${one ? "its" : "their"} sleep — ${one ? "it" : "they"} won't run until you enable ` +
+        `${one ? "it" : "them"} with ` +
+        `tumwater config set roles.${one ? disabled[0] : "<id>"}.enabled true`);
 }
 /** Schedule a graceful team stop `inMs` from now (`tumwater stop --in`, the dashboard's "Stop the
  * team later"): the marker means nothing without a live team to consume it, so a stopped one
@@ -196,17 +217,17 @@ function requestReclaim(root) {
     const { live, when } = markerApplyNote(root);
     return `reclaim requested — ${applyClause(live, when, "reclaims idle worktrees")}`;
 }
-/** Queue a prompt for one loop and wake that loop — the one workflow `tumwater prompt
+/** Queue a prompt for one role and wake that role — the one workflow `tumwater prompt
  * --role`, the dashboard's POST /api/prompt-role, and the TUI's Ctrl+R submit all share:
- * submitRolePrompt enqueues into the loop's own queue (length-capped by the shared rule)
- * and logs under the loop, then requestWake's single-role marker brings a live team's
- * loop in within one poll instead of whenever its backoff next expires (and is safe with
+ * submitRolePrompt enqueues into the role's own queue (length-capped by the shared rule)
+ * and logs under the role, then requestWake's single-role marker brings a live team's
+ * role in within one poll instead of whenever its backoff next expires (and is safe with
  * no team running — the same contract as `tumwater wake`). Returns requestWake's
  * confirmation so a surface can show what the wake did. Keeping enqueue and wake in one
  * call keeps a surface from ever queueing a prompt without the wake that delivers it
  * promptly — the pairing is the invariant, not each surface's private discipline. An optional
  * `notBeforeMs` defers the prompt (PLANS.md "tumwater prompt --at <duration>"); the wake
- * still fires — it brings the loop in at its time to find a deliverable queue, and a queue
+ * still fires — it brings the role in at its time to find a deliverable queue, and a queue
  * holding only future prompts keeps it asleep. */
 export function submitRolePromptAndWake(root, role, text, images, notBeforeMs) {
     submitRolePrompt(root, role, text, images, notBeforeMs);
@@ -223,7 +244,7 @@ export function requestAbort(root, role) {
     writeJsonAtomic(abortRequestPath(root, role), { at: Date.now() });
     let confirmation = `abort requested for ${role} — the running team applies it within ~2s`;
     if (role === DIRECTOR_ROLE) {
-        // The director's in-flight prompt was dequeued from the inbox file at tick start and an
+        // The director's in-flight prompt was dequeued from the inbox file at run start and an
         // abort discards it without re-queueing — say so, since the discard is otherwise silent.
         confirmation +=
             "; its current in-flight prompt will be discarded (re-submit with `tumwater prompt` if you want it retried)";
@@ -263,13 +284,16 @@ export function rolePauseMessage(root, role, changed, timed, now = Date.now()) {
         return `role ${role} is already paused`;
     const { when, tail } = markerApplyNote(root);
     const { forPhrase, note } = timedPauseBits(timed, now);
-    return `role ${role} paused${forPhrase} — it starts no new runs${when} (current runs finish; the rest of the team is unaffected)${note}${tail}`;
+    const disabledNote = disabledOf(root, [role]).length > 0
+        ? `; ${role} is disabled, so it starts no runs either way — the pause holds once you enable it`
+        : "";
+    return `role ${role} paused${forPhrase} — it starts no new runs${when} (current runs finish; the rest of the team is unaffected)${note}${disabledNote}${tail}`;
 }
 /** The per-role resume confirmation, shared between `tumwater resume --role` and the TUI's
  * Ctrl+P for the same no-drift reason. Carries the team-pause interplay note cmdResume
  * phrases: the team pause is the stronger gate, so with its marker present a freshly
- * resumed role still starts no ticks (the director is exempt from that gate, so its
- * resumption is real) — saying nothing would promise ticking the scheduler then deny, the
+ * resumed role still starts no runs (the director is exempt from that gate, so its
+ * resumption is real) — saying nothing would promise running the scheduler then deny, the
  * same honest-confirmation contract markerApplyNote's tail serves. */
 export function roleResumeMessage(root, role, changed) {
     if (!changed)
@@ -278,7 +302,10 @@ export function roleResumeMessage(root, role, changed) {
     const teamNote = isTeamPaused(root) && role !== DIRECTOR_ROLE
         ? " (the team pause is still active — `tumwater resume` lifts it)"
         : "";
-    return `role ${role} resumed — it starts new runs again${when}${teamNote}${tail}`;
+    const starts = disabledOf(root, [role]).length > 0
+        ? `it is disabled, so it still starts no runs — enable it with tumwater config set roles.${role}.enabled true`
+        : "it starts new runs again";
+    return `role ${role} resumed — ${starts}${when}${teamNote}${tail}`;
 }
 /** The `tumwater pause --for <duration>` cap: 90 days. A timed pause is meant to answer "step
  * away for a while and come back to a resumed team" — the same bound the report's day windows
@@ -288,7 +315,7 @@ export function roleResumeMessage(root, role, changed) {
  * value whose wall-clock resume time no `Date` can even hold (a `--for 100000000d` once printed
  * "resumes automatically at NaN:NaN:NaN"). Lives beside the marker contract it caps, which
  * every surface shares, so no new `--for` consumer can outgrow it unnoticed. */
-export const PAUSE_FOR_MAX_MS = 90 * 24 * 60 * 60 * 1000;
+export const PAUSE_FOR_MAX_MS = 90 * DAY_MS;
 /** One manual reclaim, shared by `tumwater reclaim` and the dashboard's POST /api/reclaim: with
  * a live team the pass is requested through the marker the orchestrator consumes (so in-use
  * worktrees are respected); with none running it runs in-process, since nothing is in use.

package/dist/src/operator/operator-requests.js

@@ -1,12 +1,12 @@
-// vocabulary: plain
 import fs from "node:fs";
 import path from "node:path";
 import { logEvent, warnEvent, warnEventBestEffort, TUMWATER_SOURCE } from "../events/events.js";
-import { removeQuiet } from "../files/files.js";
+import { dirEntryNames, removeQuiet } from "../files/files.js";
 import { errorMessage } from "../text/text.js";
 import { readJsonFile, writeJsonAtomic } from "../files/json-files.js";
 import { finiteNumber } from "../files/json-object.js";
-import { loadLoopState, saveLoopState, zeroCounters } from "../loop/loop-state.js";
+import { saveRunnerState, zeroCounters } from "../runner/runner-state.js";
+import { loadRunnerState } from "../runner/runner-state-load.js";
 import { canonicalRoleId } from "../roles/legacy-role-ids.js";
 import { clearBackoff } from "../scheduling/backoff.js";
 import { abortRequestPath, reclaimRequestPath, resetRequestPath, restartRequestPath, scheduledWakeDir, statePath, wakeRequestPath, STATE_DIR, } from "../paths.js";
@@ -76,7 +76,7 @@ function warnStatePersistFailed(root, role, err) {
 }
 /** Consume a pending reset request from `tumwater reset-counters`, if any: the CLI zeroed the
  * state files only when no team was running; this zeroes the affected runners' in-memory
- * copies (which then re-save), or their next tick's save would resurrect the pre-reset values,
+ * copies (which then re-save), or their next run's save would resurrect the pre-reset values,
  * and writes the zeroed state file directly for requested roles with no runner, which the CLI
  * left to its marker. */
 export function consumeResetRequest(root, runners) {
@@ -99,7 +99,7 @@ export function consumeResetRequest(root, runners) {
     const runnerlessReset = [];
     for (const role of runnerless) {
         try {
-            saveLoopState(root, zeroCounters(loadLoopState(root, role)));
+            saveRunnerState(root, zeroCounters(loadRunnerState(root, role)));
             runnerlessReset.push(role);
         }
         catch (err) {
@@ -109,7 +109,7 @@ export function consumeResetRequest(root, runners) {
     const applied = [...affected.map((r) => r.role), ...runnerlessReset];
     if (applied.length > 0) {
         const [only] = applied;
-        // One role → filed under that loop; several → one harness-level event listing them.
+        // One role → filed under that role; several → one harness-level event listing them.
         if (applied.length === 1 && only)
             logRequestEvent(root, { source: only, type: "counters_reset" });
         else
@@ -120,7 +120,7 @@ export function consumeResetRequest(root, runners) {
 /** Consume a pending wake request from `tumwater wake [--role <id>] [--in <duration>]`, if any.
  * Immediate wakes find the state files already cleared by the CLI when no team was running; this
  * clears the affected runners' in-memory schedules (backoffSeconds, nextRunAt), or their next save
- * would resurrect the pre-wake sleep window and the loops would keep sleeping until the original
+ * would resurrect the pre-wake sleep window and the roles would keep sleeping until the original
  * backoff expired, and writes the cleared schedule directly for requested roles with no runner,
  * which the CLI left to its marker. A scheduled wake (`--in`) carries a `notBeforeMs`: before the
  * deadline the marker is left in place (a later poll retries it — the wake takes effect within one
@@ -129,7 +129,7 @@ export function consumeResetRequest(root, runners) {
  * deliberately skipped it. A non-numeric or non-finite value (a hand edit's `1e999`) reads as
  * immediate (defensive; validation happens at the CLI) — leaving Infinity as a deadline would hold
  * `notBefore > Date.now()` true forever and strand the marker, which nothing else deletes. Each
- * woken role logs the existing `wake` event with the operator reason, so the team's early ticks
+ * woken role logs the existing `wake` event with the operator reason, so the team's early runs
  * read in the feed as deliberate. */
 export function consumeWakeRequest(root, runners) {
     // A legacy wake.json (the pre-upgrade build wrote scheduled wakes here) keeps its deadline.
@@ -149,25 +149,26 @@ export function consumeWakeRequest(root, runners) {
         if (!wakeNotDue(file))
             applyWakeMarker(root, file, runners);
 }
+/** A scheduled-wake marker's deadline in ms, or undefined when it has none: undefined for a
+ * missing or corrupt marker and for a `notBeforeMs` that is absent, non-numeric, or non-finite
+ * (the "immediate" reading both the due-check and the pending-list apply — a hand edit's
+ * `1e999` must not read as a forever-out deadline). */
+function wakeDeadlineMs(markerFile) {
+    const marker = readJsonFile(markerFile);
+    return marker === null ? undefined : finiteNumber(marker.notBeforeMs, undefined);
+}
 /** Whether a wake marker's deadline still lies ahead: a missing, non-numeric, or non-finite
- * `notBeforeMs` reads as immediate, and a null (corrupt) marker is due. */
+ * `notBeforeMs` reads as immediate (one helper owns the reading), and a null (corrupt) marker
+ * is due. */
 function wakeNotDue(markerFile) {
-    const marker = readJsonFile(markerFile);
-    const notBefore = marker === null ? undefined : finiteNumber(marker.notBeforeMs, undefined);
+    const notBefore = wakeDeadlineMs(markerFile);
     return notBefore !== undefined && notBefore > Date.now();
 }
 /** The scheduled-wake files in `scheduledWakeDir`, sorted; `.tmp-<pid>` leftovers of an atomic
  * write are skipped. A missing directory is an empty list. */
 function scheduledWakeFiles(root) {
     const dir = scheduledWakeDir(root);
-    let names;
-    try {
-        names = fs.readdirSync(dir);
-    }
-    catch {
-        return [];
-    }
-    return names
+    return dirEntryNames(dir)
         .filter((n) => n.endsWith(".json"))
         .sort()
         .map((n) => path.join(dir, n));
@@ -179,8 +180,7 @@ export function pendingScheduledWakes(root, now) {
     const out = [];
     for (const file of scheduledWakeFiles(root)) {
         const roles = requestedRoles(file);
-        const marker = readJsonFile(file);
-        const atMs = marker === null ? undefined : finiteNumber(marker.notBeforeMs, undefined);
+        const atMs = wakeDeadlineMs(file);
         if (roles && roles.length > 0 && atMs !== undefined && atMs > now)
             out.push({ roles, atMs });
     }
@@ -188,26 +188,26 @@ export function pendingScheduledWakes(root, now) {
 }
 /** Drop the pending scheduled wakes (`tumwater wake --cancel`), returning how many files it
  * removed or rewrote. Only files whose deadline still lies ahead are touched; due and corrupt
- * files stay the consumer's to apply. Without `role` each pending file is removed. With `role`,
- * files not naming it are skipped, a file naming only it is removed, and a file naming others
- * too is rewritten without it (same `at` and `notBeforeMs`). */
-export function cancelScheduledWakes(root, role) {
+ * files stay the consumer's to apply. Without `roles` each pending file is removed. With `roles`,
+ * files naming none of them are skipped, a file left with no role is removed, and a file naming
+ * others too is rewritten without the listed ones (same `at` and `notBeforeMs`). */
+export function cancelScheduledWakes(root, roles) {
     let count = 0;
     for (const file of scheduledWakeFiles(root)) {
         if (!wakeNotDue(file))
             continue;
-        if (role === undefined) {
+        if (roles === undefined) {
             removeQuiet(file);
             count++;
             continue;
         }
-        const roles = requestedRoles(file);
-        if (!roles?.includes(role))
+        const named = requestedRoles(file);
+        if (!named?.some((r) => roles.includes(r)))
             continue;
         const marker = readJsonFile(file);
         if (!marker)
             continue;
-        const rest = roles.filter((r) => r !== role);
+        const rest = named.filter((r) => !roles.includes(r));
         if (rest.length === 0)
             removeQuiet(file);
         else
@@ -234,7 +234,7 @@ function applyWakeMarker(root, markerFile, runners) {
     }
     for (const role of runnerlessTargets(root, markerFile, runners)) {
         try {
-            saveLoopState(root, clearBackoff(loadLoopState(root, role), Date.now()));
+            saveRunnerState(root, clearBackoff(loadRunnerState(root, role), Date.now()));
         }
         catch (err) {
             warnStatePersistFailed(root, role, err);
@@ -270,10 +270,10 @@ export function consumeReclaimRequest(root, reclaim) {
     consumeMarkerRequest(reclaimRequestPath(root), () => reclaim?.requestManual());
 }
 /** Consume per-role abort requests from `tumwater abort --role <id>`: one marker file per role (no
- * parsing needed), so a request for an idle OR disabled loop is still cleaned up. A running tick
+ * parsing needed), so a request for an idle OR disabled role is still cleaned up. An in-flight run
  * gets killed and logs exactly one event; anything else is a silent no-op — the marker's presence
  * IS the request, removing it acknowledges. Since merge queue 3/5 a role's in-flight work is often
- * a MERGE rather than a tick, so the merge's controller is passed in: an abort for the role being
+ * a MERGE rather than a run, so the merge's controller is passed in: an abort for the role being
  * merged right now kills that too (the drain's task sees `userAborted` and discards the pinned ref
  * when the merge ends). There can be several in-flight units at once (land-queue speed 2c) — one
  * per change being verified, the merge slot's stack, and each verified change waiting for it
@@ -284,13 +284,8 @@ export function consumeReclaimRequest(root, reclaim) {
  * refs of the not-yet-processed changes for one-at-a-time recovery, which is already the
  * fallback), and the merge discards every stacked ref when it ends. */
 export function consumeAbortRequests(root, runners, merges) {
-    let markers;
-    try {
-        markers = fs.readdirSync(path.join(root, STATE_DIR));
-    }
-    catch {
-        return; // .tumwater/ missing — nothing to consume (a fresh repo before the first tick).
-    }
+    // A missing .tumwater/ (a fresh repo before the first run) reads empty — nothing to consume.
+    const markers = dirEntryNames(path.join(root, STATE_DIR));
     // Best-effort report of one marker's failure: the warning can itself throw when the
     // unwritable event feed is what failed, and there is nothing left to report on then.
     const warnFailure = (role, err) => {
@@ -319,7 +314,7 @@ export function consumeAbortRequests(root, runners, merges) {
                 merge.controller.abort();
             }
             if (runner?.state.running)
-                runner.abortTick();
+                runner.abortRun();
         }
         catch (err) {
             warnFailure(role, err);

package/dist/src/operator/retire.js

@@ -1,18 +1,17 @@
-// vocabulary: plain
 import fs from "node:fs";
 import { loadConfigSafe } from "../config/config.js";
 import { CUSTOM_NAME_RE } from "../config/config-schema.js";
 import { DIRECTOR_ROLE } from "../roles/roles.js";
-import { loopEnabled } from "../roles/loop-ids.js";
+import { runnerEnabled } from "../roles/runner-ids.js";
 import { branchExists, countCommitsInRange, currentBranch, deleteRef, isDirty, isMergedInto, refSha, targetBranch, } from "../git/git.js";
 import { errorMessage } from "../text/text.js";
-import { loadLoopState } from "../loop/loop-state.js";
+import { loadRunnerState } from "../runner/runner-state-load.js";
 import { branchName, mergeRefName, legacyLandingRefName, worktreePath } from "../paths.js";
 import { isUsableWorktree, removeWorktree } from "../git/worktree.js";
 import { roleWorktreeDir, slotForDir, updateSlotsState } from "../git/slots-state.js";
 import { pausedRoles, resumeRole } from "../team/team-state.js";
 import { git } from "../git/git-run.js";
-/** `tumwater retire --role <id>`: remove a disabled loop's persistent worktree and branch, plus the
+/** `tumwater retire --role <id>`: remove a disabled role's persistent worktree and branch, plus the
  * per-role merge ref and paused-state marker that outlive it. The safety rails and the `--force`
  * override live here, so the CLI layer (operator/operator-commands.ts) stays a thin renderer. */
 /** The role's merge pin, falling back to the legacy-named one a not-yet-migrated repo holds. */
@@ -66,8 +65,8 @@ export async function collectRetire(root, role) {
         mergeRefPresent: mergeRef !== null,
         aheadOfMain: ahead + pinnedUnmerged,
         dirty,
-        enabledInConfig: loopEnabled(config.config, role),
-        midRun: loadLoopState(root, role).running === true,
+        enabledInConfig: runnerEnabled(config.config, role),
+        midRun: loadRunnerState(root, role).running === true,
     };
 }
 /** The artifacts retire manages, in removal order. */