tumwater 0.2.0 → 0.3.0

package/dist/src/verdict/refusal.js

@@ -4,25 +4,27 @@ import { commitPathsAndDiscardRest, fileContentAt } from "../git/git.js";
 import { writeTextAtomic } from "../files/files.js";
 import { parseEntryDetails } from "../backlog/backlog-md.js";
 import { actionableEntryRanges, stripEntryStamp } from "../backlog/backlog-structure.js";
-import { entryHoldAgainst, entryKey, plannedPartKeys, refusalNote, withoutRefusalNotes, } from "../backlog/backlog-eligibility.js";
-import { baseRoleOf } from "../roles/loop-ids.js";
+import { entryHoldAgainst, refusalNote, withoutRefusalNotes } from "../backlog/backlog-eligibility.js";
+import { entryKey, plannedPartKeys } from "../backlog/backlog-parts.js";
+import { baseRoleOf } from "../roles/runner-ids.js";
 import { changedFiles } from "../git/git-diff.js";
 import { resetWorktreeToMain } from "../git/worktree.js";
 import { buildCommitMessage, commitTrailer, stampedSubject } from "../git/commit-message.js";
+import { errorMessage } from "../text/text.js";
 import { labeledLine } from "./reply-contract.js";
 import { logEventBestEffort } from "../events/events.js";
-import { clearSupersededRejection } from "../tick/tick-apply.js";
-/** Handling a refused tick (plans/refusal-and-thrash.md): the run declined its work and ended
+import { clearSupersededRejection } from "../run/run-apply.js";
+/** Handling a refused run (plans/refusal-and-thrash.md): the run declined its work and ended
  * with TUMWATER_REFUSED. Only the markdown objection note may merge — it is the durable record
- * that blocks the entry for later ticks; any non-markdown half-work is discarded, tracked edits
+ * that blocks the entry for later runs; any non-markdown half-work is discarded, tracked edits
  * via reset --hard and untracked files via clean -fd (the committed note is safe at HEAD by
  * then). A refusal with no note left resets the worktree cleanly and lets the reason live in
  * the event + lastSummary only. The note commit merges directly: md-only diffs are review-exempt
  * by construction under the gate's exemption patterns, so routing it through the gate would burn
- * nothing but add a failure mode for a record that is not code. Split out of loop.ts — which
- * keeps the tick lifecycle around it — because this is a self-contained concern with its own
+ * nothing but add a failure mode for a record that is not code. Split out of runner.ts — which
+ * keeps the run lifecycle around it — because this is a self-contained concern with its own
  * policy and its own git surface (commit-only-the-notes / reset); the only things it borrows
- * from the loop are identity, the pre-commit counters for the trailer, and the loop's shared
+ * from the runner are identity, the pre-commit counters for the trailer, and the runner's shared
  * merge wiring. */
 /** A self-contradicted refusal: the reply declares a refusal yet also carries a SUMMARY —
  * the contract field of a work-completed reply — beside non-markdown work in the worktree.
@@ -79,11 +81,14 @@ export function newlyRefusedTitles(baseMd, headMd, section) {
     })
         .map((e) => stripEntryStamp(e.title));
 }
-/** Handle a refused tick and return its outcome. Never throws: a failed note merge is recorded
- * in `state.lastError` and reported through the "refused" result like any other non-merge. */
+/** Handle a refused run and return its outcome. Never throws: a failed note merge (a non-merge
+ * result, or a throw such as a lock timeout) is recorded in `state.lastError` and reported
+ * through the "refused" result like any other non-merge. A failed write of the stripped PLANS.md
+ * logs a warning and leaves PLANS.md out of the commit, so the other notes still merge. */
 export async function handleRefusal(ctx, state, wt, pi) {
     const reason = (pi.refusedReason ?? "").trim() || "no reason given";
     const plansFile = path.join(wt, "PLANS.md");
+    let plansUnstripped = false;
     if (fs.existsSync(plansFile)) {
         const { md, dropped } = withoutBlockedPlanRefusals(await fileContentAt(wt, ctx.mainBranch, "PLANS.md"), fs.readFileSync(plansFile, "utf8"));
         if (dropped.length > 0) {
@@ -92,17 +97,27 @@ export async function handleRefusal(ctx, state, wt, pi) {
             // permanently dropping the plan entries past the cut point. writeTextAtomic is the
             // harness's one write-to-temp-then-rename entry point — the same one backlog-write.ts
             // and question-answer.ts use for the markdown backlog files.
-            writeTextAtomic(plansFile, md);
-            for (const title of dropped) {
+            try {
+                writeTextAtomic(plansFile, md);
+                for (const title of dropped) {
+                    logEventBestEffort(ctx.root, {
+                        source: ctx.role,
+                        type: "warning",
+                        message: `dropped refusal note on blocked plan "${title}": its prerequisite is still planned, so the block already holds it`,
+                    });
+                }
+            }
+            catch (err) {
+                plansUnstripped = true;
                 logEventBestEffort(ctx.root, {
                     source: ctx.role,
                     type: "warning",
-                    message: `dropped refusal note on blocked plan "${title}": its prerequisite is still planned, so the block already holds it`,
+                    message: `could not drop refusal note(s) on blocked plan(s) ${dropped.map((t) => `"${t}"`).join(", ")}: ${errorMessage(err)}; PLANS.md is left out of this refusal's commit`,
                 });
             }
         }
     }
-    const notes = (await changedFiles(wt)).filter((f) => f.toLowerCase().endsWith(".md"));
+    const notes = (await changedFiles(wt)).filter((f) => f.toLowerCase().endsWith(".md") && !(plansUnstripped && f === "PLANS.md"));
     const entries = [];
     // Best-effort naming for the entry_refused event; it must never fail the refusal.
     for (const { file, section } of [{ file: "PLANS.md", section: "Planned" }, { file: "BUGS.md", section: "Open" }]) {
@@ -119,7 +134,7 @@ export async function handleRefusal(ctx, state, wt, pi) {
     if (notes.length > 0) {
         // Subject + trailer only — a refusal carries no WHY/RISK/VERIFIED body; the reason is
         // the subject, and the trailer's turn count is the same field the friction flag reads.
-        const message = buildCommitMessage(stampedSubject(baseRoleOf(ctx.role), `refuse — ${reason}`), null, commitTrailer(ctx.role, state.runs, ctx.turns, state.peakContextTokens));
+        const message = buildCommitMessage(stampedSubject(baseRoleOf(ctx.role), `refuse — ${reason}`), null, commitTrailer(ctx.role, state.runs, ctx.turns, state.peakContextTokens, undefined, undefined, ctx.modelLine));
         commit = (await commitPathsAndDiscardRest(wt, message, notes)) ?? undefined;
     }
     if (!commit) {
@@ -128,7 +143,16 @@ export async function handleRefusal(ctx, state, wt, pi) {
         await resetWorktreeToMain(wt, ctx.mainBranch);
         return { result: "refused", summary: reason };
     }
-    const result = await ctx.merge(wt, `refused: ${reason}`);
+    let result;
+    try {
+        result = await ctx.merge(wt, `refused: ${reason}`);
+    }
+    catch (err) {
+        // A lock timeout or `cannot acquire lock`: the note stays committed on the branch for
+        // leftover recovery, as for merge_conflict.
+        state.lastError = `refusal note merge failed: ${errorMessage(err)}`;
+        return { result: "refused", summary: reason, commit };
+    }
     if (result !== "changed")
         state.lastError = `refusal note merge failed: ${result}`;
     // A merged refusal note is a merged change too: it supersedes a stale rejection exactly as

package/dist/src/verdict/reply-contract.js

@@ -1,7 +1,6 @@
-// vocabulary: plain
 /** The machine-detectable half of the reply contract every pi run must follow: the
- * TUMWATER_NOTHING_TO_DO sentinel a loop emits when it found nothing to do, the
- * TUMWATER_REFUSED line a loop emits when it declines its task, and the review gate's VERDICT
+ * TUMWATER_NOTHING_TO_DO sentinel a role emits when it found nothing to do, the
+ * TUMWATER_REFUSED line a role emits when it declines its task, and the review gate's VERDICT
  * line. This module owns both halves of that contract: the constants and detection the harness
  * uses to parse pi's replies — so the run's stream parser (pi-stream.ts) and the review gate
  * (review.ts) detect it without reaching into prompt construction, and the verdict line's shape
@@ -21,24 +20,10 @@
  * commonRules. Backlog files are included because this repo's own suite reads them
  * (backlog-structure and validation-gap tests). The header says small changes are welcome on
  * purpose: a first wording ("one false claim rejects the whole change") made the improve role
- * decline real, small improvements in lab A/B runs, citing the reviewer. Must not mention the
- * reviewer's VERDICT form (prompt tests count it in the review prompt only). */
-export const CLAIMS_RULE = `Claims — keep what your change says about itself accurate. Code changes are checked against
-the code by an adversarial reviewer before they merge, and an inaccurate claim is what gets a
-change rejected; a small, correct change is welcome:
-- State only what you verified. SUMMARY, WHY, RISK, VERIFIED, and every doc comment or
-  PLANS.md/BUGS.md line you write are claims about the code.
-- Back each universal word — "all", "every", "only", "none remain", "untested", "byte-identical",
-  "unchanged" — with the check that proves it (a grep over the source, the tests, and the docs;
-  a diff), or drop the word.
-- Never state test or suite counts: say what you ran and what you saw. When the merge gate runs
-  the project's check, tumwater attests the numbers itself.
-- Verify after your LAST edit, per "Leave the project working" above: an edit made after the last
-  green run is unverified, so verify again before you end. Order your work so the final
-  verification comes after your last edit, backlog files included.`;
-/** CLAIMS_RULE in the compact prompt every run gets (prompt.ts commonRules): the same
- * four directives, without the reasons. */
-export const CLAIMS_RULE_COMPACT = `Claims — a reviewer checks your change against the code before it merges, and an inaccurate
+ * decline real, small improvements in lab A/B runs, citing the reviewer. The rules state the
+ * directives without these reasons, since every turn re-sends them (prompt.ts). Must not mention
+ * the reviewer's VERDICT form (prompt tests count it in the review prompt only). */
+export const CLAIMS_RULE = `Claims — a reviewer checks your change against the code before it merges, and an inaccurate
 claim gets it rejected; a small, correct change is welcome:
 - State only what you verified: SUMMARY, WHY, RISK, VERIFIED, and every doc comment or
   PLANS.md/BUGS.md line you write are claims about the code.
@@ -47,7 +32,7 @@ claim gets it rejected; a small, correct change is welcome:
 - Never state test or suite counts: say what you ran and what you saw.
 - Verify after your LAST edit, backlog files included: an edit after the last green run is
   unverified.`;
-/** Sentinel a loop's pi run outputs when it found nothing worth doing (REPLY_ENDINGS below
+/** Sentinel a role's pi run outputs when it found nothing worth doing (REPLY_ENDINGS below
  * instructs it). */
 export const NOTHING_TO_DO = "TUMWATER_NOTHING_TO_DO";
 /** True when `text` declares there was nothing to do (src/pi/pi-stream.ts's stream parser scans
@@ -55,12 +40,12 @@ export const NOTHING_TO_DO = "TUMWATER_NOTHING_TO_DO";
 export function isNothingToDo(text) {
     return text.includes(NOTHING_TO_DO);
 }
-/** Sentinel a loop's pi run outputs when it declines its task (see plans/refusal-and-thrash.md):
+/** Sentinel a role's pi run outputs when it declines its task (see plans/refusal-and-thrash.md):
  * `TUMWATER_REFUSED: <one-line reason>`. The reason is the durable objection — it becomes the
- * commit subject of the refusal note and the tick's lastSummary. */
+ * commit subject of the refusal note and the run's lastSummary. */
 export const REFUSED_SENTINEL = "TUMWATER_REFUSED";
 /** The four-line SUMMARY/WHY/RISK/VERIFIED block itself — the machine-parsed half of the
- * closing contract, shared verbatim by REPLY_ENDINGS (tick, director, and resume prompts) and
+ * closing contract, shared verbatim by REPLY_ENDINGS (run, director, and resume prompts) and
  * prompt-followup.ts's buildSummaryRequestPrompt (the follow-up that recovers a missing block),
  * so they cannot drift (sibling of the NOTHING_TO_DO sentinel below, and parsed field-by-field
  * by git/commit-message.ts's labeledLine). */
@@ -70,10 +55,10 @@ export const SUMMARY_BLOCK = `  SUMMARY: <imperative one-line description of the
   VERIFIED: <what you ran and observed beyond the suite total (tumwater attests the counts), e.g. "the project's check; repro script showed X before, Y after" — write none when nothing was run>`;
 /** The reply contract's closing rule: the three mutually exclusive ways a run ends, with the
  * exact SUMMARY/WHY/RISK/VERIFIED block git/commit-message.ts parses into the commit message as the
- * last one. Shared by the tick and director rules (prompt.ts's commonRules) and
+ * last one. Shared by the run and director rules (prompt.ts's commonRules) and
  * prompt-followup.ts's resume bridge, so a resumed run ends under the same contract as a fresh
  * one. Written as an either/or list because, stated as separate rules, models filled in every
- * one: 56 team ticks ended a SUMMARY block with the nothing sentinel too, and
+ * one: 56 team runs ended a SUMMARY block with the nothing sentinel too, and
  * `TUMWATER_REFUSED: none` on completed work once made the harness discard it. The nothing
  * ending says "end your reply with", not "reply with the single line", so a run that must
  * report something first (the director's answer to a question, qa's FLOW line) can. */
@@ -110,7 +95,7 @@ export function labeledLine(text, label) {
  * exists. Anchored at line start like the VERDICT line, so prose that merely mentions the
  * sentinel mid-sentence cannot set the reason. THE ONLY source of a refusal (BUGS.md
  * 2026-09-23): a bare sentinel and a mid-sentence mention are not refusals, and a reason
- * that negates the refusal is not one either (isNegatedRefusal) — four ticks ended ordinary
+ * that negates the refusal is not one either (isNegatedRefusal) — four runs ended ordinary
  * work-completed replies with `TUMWATER_REFUSED: none` and the harness destroyed their
  * tested work. */
 export function extractRefusal(text) {
@@ -126,7 +111,7 @@ export function extractRefusal(text) {
  *   alike, each of ‘ ’ “ ” decorating either side of the token (a model's quote direction
  *   is not reliable, so both classes carry all four);
  * - the whole reason itself stating absence: `nothing to do`, `nothing to refuse`,
- *   `nothing refused`, `no refusal` — a loop that found no work reaches for these phrases
+ *   `nothing refused`, `no refusal` — a role that found no work reaches for these phrases
  *   exactly as it reaches for `none`, and they are not objections (BUGS.md 2026-09-28);
  * - with trailing sentence punctuation: `None.`, `N/A!`, `none…` — punctuation is formatting
  *   (the one-character ellipsis beside its ASCII dots);
@@ -172,7 +157,7 @@ export function isNegatedRefusal(reason) {
         // `none "nothing to do"`, `none “nothing to do”`). The hyphen stays in the class beside the
         // en/em dashes: `none - …` is the same appended-note dress as `none — …` and dropping it
         // would regress `n/a - …` replies to genuine refusals. The alternation also carries the
-        // whole-reason absence statements a loop writes instead of `none` (`nothing to do`, `nothing to
+        // whole-reason absence statements a role writes instead of `none` (`nothing to do`, `nothing to
         // refuse`, `nothing refused`, `no refusal` — same negating intent, BUGS.md 2026-09-28).
         // Anchored right after the token, so a reason that continues with a word (`none of the
         // attempted fixes work`, `nothing to do with the review`, `no refusal of my own`) stays a
@@ -184,7 +169,7 @@ export function isNegatedRefusal(reason) {
     }
     return false;
 }
-/** Extract the `qa` tick's result-carrying `FLOW: <name> — <passed|bug>` line (plans/observer-
+/** Extract the `qa` run's result-carrying `FLOW: <name> — <passed|bug>` line (plans/observer-
  * roles.md 2/2); null when absent. Built on `labeledLine`, so the label is anchored at line
  * start and a mid-sentence mention is ignored. The verdict is required: a bare `FLOW: <name>`
  * — or a reply truncated mid-verdict (`FLOW: gui-budget-cap — pa`) — is not a result, and
@@ -200,6 +185,32 @@ export function extractFlow(text) {
         return null;
     return { flow: match[1].trim(), result: match[2].toLowerCase() };
 }
+/** The shortest a filed title may be to count as a declared result. A truncated `FILED:` line
+ * cuts the title off mid-word (`FILED: #12 — tit` where the run meant `title`); requiring a
+ * title of at least this many characters keeps a torn line from being latched as a filing the
+ * run never completed, while real titles — the charter composes them from a cluster key and its
+ * count — are far longer. */
+const MIN_FILED_TITLE_LENGTH = 4;
+/** Extract the `feedback` run's result-carrying `FILED: #<n> — <title>` line (plans/feedback-
+ * role.md 2/2); null when absent. Built on `labeledLine`, so the label is anchored at line
+ * start and a mid-sentence mention is ignored. The issue number and a non-empty, non-truncated
+ * title are required: a bare `FILED:`, a line with no number (`FILED: title`), or a reply
+ * truncated mid-title (`FILED: #12 — tit`) is not a filing, and returning null leaves the
+ * per-install ledger unadvanced rather than latching a record the run never declared (the same
+ * lesson as qa's FLOW line, BUGS.md 2026-09-23). Splits on the dash/em-dash token before the
+ * title so a title that itself contains a hyphen stays intact. */
+export function extractFiled(text) {
+    const value = labeledLine(text, "FILED");
+    if (!value)
+        return null;
+    const match = /^#(\d+)\s*[—-]\s*(.+)$/.exec(value);
+    if (!match?.[1] || !match[2])
+        return null;
+    const title = match[2].trim();
+    if (title.length < MIN_FILED_TITLE_LENGTH)
+        return null;
+    return { issue: Number(match[1]), title };
+}
 // The review gate's verdict line as stated in buildReviewPrompt (prompt.ts): the reviewer
 // ends with exactly `VERDICT: approve` or `VERDICT: reject`. Anchored at line start so prose
 // that merely mentions "VERDICT:" mid-sentence cannot set the outcome, but leading horizontal

package/dist/src/version.js

@@ -1,4 +1,3 @@
-// vocabulary: plain
 import fs from "node:fs";
 import { fileURLToPath } from "node:url";
 import { readJsonFile } from "./files/json-files.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tumwater",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Opinionated autonomous development harness built on pi. You write the initial prompt; role-driven loops build the project.",
   "type": "module",
   "license": "MIT",
@@ -43,6 +43,7 @@
     "test:coverage": "node scripts/live-checkout-guard.mjs && tsc --incremental && node scripts/stamp-build.mjs && node dist/test/test-runner.js --coverage",
     "smoke:claude": "node scripts/smoke-claude.mjs",
     "smoke:opencode": "node scripts/smoke-opencode.mjs",
+    "smoke:codex": "node scripts/smoke-codex.mjs",
     "tumwater": "node scripts/tumwater.mjs"
   },
   "devDependencies": {

package/dist/src/loop/revision.js

@@ -1,70 +0,0 @@
-import { gitTry } from "../git/git-run.js";
-import { resetWorktreeToMain } from "../git/worktree.js";
-import { conflictedFiles } from "../merge/merge-git.js";
-/** The persistence count at which one repeated objection makes a rejection final
- * (plans/revise-rejected.md; the repeat-finality policy in BUGS.md 2026-10-14): each numbered
- * reason records how many consecutive revisions it has survived — a new (untagged) objection is
- * 0, a `(prior N)` restatement is 1 plus the prior round's count for that objection — and when
- * any reason reaches this count it was raised and then survived two revisions, so the change has
- * stopped converging and the rejection is final. A converging chain keeps revising while each
- * round's objections differ. */
-export const REVISION_FINAL_ON_REPEAT = 2;
-/** The hard backstop on one change's revision chain (plans/revise-rejected.md; BUGS.md
- * 2026-10-14): at this many total rejections the rejection is final even when the objections
- * never repeat, so a non-converging author cannot revise forever. Replaces the old fixed
- * `REVISION_LIMIT = 2`, which ended a converging chain at its third rejection whenever each
- * round raised a new objection. */
-export const REVISION_BACKSTOP = 6;
-/** Re-apply a rejected change `sha` onto current main as uncommitted edits in `wt`
- * (plans/revise-rejected.md): the author's next tick starts from the rejected diff instead of
- * re-deriving it. `git cherry-pick --no-commit <merge-base>..<sha>` leaves the edits in the
- * worktree without committing. On any git failure — most often a conflict with what main merged
- * since the rejection, but also a missing object — the cherry-pick is aborted and the worktree
- * reset to main, and false is returned so the caller falls back to a plain rejection note. */
-export async function applyRevision(wt, mainBranch, sha) {
-    const base = await gitTry(wt, "merge-base", mainBranch, sha);
-    if (base === null) {
-        await resetWorktreeToMain(wt, mainBranch);
-        return false;
-    }
-    const picked = await gitTry(wt, "cherry-pick", "--no-commit", `${base}..${sha}`);
-    if (picked === null) {
-        await gitTry(wt, "cherry-pick", "--abort");
-        await resetWorktreeToMain(wt, mainBranch);
-        return false;
-    }
-    return true;
-}
-/** Re-apply a handed-back change's diff onto current main with the conflict markers left in
- * place as ordinary uncommitted edits, so its author can resolve them (PLANS.md "Robust
- * conflict landing, part 2/2"). Like applyRevision it cherry-picks
- * `<merge-base>..<sha> --no-commit` onto the worktree's current main. A conflicted pick is NOT
- * aborted: the unmerged paths are read off the index, a mixed `git reset` drops the index state
- * so the marker-bearing files are plain working-tree edits the tick can commit normally, and
- * `{ applied: true, conflicted }` is returned. A failure with no unmerged paths (a missing
- * object, a bad revision) aborts, resets to main, and returns `{ applied: false }` so the
- * caller falls back to a fresh start. Never throws for a git-level failure. */
-export async function applyWithConflicts(wt, mainBranch, sha) {
-    const base = await gitTry(wt, "merge-base", mainBranch, sha);
-    if (base === null) {
-        await resetWorktreeToMain(wt, mainBranch);
-        return { applied: false, conflicted: [] };
-    }
-    const picked = await gitTry(wt, "cherry-pick", "--no-commit", `${base}..${sha}`);
-    // conflictedFiles, not a raw diff: it decodes git's C-quoted names, so a non-ASCII
-    // conflicted path is the on-disk name the prompt and hasConflictMarkers can use.
-    const conflicted = await conflictedFiles(wt);
-    if (conflicted.length > 0) {
-        // Keep the marker-bearing files, drop only the index's unmerged stage entries: a mixed
-        // reset leaves the working tree untouched, so the markers are uncommitted edits the tick
-        // stages and commits like any other author work.
-        await gitTry(wt, "reset");
-        return { applied: true, conflicted };
-    }
-    if (picked === null) {
-        await gitTry(wt, "cherry-pick", "--abort");
-        await resetWorktreeToMain(wt, mainBranch);
-        return { applied: false, conflicted: [] };
-    }
-    return { applied: true, conflicted: [] };
-}

package/dist/src/roles/loop-ids.js

@@ -1,77 +0,0 @@
-/** Loop-id arithmetic for parallel work instances (plans/parallel-work-instances.md, part 1/7). A
- * base role may run several loop ids — `feature`, `feature-2`, `bugfix-3`, … — each keying
- * its own persisted state, branch, refs, session and notebook, while every lookup that is ABOUT the
- * role (its catalog charter, model, tier, caps, scheduling class) resolves through the base role.
- * With no instances configured, every loop id is bare, so `baseRoleOf` is the identity.
- *
- * Only `feature` and `bugfix` may gain instances; any other id is returned unchanged, including a
- * custom loop whose name merely resembles an instance. */
-/** The base roles that may run more than one instance. */
-export const INSTANCE_ROLES = new Set(["feature", "bugfix"]);
-/** The instance-id shape: a base role, a dash, and an index of 2 or more (`-1` is not an
- * instance — the bare id already means instance 1). The source string is also interpolated into
- * the dashboard script (gui-client-labels.ts). */
-export const INSTANCE_ID_SOURCE = "^(feature|bugfix)-([2-9]|[1-9][0-9]+)$";
-const INSTANCE_RE = new RegExp(INSTANCE_ID_SOURCE);
-/** The base role a loop id belongs to: `feature-2` → `feature`, `bugfix-10` → `bugfix`; any
- * other id — a bare role, a custom loop, `feature-1` — is returned unchanged. */
-export function baseRoleOf(id) {
-    const m = INSTANCE_RE.exec(id);
-    return m ? m[1] : id;
-}
-/** The 1-based instance number of a loop id: 1 for a bare role or any non-instance id, N for
- * `<role>-N`. */
-export function instanceIndex(id) {
-    const m = INSTANCE_RE.exec(id);
-    return m ? Number(m[2]) : 1;
-}
-/** The instance count configured for a loop id's base role (`roles.<base>.instances`, default
- * 1). A caller tells a multi-instance base (whose unassigned ticks stage claims for their
- * siblings) from a single-runner one by this. */
-export function configuredInstances(config, id) {
-    const role = config.roles[baseRoleOf(id)];
-    return role?.instances ?? 1;
-}
-/** Is this loop id enabled? True when its base role is enabled in config and the id's instance
- * index is within that role's configured instance count (`roles.<id>.instances`, default 1). */
-export function loopEnabled(config, id) {
-    const role = config.roles[baseRoleOf(id)];
-    if (role?.enabled !== true)
-        return false;
-    return instanceIndex(id) <= configuredInstances(config, id);
-}
-/** Every loop id the config says should exist, in `config.roles` order: each enabled role's
- * bare id, then `<id>-2`…`<id>-N` for the `INSTANCE_ROLES` at their configured instance
- * count. Other roles and custom loops stay bare — only feature and bugfix may split. The one
- * answer to "which runners should exist", so the orchestrator (part 5b/7) and live reload
- * enumerate the same set. At the default instance count this returns exactly the bare ids
- * `enabledRoleIds` returns. */
-export function loopIds(config) {
-    const ids = [];
-    for (const [id, role] of Object.entries(config.roles)) {
-        if (!role.enabled)
-            continue;
-        ids.push(id);
-        if (!INSTANCE_ROLES.has(id))
-            continue;
-        const count = role.instances ?? 1;
-        for (let i = 2; i <= count; i++)
-            ids.push(`${id}-${i}`);
-    }
-    return ids;
-}
-/** The pause-marker key for a loop id. Instance 1's loop id is the bare role id, which as a pause
- * key would mean the whole role, so while the role runs several instances instance 1 pauses under
- * `<role>-1`. `-1` is a pause key only, never a loop id. Every other id is its own key. */
-export function instancePauseKey(config, loopId) {
-    return INSTANCE_ROLES.has(loopId) && configuredInstances(config, loopId) > 1
-        ? `${loopId}-1`
-        : loopId;
-}
-/** Does the per-role pause marker stop this loop id? True for its own id, its base role's id (a
- * whole-role pause), or — for the bare id of an instance role — the `<role>-1` pause key. */
-export function loopPaused(paused, loopId) {
-    return (paused.has(loopId) ||
-        paused.has(baseRoleOf(loopId)) ||
-        (INSTANCE_ROLES.has(loopId) && paused.has(`${loopId}-1`)));
-}