faberun 0.14.0 → 0.16.0

package/src/plan/routing.mjs

@@ -5,26 +5,44 @@
  * resolves a *contract's* already-declared runtimes; a plan's draft node
  * never names one (the constitution reserves model choice to runtimes,
  * runtimeDefaults, or an explicit node override) — this module is what turns
- * a taskKind/riskTier classification into one of those three.
+ * a taskKind/riskTier classification into one of those three. Each rule names
+ * the strategy that consumes its `prefer` list, and every assignment records
+ * the strategy that was applied and the reason for the choice — `declared`
+ * when an operator instruction prevailed, since that outranks every strategy.
  */
 
-import { cheapest, strongest } from "../engine/runtime-discovery.mjs";
+import { ROUTING_STRATEGIES } from "../contract/runtime.mjs";
+import { cheapest, isRuntimeAvailable, strongest } from "../engine/runtime-discovery.mjs";
 
-/** @typedef {{available: boolean, exhaustedUntil: string|null, [key: string]: unknown}} RoutingAvailability */
+/** @typedef {import("../contract/runtime.mjs").RoutingStrategy} RoutingStrategy */
+/** @typedef {RoutingStrategy|"declared"} AppliedStrategy */
+
+/**
+ * The plan's copy of the discovery catalogue record: only what the harness de
+ * facto reports, with the moment each datum was observed. The observables are
+ * null where the harness exposes nothing -- never zero and never full
+ * allowance, so a runtime that reports nothing cannot look rested -- and an
+ * observation older than its own window reads as unknown at the one shared
+ * reader, `isRuntimeAvailable` in runtime-discovery.mjs.
+ * @typedef {{available: boolean, exhaustedUntil: string|null, observedAt?: string|null, window?: string|null, remaining?: number|null, [key: string]: unknown}} RoutingAvailability
+ */
 /** @typedef {{vendor: string, tier?: number|string, costRank?: number, fallback?: string, [key: string]: unknown}} RoutingRuntime */
 /** @typedef {{id: string, taskKind?: string, riskTier?: string}} RoutingNode */
 /** @typedef {{taskKind?: string, riskTier?: string}} RoutingWhen */
-/** @typedef {{name?: string, when: RoutingWhen, prefer: string[], role: "worker"|"judge"}} RoutingRule */
+/** @typedef {{name?: string, when: RoutingWhen, prefer: string[], role: "worker"|"judge", strategy?: RoutingStrategy}} RoutingRule */
 /** @typedef {{worker?: string, judge?: string}} RoutingRoleMap */
 /** @typedef {{table?: RoutingRule[], runtimes: Record<string, RoutingRuntime>, availability?: Record<string, RoutingAvailability>, runtimeDefaults?: RoutingRoleMap, overrides?: Record<string, RoutingRoleMap>}} RoutingConfig */
-/** @typedef {{worker: string|null, judge: string|null, rule: {worker: string, judge: string}}} RoutingAssignment */
+/** @typedef {{worker: string|null, judge: string|null, rule: {worker: string, judge: string}, strategy: {worker: AppliedStrategy|null, judge: AppliedStrategy|null}, reason: {worker: string, judge: string}}} RoutingAssignment */
 /** @typedef {{nodeId: string, role: "worker"|"judge", rule: string}} RoutingUnmet */
 /** @typedef {{assignments: Record<string, RoutingAssignment>, unmet: RoutingUnmet[]}} RoutingResult */
 
 /**
  * @param {RoutingNode[]} nodes
  * @param {RoutingConfig} config
- * @param {{partial?: boolean}} [options]
+ * @param {{partial?: boolean, previous?: Record<string, RoutingRoleMap>}} [options]
+ *   `previous` carries the per-node role assignment the last routing pass made,
+ *   the datum the `attempt-affinity` strategy prefers; absent, that strategy is
+ *   inert and the remaining rules decide.
  * @returns {RoutingResult}
  */
 export function resolveRuntimes(nodes, config, options = {}) {
@@ -33,6 +51,15 @@ export function resolveRuntimes(nodes, config, options = {}) {
   const availability = config.availability ?? {};
   const runtimeDefaults = config.runtimeDefaults ?? {};
   const overrides = config.overrides ?? {};
+  const previous = options.previous ?? {};
+
+  // A strategy name outside the vocabulary is an authored-table defect, not an
+  // unobservable datum: it fails fast, before any node is resolved.
+  for (const row of table) {
+    if (row.strategy !== undefined && !ROUTING_STRATEGIES.has(row.strategy)) {
+      throw new TypeError(`routing rule ${ruleLabel(row)} names unknown strategy ${row.strategy}`);
+    }
+  }
 
   /** @type {Record<string, RoutingAssignment>} */
   const assignments = {};
@@ -41,15 +68,21 @@ export function resolveRuntimes(nodes, config, options = {}) {
 
   for (const node of nodes) {
     const override = overrides[node.id] ?? {};
-    const worker = resolveRole(node, "worker", { runtimes, availability, runtimeDefaults, table, override, forbiddenVendors: EMPTY_VENDORS });
+    const worker = resolveRole(node, "worker", { runtimes, availability, runtimeDefaults, table, override, forbiddenVendors: EMPTY_VENDORS, previousId: previous[node.id]?.worker });
     if (worker.runtimeId === null) unmet.push({ nodeId: node.id, role: "worker", rule: worker.rule });
     // The judge's forbidden vendors follow the worker runtime that was
     // actually chosen, never the row that named it — a worker unmet leaves
     // nothing to conflict with, so the judge resolves without restriction.
     const forbiddenVendors = worker.runtimeId ? forbiddenJudgeVendors(worker.runtimeId, runtimes) : EMPTY_VENDORS;
-    const judge = resolveRole(node, "judge", { runtimes, availability, runtimeDefaults, table, override, forbiddenVendors });
+    const judge = resolveRole(node, "judge", { runtimes, availability, runtimeDefaults, table, override, forbiddenVendors, previousId: previous[node.id]?.judge });
     if (judge.runtimeId === null) unmet.push({ nodeId: node.id, role: "judge", rule: judge.rule });
-    assignments[node.id] = { worker: worker.runtimeId, judge: judge.runtimeId, rule: { worker: worker.rule, judge: judge.rule } };
+    assignments[node.id] = {
+      worker: worker.runtimeId,
+      judge: judge.runtimeId,
+      rule: { worker: worker.rule, judge: judge.rule },
+      strategy: { worker: worker.strategy, judge: judge.strategy },
+      reason: { worker: worker.reason, judge: judge.reason },
+    };
   }
 
   if (unmet.length && options.partial !== true) {
@@ -66,44 +99,136 @@ const EMPTY_VENDORS = Object.freeze(new Set());
 /**
  * Precedence for one role on one node: an explicit node override, then the
  * operator's runtimeDefaults, then the first table row whose `when` matches
- * this node's classification, then plain discovery. A row or default that
- * names an unavailable or vendor-forbidden runtime is unmet by that rule —
- * it does not fall through to a lower-precedence source, since falling
- * through would silently discard an explicit declaration; only the
- * candidates *within* a row's `prefer` list, and within discovery, are
- * skipped for exhaustion or vendor conflict.
+ * this node's classification, then plain discovery. A declaration outranks
+ * every strategy — it is recorded as `declared`, never as a strategy outcome —
+ * and a row or default that names an unavailable or vendor-forbidden runtime
+ * is unmet by that rule — it does not fall through to a lower-precedence
+ * source, since falling through would silently discard an explicit
+ * declaration; only the candidates *within* a row's `prefer` list, and within
+ * discovery, are skipped for exhaustion or vendor conflict.
  *
  * @param {RoutingNode} node
  * @param {"worker"|"judge"} role
- * @param {{runtimes: Record<string, RoutingRuntime>, availability: Record<string, RoutingAvailability>, runtimeDefaults: RoutingRoleMap, table: RoutingRule[], override: RoutingRoleMap, forbiddenVendors: ReadonlySet<string>}} context
- * @returns {{runtimeId: string|null, rule: string}}
+ * @param {{runtimes: Record<string, RoutingRuntime>, availability: Record<string, RoutingAvailability>, runtimeDefaults: RoutingRoleMap, table: RoutingRule[], override: RoutingRoleMap, forbiddenVendors: ReadonlySet<string>, previousId: string|undefined}} context
+ * @returns {{runtimeId: string|null, rule: string, strategy: AppliedStrategy|null, reason: string}}
  */
 function resolveRole(node, role, context) {
-  const { runtimes, availability, runtimeDefaults, table, override, forbiddenVendors } = context;
+  const { runtimes, availability, runtimeDefaults, table, override, forbiddenVendors, previousId } = context;
 
   if (override[role] !== undefined) {
     const id = override[role];
-    return { runtimeId: admits(id, runtimes, availability, forbiddenVendors) ? id : null, rule: "override" };
+    return {
+      runtimeId: admits(id, runtimes, availability, forbiddenVendors) ? id : null,
+      rule: "override",
+      strategy: "declared",
+      reason: `operator override on node ${node.id}`,
+    };
   }
 
   if (runtimeDefaults[role] !== undefined) {
     const id = runtimeDefaults[role];
-    return { runtimeId: admits(id, runtimes, availability, forbiddenVendors) ? id : null, rule: "runtimeDefaults" };
+    return {
+      runtimeId: admits(id, runtimes, availability, forbiddenVendors) ? id : null,
+      rule: "runtimeDefaults",
+      strategy: "declared",
+      reason: "operator runtimeDefaults",
+    };
   }
 
   const row = table.find((candidate) => candidate.role === role
     && (candidate.when.taskKind === undefined || candidate.when.taskKind === node.taskKind)
     && (candidate.when.riskTier === undefined || candidate.when.riskTier === node.riskTier));
   if (row) {
-    const rule = ruleLabel(row);
-    const id = row.prefer.find((candidate) => admits(candidate, runtimes, availability, forbiddenVendors)) ?? null;
-    return { runtimeId: id, rule };
+    const strategy = row.strategy ?? "priority";
+    const decision = chooseByStrategy(strategy, row.prefer, { runtimes, availability, forbiddenVendors, previousId });
+    return { runtimeId: decision.runtimeId, rule: ruleLabel(row), strategy, reason: decision.reason };
   }
 
   const discovered = role === "worker"
     ? cheapestAvailable(runtimes, availability, forbiddenVendors)
     : strongestAvailable(runtimes, availability, forbiddenVendors);
-  return { runtimeId: discovered, rule: "discovery" };
+  return {
+    runtimeId: discovered,
+    rule: "discovery",
+    strategy: role === "worker" ? "cost" : "priority",
+    reason: role === "worker" ? "discovery: cheapest available runtime" : "discovery: strongest available runtime",
+  };
+}
+
+/**
+ * One strategy's choice over a row's `prefer` list -- attempt-affinity's
+ * candidate is the previous attempt's runtime, which the list need not name.
+ * A strategy whose datum a
+ * candidate does not expose is inert for that candidate — it cannot choose it,
+ * and it never raises; inert for the whole row when no candidate exposes it,
+ * at which point the prefer list's own order decides. The reason says which
+ * of the two happened, because a recorded strategy that fell back must read
+ * differently from one that decided.
+ *
+ * @param {RoutingStrategy} strategy
+ * @param {string[]} prefer
+ * @param {{runtimes: Record<string, RoutingRuntime>, availability: Record<string, RoutingAvailability>, forbiddenVendors: ReadonlySet<string>, previousId: string|undefined}} context
+ * @returns {{runtimeId: string|null, reason: string}}
+ */
+function chooseByStrategy(strategy, prefer, context) {
+  const { runtimes, availability, forbiddenVendors, previousId } = context;
+  const candidates = prefer.map((id) => ({ id, admissible: admits(id, runtimes, availability, forbiddenVendors) }));
+  const admissible = candidates.filter((candidate) => candidate.admissible);
+  if (admissible.length === 0) return { runtimeId: null, reason: "no admissible candidate in the prefer list" };
+
+  if (strategy === "attempt-affinity") {
+    if (previousId === undefined) {
+      return { runtimeId: admissible[0].id, reason: "attempt-affinity inert: no previous attempt recorded; prefer order decided" };
+    }
+    // Affinity's candidate is the previous attempt's runtime itself, even
+    // where the prefer list does not name it -- reusing it is the strategy's
+    // whole point. It yields by name whenever it would violate availability
+    // or vendor distinction, the yields `admits` already speaks.
+    if (admits(previousId, runtimes, availability, forbiddenVendors)) {
+      return { runtimeId: previousId, reason: `attempt-affinity: previous attempt's runtime ${previousId} still admissible` };
+    }
+    return { runtimeId: admissible[0].id, reason: `attempt-affinity yielded: ${previousId} ${blockedWhy(previousId, runtimes, availability, forbiddenVendors)}; prefer order decided` };
+  }
+
+  if (strategy === "cost") {
+    const ranked = admissible.filter((candidate) => typeof runtimes[candidate.id]?.costRank === "number");
+    if (ranked.length === 0) {
+      return { runtimeId: admissible[0].id, reason: "cost inert: no admissible candidate exposes costRank; prefer order decided" };
+    }
+    /** @param {{id: string, admissible: boolean}} candidate */
+    const costRank = (candidate) => /** @type {number} */ (runtimes[candidate.id]?.costRank);
+    const winner = ranked.reduce((best, candidate) => (costRank(candidate) < costRank(best) ? candidate : best));
+    return { runtimeId: winner.id, reason: `cost: lowest costRank ${costRank(winner)} among ranked candidates` };
+  }
+
+  if (strategy === "reset-proximity") {
+    const measured = admissible.filter((candidate) => typeof availability[candidate.id]?.remaining === "number");
+    if (measured.length === 0) {
+      return { runtimeId: admissible[0].id, reason: "reset-proximity inert: no admissible candidate exposes remaining; prefer order decided" };
+    }
+    // The window nearest its reset is spent first, so a reset never wastes
+    // allowance; a runtime exposing nothing is unrankable, not free.
+    const winner = measured.reduce((best, candidate) => (/** @type {number} */ (availability[candidate.id].remaining) < /** @type {number} */ (availability[best.id].remaining) ? candidate : best));
+    return { runtimeId: winner.id, reason: `reset-proximity: least remaining allowance (${/** @type {number} */ (availability[winner.id].remaining)})` };
+  }
+
+  return { runtimeId: admissible[0].id, reason: "priority: first admissible of the prefer list" };
+}
+
+/**
+ * Why one runtime fails `admits`, in words a recorded reason can quote.
+ *
+ * @param {string} id
+ * @param {Record<string, RoutingRuntime>} runtimes
+ * @param {Record<string, RoutingAvailability>} availability
+ * @param {ReadonlySet<string>} forbiddenVendors
+ * @returns {string}
+ */
+function blockedWhy(id, runtimes, availability, forbiddenVendors) {
+  const runtime = runtimes[id];
+  if (!runtime) return "is not declared in runtimes";
+  if (forbiddenVendors.has(runtime.vendor)) return `carries forbidden vendor ${runtime.vendor}`;
+  return "is unavailable";
 }
 
 /**
@@ -117,14 +242,7 @@ function admits(id, runtimes, availability, forbiddenVendors) {
   const runtime = runtimes[id];
   if (!runtime) return false;
   if (forbiddenVendors.has(runtime.vendor)) return false;
-  return isAvailable(availability[id]);
-}
-
-/** @param {RoutingAvailability|undefined} entry @returns {boolean} */
-function isAvailable(entry) {
-  if (!entry) return false;
-  if (entry.available === true) return !entry.exhaustedUntil || Date.parse(entry.exhaustedUntil) <= Date.now();
-  return Boolean(entry.exhaustedUntil && Date.parse(entry.exhaustedUntil) <= Date.now());
+  return isRuntimeAvailable(availability[id]);
 }
 
 /**
@@ -165,7 +283,7 @@ function ruleLabel(row) {
 function candidateEntries(runtimes, availability, forbiddenVendors) {
   return Object.entries(runtimes)
     .map(([id, runtime], order) => ({ id, runtime, order }))
-    .filter(({ id, runtime }) => !forbiddenVendors.has(runtime.vendor) && isAvailable(availability[id]));
+    .filter(({ id, runtime }) => !forbiddenVendors.has(runtime.vendor) && isRuntimeAvailable(availability[id]));
 }
 
 /**

package/src/plan/sizing.mjs

@@ -432,6 +432,39 @@ function markParallelisable(nodes, transformations) {
   });
 }
 
+/**
+ * Ceiling on the concurrency a frozen plan may declare. Not a measurement: no
+ * one has measured how many concurrent workers this or any host survives, and
+ * the only evidence on hand is the wrong direction — three OOM kills on the
+ * planning host on 2026-09-21. So the ceiling is the largest value a contract
+ * in this repository's own record has ever run with: of the 58 stored
+ * contracts, 44 ran at 1 and 14 at 2, none higher. Raise it when someone
+ * measures a host surviving more, not before.
+ */
+const MAX_PROVEN_PARALLELISM = 2;
+
+/**
+ * How many nodes a sized plan may have in flight at once: the nodes
+ * `markParallelisable` marked, floored at 1 and capped at
+ * `MAX_PROVEN_PARALLELISM`. The mark is transitive by construction — a marked
+ * node depends on nothing, nothing depends on it, and its writeFiles is
+ * disjoint from *every* other node's, so any two marked nodes are independent
+ * of each other too and can all run together. The count is therefore the
+ * concurrency sizing proved the plan has work for: above it a slot only ever
+ * idles, and a plan with one marked node, or none, is 1 — the serial number a
+ * contract carries when it says nothing.
+ *
+ * `parallel` is a node-level mark and no contract node accepts it, so this
+ * number is the only way sizing's conclusion survives into a frozen contract
+ * (as `maxParallel`).
+ *
+ * @param {Plan} plan
+ * @returns {number}
+ */
+export function provenParallelism(plan) {
+  return Math.min(MAX_PROVEN_PARALLELISM, Math.max(1, plan.nodes.filter((node) => node.parallel === true).length));
+}
+
 /**
  * The longest dependsOn chain in the graph, counted in nodes. Sizing runs on
  * a model-drafted, not-yet-validated plan, so a dependsOn cycle is possible

package/src/repo/worktree.mjs

@@ -104,6 +104,11 @@ export function candidateRefName(runId) {
   return `refs/faberun/${runId}/candidate`;
 }
 
+/** @param {string} runId @param {string} nodeId @returns {string} */
+export function preservedRefName(runId, nodeId) {
+  return `refs/faberun/${runId}/preserved/${nodeId}`;
+}
+
 /** @param {string} runId @param {string} nodeId @param {number} attempt @returns {string} */
 function attemptBranchName(runId, nodeId, attempt) {
   return `faberun/${runId}/${nodeId}/${attempt}`;
@@ -168,6 +173,29 @@ export function createRunRef(repo, runId, head) {
   return ref;
 }
 
+/**
+ * Keep one node's integrated commit reachable after cancel releases the run
+ * ref and the attempt branches: without a ref of its own the commit is
+ * garbage the next `git gc` collects, and the persisted snapshot alone cannot
+ * bring a pruned object back.
+ *
+ * Idempotent by the same contract `deleteRef` and `removeWorktree` honour:
+ * cancel can legitimately run twice (a retry after a partial first pass, or
+ * the operator repeating it), so a preserved ref that already names this
+ * exact commit is done, not a conflict — the second creation neither fails
+ * nor moves the target. A ref left at a different sha moves to the commit
+ * handed in now.
+ *
+ * @param {string} repo @param {string} runId @param {string} nodeId @param {string|null|undefined} sha @returns {string}
+ */
+export function createPreservedRef(repo, runId, nodeId, sha) {
+  if (!sha) throw Object.assign(new Error("a preserved ref needs an integrated commit"), { code: "git_head_required" });
+  const ref = preservedRefName(runId, nodeId);
+  if (gitHead(repo, ref) === sha) return ref;
+  runGit(["-C", repo, "update-ref", ref, sha]);
+  return ref;
+}
+
 /**
  * @param {{repo: string, runDir: string, runId: string, nodeId: string, attempt: number, base?: string, declaredReads?: string[]}} args
  *   `base` cuts the new branch from a sealed sha instead of the run ref tip —

package/src/report/final.mjs

@@ -11,6 +11,7 @@ import { basename, join } from "node:path";
 import { readJson, writeJsonAtomic, writeTextAtomic } from "../run/store.mjs";
 import { scopeFindingsNote } from "../contract/scope-findings.mjs";
 import { MARK, fit, roleCosts, statusNote, writeStatusArtifacts } from "./render.mjs";
+import { packetRepetitionByNode, packetRepetitionNote } from "./packet-repetition.mjs";
 import { unlinkSync } from "node:fs";
 
 /** @typedef {ReturnType<typeof import("../run/lock.mjs").acquire>} LockHandle */
@@ -130,7 +131,7 @@ export function renderFinalReport(runDir, contract, states) {
     ]));
   }
   const roles = roleCosts(nodes);
-  lines.push("```", "", `totals · in ${compactTokens(totals.inputTokens)} · out ${compactTokens(totals.outputTokens)} · cache ${compactTokens(totals.cacheReadInputTokens)} · worker ${compactCost(roles.worker)} · judge ${compactCost(roles.judge)} · cost ${compactCost(totalCostUsd)} · read ${compactTokens(totals.declaredReadBytes)}`);
+  lines.push("```", "", `totals · in ${compactTokens(totals.inputTokens)} · out ${compactTokens(totals.outputTokens)} · cache ${compactTokens(totals.cacheReadInputTokens)} · worker ${compactCost(roles.worker)} · judge ${compactCost(roles.judge)} · cost ${compactCost(totalCostUsd)} · read ${compactTokens(totals.declaredReadBytes)}${packetRepetitionNote(packetRepetitionByNode(runDir, nodes))}`);
   return `${lines.join("\n")}\n`;
 }
 /**

package/src/report/locale.mjs

@@ -0,0 +1,164 @@
+/**
+ * The language of a notification, and the labels it is written in.
+ *
+ * The controller never sees the operator's conversation with a harness; it
+ * sees what the operator wrote for faberun: the campaign goal, the journal
+ * notes and the objectives the plan gave each node. Those are the operator's
+ * prompts to this product, and a message that answers them in the same
+ * language reads as a reply rather than a log line. Detection is a count of
+ * function words in the two languages this product's operators write in;
+ * anything else, or nothing to read, is English. Quoted content -- the
+ * worker's own words, a judge finding -- keeps the language it was written
+ * in, because translating a quotation would make it stop being one.
+ *
+ * It is a module apart from `message.mjs` so the layout and the wording can
+ * change independently: a new label is one line here, a new line is one
+ * function there.
+ */
+
+/** @typedef {"en"|"pt"} Language */
+
+// `a`, `do` and `no` are left out on purpose: each is also an English word,
+// and one article in an English sentence must not read as Portuguese.
+const PORTUGUESE = new Set(["o", "e", "de", "da", "na", "que", "não", "nao", "para", "com", "uma", "um", "em", "os", "as", "dos", "das", "é", "se", "por", "mais", "como", "mas", "ao", "ou", "quando", "já", "também", "ser", "sem", "até", "cada", "nunca", "está", "são", "foi", "pelo", "pela", "nos", "nas", "seu", "sua", "isso", "esse", "essa", "ele", "ela"]);
+const ENGLISH = new Set(["the", "and", "of", "to", "in", "is", "for", "with", "that", "on", "as", "are", "this", "it", "be", "by", "from", "or", "an", "not", "at", "when", "every", "never", "before", "after", "its", "into", "than", "which", "while", "each", "was", "has", "have"]);
+
+/**
+ * The language of the first group of samples that carries any function word
+ * at all, English when none does. Groups are passed in order of authorship:
+ * the campaign goal is the operator's own sentence, the journal notes are the
+ * orchestrating session's, the node objectives are the planner's -- and a
+ * plan written by a model in English must not outvote the person who typed
+ * the goal in Portuguese (measured 2026-09-21: two node objectives held 40
+ * English function words against a Portuguese goal's 19).
+ *
+ * @param {...readonly (string|null|undefined)[]} groups
+ * @returns {Language}
+ */
+export function detectLanguage(...groups) {
+  for (const samples of groups) {
+    let portuguese = 0;
+    let english = 0;
+    for (const sample of samples) {
+      if (typeof sample !== "string") continue;
+      for (const word of sample.toLowerCase().split(/[^\p{L}]+/u)) {
+        if (PORTUGUESE.has(word)) portuguese += 1;
+        else if (ENGLISH.has(word)) english += 1;
+      }
+    }
+    if (portuguese + english > 0) return portuguese > english ? "pt" : "en";
+  }
+  return "en";
+}
+
+/**
+ * Every phrase the message renders, per language. Node ids, run ids, model
+ * names and quoted text are never here: they are data, not wording.
+ *
+ * @type {Record<Language, Record<string, string>>}
+ */
+const LABELS = {
+  en: {
+    doneIn: "done in",
+    running: "running",
+    pending: "pending",
+    state: "state",
+    nothingDelivered: "nothing delivered",
+    "no-op": "no-op after",
+    failedAfter: "failed after",
+    blockedAfter: "blocked after",
+    exhaustedAfter: "exhausted after",
+    stalledAfter: "stalled after",
+    canceledAfter: "canceled after",
+    needsYou: "needs you",
+    attempt: "attempt",
+    run: "run",
+    done: "done",
+    asked: "asked",
+    did: "done",
+    proof: "proof",
+    delivered: "delivered",
+    why: "why",
+    do: "do",
+    judge: "judge",
+    missing: "missing",
+    error: "error",
+    checksGreen: "checks green",
+    checksOf: "checks passed",
+    judgePass: "judge pass",
+    judgePasses: "judge passes",
+    judgeRejected: "judge rejected",
+    noJudge: "no judge",
+    revisions: "revisions",
+    nodes: "nodes",
+    next: "next",
+    waitingOnYou: "waiting on you",
+    phases: "phases",
+    cache: "cache",
+    in: "in",
+    out: "out",
+    nextCommand: "next",
+    available: "available",
+    runUpdate: "run",
+    noSummary: "(no summary recorded)",
+    noObjective: "(no objective recorded)",
+    more: "more",
+    complete: "complete",
+  },
+  pt: {
+    doneIn: "concluído em",
+    running: "rodando",
+    pending: "pendente",
+    state: "estado",
+    nothingDelivered: "nada entregue",
+    "no-op": "sem mudança após",
+    failedAfter: "falhou após",
+    blockedAfter: "bloqueado após",
+    exhaustedAfter: "esgotado após",
+    stalledAfter: "travou após",
+    canceledAfter: "cancelado após",
+    needsYou: "precisa de você",
+    attempt: "tentativa",
+    run: "run",
+    done: "concluídos",
+    asked: "pedido",
+    did: "feito",
+    proof: "prova",
+    delivered: "entregue",
+    why: "motivo",
+    do: "ação",
+    judge: "juiz",
+    missing: "faltou",
+    error: "erro",
+    checksGreen: "checagens verdes",
+    checksOf: "checagens passaram",
+    judgePass: "juiz aprovou",
+    judgePasses: "aprovações do juiz",
+    judgeRejected: "juiz rejeitou",
+    noJudge: "sem juiz",
+    revisions: "revisões",
+    nodes: "nós",
+    next: "próximo",
+    waitingOnYou: "esperando você",
+    phases: "fases",
+    cache: "cache",
+    in: "entrada",
+    out: "saída",
+    nextCommand: "próximo passo",
+    available: "disponível",
+    runUpdate: "rode",
+    noSummary: "(sem resumo registrado)",
+    noObjective: "(sem objetivo registrado)",
+    more: "mais",
+    complete: "completa",
+  },
+};
+
+/**
+ * @param {Language} language
+ * @returns {(key: string) => string}
+ */
+export function labelsFor(language) {
+  const table = LABELS[language];
+  return (key) => table[key] ?? LABELS.en[key] ?? key;
+}