tumwater 0.2.0 → 0.3.0

package/dist/src/roles/role-render.js

@@ -1,12 +1,13 @@
-// vocabulary: plain
+import { joinParts } from "../text/text.js";
 import { agree, shortSpanPhrase } from "../text/phrases.js";
 import { compactTokens, usd } from "../text/format.js";
-import { clockHm, formatTimestamp, humanSeconds, nextRunPhrase, secondsSince, secondsUntil } from "../text/datetime.js";
+import { clockHm, formatTimestamp, humanAgo, nextRunPhrase, secondsUntil } from "../text/datetime.js";
 import { claudeWindowLabel } from "../agent/claude/claude-account.js";
+import { windowLabel } from "../agent/subscription-account.js";
+import { backendDisplayName } from "../agent/backend-traits.js";
 import { yieldMultiplierSuffix } from "../scheduling/backoff.js";
 import { quietWindowEnd } from "../scheduling/quiet-hours.js";
-import { isAgentId } from "../config/model-selector.js";
-/** The terminal's view of one loop — what `tumwater role <id>` prints, rendered as Markdown
+/** The terminal's view of one role — what `tumwater role <id>` prints, rendered as Markdown
  * from the payload role-view.ts's rolePayload collects (the same document `--json` prints).
  * Like backlog-render.ts, the renderer owns no collection of its own: the CLI's --json and
  * human branches share one collection through sayJsonOrRender's thunk, so the two surfaces
@@ -15,7 +16,7 @@ import { isAgentId } from "../config/model-selector.js";
  * prose-and-shell markdown the operator may copy verbatim — with the fence grown past any
  * backtick run the text itself contains, so a prompt that quotes a fence still round-trips.
  * Unset things render as explicit `_(none)_` lines rather than disappearing, so an
- * un-overridden loop reads as fully defaulted, not as a truncated report. */
+ * un-overridden role reads as fully defaulted, not as a truncated report. */
 /** A code fence one longer than any backtick run in the fenced text, so the block always
  * closes where the text itself would have ended it. */
 function fenceFor(text) {
@@ -31,22 +32,22 @@ function fencedOrNone(label, text, noneNote = "none") {
     const fence = fenceFor(text);
     return [`## ${label}`, "", fence, text.replace(/\n+$/, ""), fence, ""];
 }
-/** The Notebook and Next tick prompt blocks and the "more waits" disclosure, as Markdown
- * lines — the read-only inspection the TUI's notebook view and `tumwater role <id>` share,
- * so the terminal and the CLI show one loop's notebook and assembled prompt identically.
+/** The Notes and Next run prompt blocks and the "more waits" disclosure, as Markdown
+ * lines — the read-only inspection the TUI's notes view and `tumwater role <id>` share,
+ * so the terminal and the CLI show one role's notes and assembled prompt identically.
  * `renderRoleMarkdown` splices these at the same position, so the extracted function and the
  * full document cannot drift. */
 export function inspectMarkdownLines(p) {
     const running = chainStepLine(p);
     return [...(running ? [running, ""] : []), ...inspectBodyLines(p)];
 }
-/** The notebook, prompt and disclosure blocks alone — what renderRoleMarkdown splices after
+/** The notes, prompt and disclosure blocks alone — what renderRoleMarkdown splices after
  * its own Team lines, which already carry the fallback-step bullet. */
 function inspectBodyLines(p) {
     const lines = [];
     lines.push(...fencedOrNone("Notes", p.notes, "none yet — the role's own earlier runs write them, and the director has none"));
     lines.push(...fencedOrNone("Next run's prompt", p.nextPrompt, "nothing to do this run"));
-    // tick-prompt.ts dequeues exactly one queued prompt per tick, so with more than one
+    // run-prompt.ts dequeues exactly one queued prompt per run, so with more than one
     // waiting the block above shows only the oldest — say so, so the count line and the
     // block never read as a contradiction (the 2026-10-04 BUGS.md entry under ## Fixed).
     if (p.inboxCount > 1 && p.nextPrompt !== null && p.nextPrompt.trim() !== "") {
@@ -59,11 +60,11 @@ function inspectBodyLines(p) {
  * `model` alone when only the model is (the join simply drops unset halves) — shared by the
  * main line and the budget-fallback line, so the two render the same wiring the same way. */
 function modelPair(provider, model) {
-    return [provider, model].filter(Boolean).join("/");
+    return joinParts([provider, model], "/");
 }
 /** The backend's own-default label when no model resolves: `<agent> default` — pi's
  * historical `pi default` for the pi backend, `claude default` for claude (part 4f/7). */
-function agentDefault(p) {
+function backendDefault(p) {
     return `${p.backend !== "pi" ? p.backend : "pi"} default`;
 }
 /** The provider/model wiring as one readable token: `provider/model` when both resolve,
@@ -75,11 +76,11 @@ function modelLine(p) {
     // level (piDefault is formatted with the effective thinking winning), so the separate
     // ` (thinking: …)` suffix is dropped for this case only.
     if (p.piDefault)
-        return `${agentDefault(p)} (${p.piDefault})`;
+        return `${backendDefault(p)} (${p.piDefault})`;
     const pair = modelPair(p.provider, p.model);
     const thinking = p.thinking ? ` (thinking: ${p.thinking})` : "";
     if (!pair)
-        return `${agentDefault(p)}${thinking}`;
+        return `${backendDefault(p)}${thinking}`;
     const agent = p.backend !== "pi" ? `${p.backend}/` : "";
     return `${agent}${pair}${thinking}`;
 }
@@ -89,9 +90,8 @@ function modelLine(p) {
  * backend-default label. One home for the Model fallback and Budget fallback lines, so a
  * claude fallback reads `claude/claude-sonnet-5-5`, not a bare id (PLANS.md "Mixed claude +
  * pi fleets, part 3/4" gap 7). */
-function fallbackPairLabel(fb, agentDefault) {
-    const agentBackend = (fb.backend !== undefined && fb.backend !== "pi" ? fb.backend : undefined) ??
-        (fb.provider !== undefined && isAgentId(fb.provider) ? fb.provider : undefined);
+function fallbackPairLabel(fb, backendDefault) {
+    const agentBackend = fb.backend !== undefined && fb.backend !== "pi" ? fb.backend : undefined;
     if (fb.model !== undefined) {
         if (agentBackend !== undefined)
             return `${agentBackend}/${fb.model}`;
@@ -99,12 +99,27 @@ function fallbackPairLabel(fb, agentDefault) {
     }
     if (fb.provider !== undefined)
         return fb.provider;
-    return agentDefault;
+    return backendDefault;
 }
-/** Why a tier moved down its fallback chain, as the role view words it. */
-function chainReasonPhrase(reason, windowType) {
+/** The backend-and-window label the role view shows for a non-claude backend's window:
+ * `backendDisplayName(billingBackend)` beside `windowLabel(windowType)` — "Codex 7d" for a
+ * codex subscription (plans/codex-backend.md part 3c/9), so a reader knows whose window it
+ * is. Claude keeps today's bare window type ("5h") so its role view stays byte-identical. */
+function billingWindowLabel(billingBackend, windowType) {
+    const type = windowType !== undefined ? windowLabel(windowType) : "";
+    const backend = billingBackend !== undefined && billingBackend !== "claude" ? backendDisplayName(billingBackend) : "";
+    return [backend, type].filter(Boolean).join(" ");
+}
+/** Why a tier moved down its fallback chain, as the role view words it. The window phrase
+ * names the backend in play ("Codex 7d window used up") when a non-claude backend moved the
+ * role; claude keeps today's wording byte-identical, and an unknown backend falls back to
+ * today's hardcoded "Claude". */
+function chainReasonPhrase(reason, billingBackend, windowType) {
     switch (reason) {
         case "window":
+            if (billingBackend !== undefined && billingBackend !== "claude") {
+                return `${billingWindowLabel(billingBackend, windowType)} window used up`;
+            }
             return `${windowType !== undefined ? claudeWindowLabel(windowType) : "Claude"} window used up`;
         case "reserve":
             return "window reserve reached";
@@ -125,10 +140,10 @@ function chainStepLine(p) {
     if (!c)
         return null;
     const resets = c.returnsAt !== undefined ? `, resets ${clockHm(c.returnsAt)}` : "";
-    return `- Running on fallback ${c.step} of ${c.of} (${chainReasonPhrase(c.reason, p.billingWindow)}${resets})`;
+    return `- Running on fallback ${c.step} of ${c.of} (${chainReasonPhrase(c.reason, p.billingBackend, p.billingWindow)}${resets})`;
 }
-/** One recent tick outcome as a Markdown bullet line — `<time> · <result> · <span> —
- * <summary>` — so `tumwater role <id>` and the TUI notebook view read a loop's discrete
+/** One recent run outcome as a Markdown bullet line — `<time> · <result> · <span> —
+ * <summary>` — so `tumwater role <id>` and the TUI notes view read a role's discrete
  * outcomes at a glance. `time` is the same local `YYYY-MM-DD HH:MM:SS` stamp the model-
  * fallback `since` prints (formatTimestamp); `span` is the same short-duration phrasing
  * shortSpanPhrase renders for holdPhrase and the event feed's countdowns; the summary is
@@ -142,29 +157,29 @@ function recentOutcomeLine(o) {
         line += ` — ${o.summary}`;
     return line;
 }
-/** One quiet-hours bullet: the window, whose it is, and whether it holds the loop now — with
+/** One quiet-hours bullet: the window, whose it is, and whether it holds the role now — with
  * the same `quiet until <end>` text the status table uses. */
 function quietHoursLine(w) {
     const whose = w.scope === "role" ? "own window" : "team window";
     const state = w.inWindow ? `holding now — quiet until ${quietWindowEnd(w.window)}` : "not holding now";
     return `- Quiet hours: ${w.window} (${whose}; ${state})`;
 }
-/** The loop's schedule as Markdown bullet lines — `Next tick`, `Last tick`, then one
+/** The role's schedule as Markdown bullet lines — `Next run`, `Last run`, then one
  * `Quiet hours` line per governing window (none when the payload carries no windows) — in the
  * same words and wording family as the team surface's `next run` cell (status-render.ts's
- * nextRunCell), so the role view and the status table cannot drift on when a loop acts next:
- * a never-scheduled loop (nextRunAt 0) reads `not scheduled yet`; a due loop reads `due now`;
+ * nextRunCell), so the role view and the status table cannot drift on when a role acts next:
+ * a never-scheduled role (nextRunAt 0) reads `not scheduled yet`; a due role reads `due now`;
  * a future one reads `in <Ns>` through humanSeconds, prefixed `backoff ` while backoffSeconds
  * > 0 (the wake row-action clears exactly that) — the shared nextRunPhrase, so the role view
  * and the status `next run` cell cannot drift on the backoff prefix or the humanSeconds
- * bucketing. `Last tick` reuses formatTimestamp and the same `humanSeconds … ago` phrasing the
- * status `last tick` cell ages with, or `never` for a loop that has not ticked. `now` is
+ * bucketing. `Last run` reuses formatTimestamp and the same `humanSeconds … ago` phrasing the
+ * status `last run` cell ages with, or `never` for a role that has not run. `now` is
  * injected (default Date.now()) so the renderer stays a pure function of the payload and the
  * test can pin a fixed clock. */
 function scheduleLine(p, now) {
     // The yield multiplier rides the line as `×N` exactly like nextRunCell/fmtNextRun: a quiet
-    // yield-scaled loop's effective gap is longer than nextRunAt's countdown shows (isEligible
-    // gates on the multiplier too), so the Schedule must not understate when the loop acts next.
+    // yield-scaled role's effective gap is longer than nextRunAt's countdown shows (isEligible
+    // gates on the multiplier too), so the Schedule must not understate when the role acts next.
     const suffix = yieldMultiplierSuffix(p.yieldMultiplier);
     let next;
     if (p.nextRunAt <= 0) {
@@ -175,11 +190,11 @@ function scheduleLine(p, now) {
         next = nextRunPhrase(remain, p.backoffSeconds > 0, "due now", true) + suffix;
     }
     const last = p.lastRunEndedAt !== undefined
-        ? `${formatTimestamp(p.lastRunEndedAt)} (${humanSeconds(secondsSince(p.lastRunEndedAt, now))} ago)`
+        ? `${formatTimestamp(p.lastRunEndedAt)} (${humanAgo(p.lastRunEndedAt, now)})`
         : "never";
     return [`- Next run: ${next}`, `- Last run: ${last}`, ...(p.quietHours ?? []).map(quietHoursLine)];
 }
-/** Render one loop's inspection payload as Markdown. `now` is injected (default Date.now())
+/** Render one role's inspection payload as Markdown. `now` is injected (default Date.now())
  * so the schedule lines stay a pure function of the payload — the test pins a fixed clock. */
 export function renderRoleMarkdown(p, now = Date.now()) {
     const lines = [`# tumwater role: ${p.id}`, ""];
@@ -194,15 +209,15 @@ export function renderRoleMarkdown(p, now = Date.now()) {
     // unresolvable pair, a model with no declared window).
     lines.push(`- Context window: ${p.contextWindow === null ? "unknown" : `${compactTokens(p.contextWindow)} tokens`}`);
     // Per-provider concurrency cap (plans/provider-concurrency.md §8): name the key whose cap
-    // bounds the role's concurrent ticks, plus the cap itself. Present only while
+    // bounds the role's concurrent runs, plus the cap itself. Present only while
     // `maxConcurrentPerProvider` maps this seam's key — a cap-less default team has no
     // resolvable key entry, so its role view renders no new line and stays byte-identical.
     if (p.providerKey !== undefined && p.providerCap !== undefined) {
         lines.push(`- Provider: ${p.providerKey} (cap ${p.providerCap})`);
     }
-    // Image input (plans/image-input.md "Surfaces", part 5/5): whether this loop's own model
-    // reads images, and — when it cannot — where a tick that reads an image reroutes. Not just
-    // `yes`/`no`: a text-only loop that falls back names the target, so `tumwater role <id>`
+    // Image input (plans/image-input.md "Surfaces", part 5/5): whether this role's own model
+    // reads images, and — when it cannot — where a run that reads an image reroutes. Not just
+    // `yes`/`no`: a text-only role that falls back names the target, so `tumwater role <id>`
     // explains the team alert without running doctor. Unknown (null) renders `unknown` rather
     // than guessing.
     const images = p.imageInput === true
@@ -216,11 +231,11 @@ export function renderRoleMarkdown(p, now = Date.now()) {
     // Model failure fallback, part 2/2: name the off-model pair, when the episode began, and
     // the provider-class failure that tripped it, so `tumwater role <id>` explains the state.
     if (p.modelFallback) {
-        const pair = fallbackPairLabel(p.modelFallback, agentDefault(p));
+        const pair = fallbackPairLabel(p.modelFallback, backendDefault(p));
         lines.push(`- Model fallback: ${pair} — on fallback since ${formatTimestamp(p.modelFallback.since)} (primary failing: ${p.modelFallback.reason})`);
     }
     if (p.fallback) {
-        const pair = fallbackPairLabel(p.fallback, agentDefault(p));
+        const pair = fallbackPairLabel(p.fallback, backendDefault(p));
         lines.push(`- Over-cap model: ${pair} (${p.fallbackFree ? "free" : "priced"})`);
     }
     const running = chainStepLine(p);
@@ -229,17 +244,19 @@ export function renderRoleMarkdown(p, now = Date.now()) {
     // The claude seam's billing (plans/agent-backends.md §7/§8, PLANS.md part 6d/7): absent on
     // a pi seam, so its role view is byte-identical to before.
     if (p.billing) {
-        const window = p.billing === "subscription" && p.billingWindow ? ` (${claudeWindowLabel(p.billingWindow)} window)` : "";
+        const window = p.billing === "subscription" && p.billingWindow
+            ? ` (${billingWindowLabel(p.billingBackend, p.billingWindow)} window)`
+            : "";
         lines.push(`- Billing: ${p.billing === "api" ? "API" : p.billing}${window}`);
     }
     lines.push(`- Min run interval: ${p.minRunIntervalSeconds}s`);
     if (p.instances !== undefined)
         lines.push(`- Instances: ${p.instances}`);
     lines.push(`- Inbox: ${p.inboxCount}`);
-    // The loop's own spend over its retained event window (role-view.ts's usage, summed from the
-    // same run_end events recentOutcomes reads): how much the loop burned on tokens and cost,
+    // The role's own spend over its retained event window (role-view.ts's usage, summed from the
+    // same run_end events recentOutcomes reads): how much the role burned on tokens and cost,
     // with a notional suffix only when a claude-subscription seam burned non-zero notional spend
-    // (plans/agent-backends.md part 6a). Absent for a never-costly loop, so old `tumwater role`
+    // (plans/agent-backends.md part 6a). Absent for a never-costly role, so old `tumwater role`
     // goldens are byte-identical.
     if (p.usage) {
         let spend = `- Spend: ${usd(p.usage.costUsd)} · ${compactTokens(p.usage.tokens)} tokens`;
@@ -248,7 +265,7 @@ export function renderRoleMarkdown(p, now = Date.now()) {
         lines.push(spend);
     }
     // The per-role daily cap (role-view.ts's dailyCap): today's spend against the cap and whether
-    // it holds the loop now. Absent without a cap, so old goldens are unchanged.
+    // it holds the role now. Absent without a cap, so old goldens are unchanged.
     if (p.dailyCap) {
         const dc = p.dailyCap;
         let cap = `- Daily cap: ${usd(dc.spentUsd)} of ${usd(dc.capUsd)} spent today (${dc.over ? "holding now — no new runs until local midnight" : "not holding"})`;
@@ -256,14 +273,14 @@ export function renderRoleMarkdown(p, now = Date.now()) {
             cap += ` · shared by ${dc.roleIds.join(", ")}`;
         lines.push(cap);
     }
-    // The loop's schedule (role-view.ts's nextRunAt/backoffSeconds/lastRunEndedAt, read from
-    // the same persisted state): when it may tick again, and when it last did — the one
-    // place the team's `next run`/`last tick` vocabulary was absent. Rendered from the
+    // The role's schedule (role-view.ts's nextRunAt/backoffSeconds/lastRunEndedAt, read from
+    // the same persisted state): when it may run again, and when it last did — the one
+    // place the team's `next run`/`last run` vocabulary was absent. Rendered from the
     // injected `now`, so the lines stay a pure function of the payload.
     lines.push(...scheduleLine(p, now));
-    // The loop's recent tick outcomes (role-view.ts's recentOutcomes, read from the event log):
-    // one line per outcome so `tumwater role <id>` shows what the loop has been DOING, not just
-    // what it is. Absent (never ticked) renders nothing new, so old goldens are byte-identical.
+    // The role's recent run outcomes (role-view.ts's recentOutcomes, read from the event log):
+    // one line per outcome so `tumwater role <id>` shows what the role has been DOING, not just
+    // what it is. Absent (never run) renders nothing new, so old goldens are byte-identical.
     if (p.recentOutcomes && p.recentOutcomes.length > 0) {
         lines.push("", "## Recent runs", "");
         for (const o of p.recentOutcomes)

package/dist/src/roles/role-view.js

@@ -1,8 +1,7 @@
-// vocabulary: plain
-/** One loop's read-only inspection payload — the collector behind `tumwater role <id>`:
- * what the loop IS (catalog entry or custom, enabled, paused, tier), what it RUNS ON
+/** One role's read-only inspection payload — the collector behind `tumwater role <id>`:
+ * what the role IS (catalog entry or custom, enabled, paused, tier), what it RUNS ON
  * (resolved provider/model, the budget fallback pair), what it CARRIES (the instructions
- * override and the role's own find text verbatim), and what its NEXT tick's prompt will
+ * override and the role's own find text verbatim), and what its NEXT run's prompt will
  * read like, assembled through the preview seam so nothing queued is consumed. Split out
  * of cli.ts like backlogPayload and status/status-data.ts's snapshot so the collector is testable
  * without the CLI and one renderer consumes exactly this shape. Every read degrades like
@@ -13,21 +12,23 @@ import { defaultConfig, enabledRoleIds, isCustomRole, knownRoleIds, loadConfigSa
 import { DIRECTOR_ROLE, customRole, roleById, roleTier, unknownRoleMessage } from "./roles.js";
 import { queuedRolePromptCount } from "../inbox/inbox.js";
 import { pausedRoles } from "../team/team-state.js";
-import { loadLoopState } from "../loop/loop-state.js";
-import { baseRoleOf, loopIds, loopPaused } from "./loop-ids.js";
+import { loadRunnerState } from "../runner/runner-state-load.js";
+import { baseRoleOf, runnerIds, runnerPaused } from "./runner-ids.js";
 import { roleCapVerdicts } from "../gates/role-cap-gates.js";
 import { yieldMultiplierFor } from "../scheduling/backoff.js";
 import { quietHoursStatus } from "../scheduling/quiet-hours.js";
-import { assembleTickPrompt } from "../tick/tick-prompt.js";
+import { assembleRunPrompt } from "../run/run-prompt.js";
 import { configForRole, resolvedModelFields, reviewRunConfig, roleSeamTier, seamConcurrencyKey } from "../config/config-views.js";
 import { fallbackPair, modelFallbackView } from "../config/config-fallbacks.js";
 import { fallbackModelPair, piModelsPath, seamContextWindow } from "../pi/pi-models.js";
 import { readOpencodeCache } from "../agent/opencode/opencode-catalog.js";
 import { formatModelSelector } from "../config/model-selector.js";
 import { roleImageInfo } from "../agent/image-input.js";
+import { readPiListedModels } from "../pi/pi-listed-models.js";
 import { readImageProbeCache } from "../doctor/image-probe.js";
 import { piSettingsPath, readPiDefaultModel } from "../pi/pi-settings.js";
-import { claudeWindowEntries, readClaudeAccount } from "../agent/claude/claude-account.js";
+import { readClaudeAccount } from "../agent/claude/claude-account.js";
+import { readAccount, windowEntries } from "../agent/subscription-account.js";
 import { CONFIG_BASENAME, configPath, roleNotesPath } from "../paths.js";
 import { readTextOrNull } from "../files/files.js";
 import { eventRole, eventUsage, readEvents } from "../events/event-read.js";
@@ -49,7 +50,7 @@ export function rawRoleField(root, roleId, field) {
         return undefined;
     return obj[field];
 }
-/** Collect one loop's inspection payload. `modelsPath` overrides pi's model definitions location
+/** Collect one role's inspection payload. `modelsPath` overrides pi's model definitions location
  * — a test seam, like status/status-data.ts's snapshot — consulted only when a fallback pair is
  * configured (the freeness verdict needs the definitions; nothing else does). */
 export function rolePayload(root, typedRole, modelsPath = piModelsPath(), now = new Date()) {
@@ -61,30 +62,37 @@ export function rolePayload(root, typedRole, modelsPath = piModelsPath(), now =
     const cfg = config ?? defaultConfig();
     const catalog = roleById(role);
     const customEntry = cfg.customRoles.find((c) => c.name === role);
-    // The director is inspectable like any loop but has no catalog entry: a pseudo-Role whose
+    // The director is inspectable like any role but has no catalog entry: a pseudo-Role whose
     // find text is empty (rolePayload nulls it below — the director's queued prompts ARE its
     // work), so the unknown-role throw only fires for ids nothing can answer.
     const resolved = catalog ??
         (customEntry ? customRole(customEntry.name, customEntry.task)
             : role === DIRECTOR_ROLE ? { id: DIRECTOR_ROLE, title: DIRECTOR_ROLE, find: "" }
                 : undefined);
-    if (!resolved) {
+    // roleById maps any `feature-N` to its base whatever the config runs, so an instance id
+    // counts only when knownRoleIds (the ids the config runs) holds it.
+    if (!resolved || !knownRoleIds(cfg).includes(role)) {
         // The one unknown-role answer (unknownRoleMessage): the CLI's main catch turns the throw
         // into `tumwater: <message>` with exit 1, so the collector keeps the wording and the CLI
         // stays a thin peel-parse-print layer.
         throw new Error(unknownRoleMessage(role, knownRoleIds(cfg)));
     }
     const effective = configForRole(cfg, role);
-    // The claude billing answer, read when a claude seam is in play — the role's OWN seam, or
-    // the review gate's when the reviewer runs claude (PLANS.md "Mixed claude + pi fleets, part
-    // 3/4" gap 7): a pi author on a claude reviewer still shows where its changes' spend lands.
-    // Its subscription window's primary type rides along for the renderer's label. The account
-    // file is team-global, so either seam reads the same answer.
-    const claudeInPlay = effective.agent === "claude" || (cfg.review.enabled && reviewRunConfig(cfg).agent === "claude");
-    const account = claudeInPlay ? readClaudeAccount(root) : null;
+    // The subscription backend whose billing is in play — the role's OWN seam when it routes
+    // to a non-pi backend, else the review gate's backend when the reviewer runs a non-pi
+    // backend (today's claude precedence generalized off the literal "claude", part 3c/9;
+    // PLANS.md "Mixed claude + pi fleets, part 3/4" gap 7): a pi author on a claude/codex
+    // reviewer still shows where its changes' spend lands. Read that backend's account; the
+    // account file is team-global, so either seam reads the same answer. Its subscription
+    // window's primary type rides along for the renderer's label.
+    const roleBackend = effective.agent !== undefined && effective.agent !== "pi" ? effective.agent : undefined;
+    const reviewAgent = reviewRunConfig(cfg).agent;
+    const reviewBackend = cfg.review.enabled && reviewAgent !== undefined && reviewAgent !== "pi" ? reviewAgent : undefined;
+    const billingBackend = roleBackend ?? reviewBackend;
+    const account = billingBackend !== undefined ? readAccount(root, billingBackend) : null;
     const info = readOrchestratorInfo(root);
     const chainStep = (orchestratorAlive(root, info) && info?.chain?.[roleSeamTier(cfg, role)]) || null;
-    const billingWindow = account?.billing === "subscription" ? claudeWindowEntries(account)[0]?.type : undefined;
+    const billingWindow = account?.billing === "subscription" ? windowEntries(account)[0]?.type : undefined;
     // pi's own saved default for a pi seam that resolves no model, read once beside the models
     // catalog this collector already takes as a seam (piSettingsPath). The config's `thinking`
     // wins over the default's because tumwater passes it to pi as `--thinking`, mirroring the
@@ -117,28 +125,34 @@ export function rolePayload(root, typedRole, modelsPath = piModelsPath(), now =
     // gate does) keeps them on one answer. OpenCode's `catalog` is threaded the way claude's
     // `account` is: absent, an opencode pair reads NOT free.
     const opencodeCatalog = readOpencodeCache(root);
-    const freeFallback = declaredFallback ? fallbackModelPair(cfg, modelsPath, readClaudeAccount(root), opencodeCatalog) : null;
+    // The claude account answer (6a/7), read the way the budget gate reads it — always, so the
+    // fallback price verdict sees the subscription even when claude is not this role's own seam
+    // (a pi role may still fall back to claude). The lookup returns it only for "claude" (part
+    // 2a/9) — no caller asks for another backend yet.
+    const claudeFallbackAccount = readClaudeAccount(root);
+    const accounts = (b) => (b === "claude" ? claudeFallbackAccount : null);
+    const freeFallback = declaredFallback ? fallbackModelPair(cfg, modelsPath, accounts, opencodeCatalog) : null;
     const fallback = freeFallback ?? declaredFallback;
-    // One state read serves both the model-fallback episode and the next-tick preview below.
-    const state = loadLoopState(root, role);
+    // One state read serves both the model-fallback episode and the next-run preview below.
+    const state = loadRunnerState(root, role);
     const episode = state.modelFallback;
-    // The loop's recent tick outcomes, read from the event log (readEvents) so the command
+    // The role's recent run outcomes, read from the event log (readEvents) so the command
     // answers with the team stopped and never touches live state. readEvents returns the log's
     // newest events in file (chronological) order, so filtering to this role's run_end events
     // and taking the last 8 yields the newest 8, reversed to newest-first. Durations and
     // summaries ride along only when the event carried them (a torn or empty line drops them),
-    // and an empty result is omitted so a never-ticked loop carries no `recentOutcomes` at all.
-    // One event-log read serves both per-loop facts — the recent outcomes and the spend sum — so
+    // and an empty result is omitted so a never-run role carries no `recentOutcomes` at all.
+    // One event-log read serves both per-role facts — the recent outcomes and the spend sum — so
     // the two cannot drift on what they cover: filtered to this role's run_end events once, then
     // the outcome projection keeps the newest valid 8 while the usage fold sums the whole window.
     const events = readEvents(root);
-    const tickEnds = events.filter((ev) => ev.type === "run_end" && eventRole(ev) === role);
+    const runEnds = events.filter((ev) => ev.type === "run_end" && eventRole(ev) === role);
     // The event log is read without a shape filter, so a torn or hand-edited run_end line can
     // carry a non-numeric ts/durationMs or an empty result — the same foreign shape every other
     // consumer guards with finiteNumber. A line with no usable ts or result is as unusable as
-    // an absent one (the same "a torn line carries no usable timestamp" rule eventTick/tickStartMap
+    // an absent one (the same "a torn line carries no usable timestamp" rule eventRun/runStartMap
     // apply), so it contributes no outcome; a non-numeric durationMs is dropped like a missing one.
-    const recentOutcomes = tickEnds
+    const recentOutcomes = runEnds
         .filter((ev) => {
         return finiteNumber(ev.ts, null) !== null && typeof ev.result === "string" && ev.result !== "";
     })
@@ -150,13 +164,13 @@ export function rolePayload(root, typedRole, modelsPath = piModelsPath(), now =
         ...(typeof ev.summary === "string" && ev.summary !== "" ? { summary: ev.summary } : {}),
     }))
         .reverse();
-    // The loop's own spend over the same retained window, summed per-run_end through the shared
+    // The role's own spend over the same retained window, summed per-run_end through the shared
     // eventUsage guard (a torn or hand-edited run_end line contributes nothing: a non-numeric
     // field reads as 0, and a line without a usable ts is as unusable as an absent one, matching
-    // recentOutcomes's drop rule so a torn tick never silently spends). Omitted when all three
-    // sums are 0, keeping a never-costly loop's JSON unchanged (the report's zero-means-absent
+    // recentOutcomes's drop rule so a torn run never silently spends). Omitted when all three
+    // sums are 0, keeping a never-costly role's JSON unchanged (the report's zero-means-absent
     // convention).
-    const usage = tickEnds.reduce((acc, ev) => {
+    const usage = runEnds.reduce((acc, ev) => {
         if (finiteNumber(ev.ts, null) === null)
             return acc;
         const u = eventUsage(ev);
@@ -193,15 +207,15 @@ export function rolePayload(root, typedRole, modelsPath = piModelsPath(), now =
     const capUsd = cfg.maxDailyCostUsdPerRole?.[base];
     let dailyCap;
     if (role !== DIRECTOR_ROLE && typeof capUsd === "number" && Number.isFinite(capUsd) && capUsd > 0) {
-        const ids = loopIds(cfg).filter((id) => baseRoleOf(id) === base);
+        const ids = runnerIds(cfg).filter((id) => baseRoleOf(id) === base);
         if (!ids.includes(role))
             ids.push(role);
-        const runners = ids.map((id) => ({ role: id, state: id === role ? state : loadLoopState(root, id) }));
+        const runners = ids.map((id) => ({ role: id, state: id === role ? state : loadRunnerState(root, id) }));
         const verdict = roleCapVerdicts(runners, cfg.maxDailyCostUsdPerRole, now.getTime()).get(base);
         if (verdict)
             dailyCap = { capUsd, spentUsd: verdict.spentUsd, over: verdict.over, roleIds: verdict.roleIds };
     }
-    // The role's notebook, read for display. The same degradation as every other read here: a
+    // The role's notes, read for display. The same degradation as every other read here: a
     // missing, empty, or unreadable file is simply "no note yet". The director has none.
     let note = null;
     if (role !== DIRECTOR_ROLE) {
@@ -227,7 +241,7 @@ export function rolePayload(root, typedRole, modelsPath = piModelsPath(), now =
         title: resolved.title,
         custom: isCustomRole(cfg, role),
         enabled: enabledRoleIds(cfg).includes(role),
-        paused: loopPaused(new Set(pausedRoles(root)), role),
+        paused: runnerPaused(new Set(pausedRoles(root)), role),
         tier: roleTier(role),
         modelTier: roleSeamTier(cfg, role),
         ...resolvedModelFields(effective.provider, effective.model, effective.thinking),
@@ -245,10 +259,10 @@ export function rolePayload(root, typedRole, modelsPath = piModelsPath(), now =
         fallback,
         fallbackFree: freeFallback !== null,
         modelFallback: modelFallbackView(episode, cfg, role),
-        ...(account !== null ? { billing: account.billing } : {}),
+        ...(account !== null ? { billing: account.billing, billingBackend } : {}),
         ...(billingWindow !== undefined ? { billingWindow } : {}),
         chainStep,
-        ...roleImageInfo(cfg, role, modelsPath, readImageProbeCache(root)),
+        ...roleImageInfo(cfg, role, modelsPath, readImageProbeCache(root), readPiListedModels(root)),
         minRunIntervalSeconds: effective.minRunIntervalSeconds,
         ...(minRunIntervalOverride !== undefined ? { minRunIntervalOverride } : {}),
         ...(providerOverride !== undefined ? { providerOverride } : {}),
@@ -261,7 +275,7 @@ export function rolePayload(root, typedRole, modelsPath = piModelsPath(), now =
         ...(cfg.roles[base]?.instances !== undefined ? { instances: cfg.roles[base].instances } : {}),
         // The roles.<base>.instructions override verbatim — resolved through the base role like
         // the cap and quiet hours, so an instance id shows (and can edit) the override its runs
-        // carry (tick-prompt reads config.roles[base]); null when unset.
+        // carry (run-prompt reads config.roles[base]); null when unset.
         instructions: cfg.roles[baseRoleOf(role)]?.instructions ?? null,
         find: role === DIRECTOR_ROLE ? null : resolved.find,
         notes: note,
@@ -271,20 +285,18 @@ export function rolePayload(root, typedRole, modelsPath = piModelsPath(), now =
         // declared window) — the same seam `- Next run:` previews. Independent of the fallback.
         contextWindow,
         // The preview seam: the queued prompt (if any) is read, not consumed, so an inspection
-        // never costs the loop its queued work — the property the tick-prompt test pins.
-        nextPrompt: assembleTickPrompt({
+        // never costs the role its queued work — the property the run-prompt test pins.
+        nextPrompt: assembleRunPrompt({
             root,
             config: cfg,
             role,
             state,
             preview: true,
-            // The compact prompt every run gets (loop-tick.ts), so the preview is the real prompt.
-            compact: true,
         })?.prompt ?? null,
-        // The loop's schedule — surfaced read-only from the same persisted state rolePayload
-        // already loaded for the model-fallback episode and the next-tick preview, so no new
-        // read path exists and the collector stays one loadLoopState per role. `lastRunEndedAt`
-        // is omitted (JSON unchanged) until the loop has actually ticked.
+        // The role's schedule — surfaced read-only from the same persisted state rolePayload
+        // already loaded for the model-fallback episode and the next-run preview, so no new
+        // read path exists and the collector stays one loadRunnerState per role. `lastRunEndedAt`
+        // is omitted (JSON unchanged) until the role has actually run.
         nextRunAt: state.nextRunAt,
         backoffSeconds: state.backoffSeconds,
         yieldMultiplier: yieldMultiplierFor(state),