omp-conductor 0.12.0 → 0.13.0

package/src/diff-flags.ts

@@ -745,6 +745,10 @@ export function formatSettlementFlags(
       pooledHeading(diff.attempts),
   ];
   for (const flag of flags.slice(0, RENDERED_FLAGS)) {
+    if (flag.kind === "pr-adopted") {
+      lines.push(`  ${flag.kind} — ${flag.detail}`);
+      continue;
+    }
     lines.push(
       `  ${flag.kind}  ${flag.file}${flag.line === undefined ? "" : `:${flag.line}`} — ${flag.detail}` +
         (flag.unattributed === true ? "  [unattributed: the dispatching issue never names this file]" : ""),

package/src/escalate.ts

@@ -213,13 +213,13 @@ export function createEscalator(
       if (e.tier === 2 && chatId) {
         const token = readTelegramToken();
         if (token) {
-          // A category this policy defers does not page now: it is held here so
-          // the digest is the delivery authority for it (#229). A missing
-          // `reporting` block means the default (page everything); an explicit
-          // list decides each escalation by its category, defaulting `tier2`.
+          // The digest can own deferred delivery only while its orchestrator
+          // loop is alive. An urgent escalation says that loop is the failed
+          // component, so waiting for its digest would park the only warning
+          // behind the failure it reports (#246).
           const category = e.category ?? "tier2";
           const interruptOn = p.reporting?.interruptOn;
-          if (interruptOn !== undefined && !interruptOn.includes(category)) {
+          if (!e.urgent && interruptOn !== undefined && !interruptOn.includes(category)) {
             store.addHeldNotice({
               project: p.name,
               category,

package/src/failure-class.ts

@@ -22,6 +22,9 @@ export interface ClassifyFacts {
   pr?: "open" | "merged" | "closed";
   mergeable?: "conflicting" | "clean" | "unknown";
   checks?: { name: string; state: string; link?: string }[];
+  /** Full session error recovered from the transcript. Kept as a fact so a
+   *  classification retry does not lose an HTTP status the run row cannot store. */
+  sessionError?: { status?: number; message: string };
   /** Tail (ANSI-stripped) of the first failed check's log, when one was
    *  reachable. Lets the table tell an infrastructure outage (#177) from a
    *  deterministic test failure by the log's own words. */
@@ -221,6 +224,8 @@ const DISPATCH_GIT_ERROR = /^(?:Error: )?git .+ exited \d+/s;
 
 export function classifyRun(run: RunRecord, facts: ClassifyFacts): Classification {
   const hasArtifacts = run.prUrl !== undefined || run.headSha !== undefined || run.salvageSha !== undefined;
+  const providerError =
+    facts.sessionError ?? (run.lastError === undefined ? undefined : { message: run.lastError });
 
   // The PR landed while the row says otherwise. Whatever else is true about this
   // run, it succeeded, and the recovery is bookkeeping.
@@ -249,10 +254,7 @@ export function classifyRun(run: RunRecord, facts: ClassifyFacts): Classificatio
   // first request produces a turn-0 row with no artifacts, which
   // `env-start-failure` would otherwise absorb and lose the cause.
   if (run.state === "failed" || run.state === "killed") {
-    const credit =
-      run.lastError === undefined
-        ? undefined
-        : providerCreditRefusal({ message: run.lastError });
+    const credit = providerError === undefined ? undefined : providerCreditRefusal(providerError);
     if (credit !== undefined) {
       return { cls: "provider-credit", recovery: "requeue", evidence: credit };
     }
@@ -267,7 +269,7 @@ export function classifyRun(run: RunRecord, facts: ClassifyFacts): Classificatio
   // the same reason as the credit branch: a turn-0 stall would otherwise be
   // absorbed by `env-start-failure` and lose its cause.
   if (run.state === "failed" || run.state === "killed") {
-    const transient = run.lastError === undefined ? undefined : providerTransientFault({ message: run.lastError });
+    const transient = providerError === undefined ? undefined : providerTransientFault(providerError);
     if (transient !== undefined) {
       return { cls: "provider-transient", recovery: "requeue", evidence: transient };
     }

package/src/fleet.ts

@@ -38,6 +38,7 @@ import { settlementFlagSummary } from "./diff-flags.ts";
 import { probeCodeGraph, type CodeGraphHealth } from "./graph-health.ts";
 import { formatOpenReports } from "./reports.ts";
 import {
+  formatBaseChecks,
   formatDispatchSummary,
   formatReleaseGrants,
   formatSalvagedRuns,
@@ -1026,7 +1027,7 @@ export function formatFleetStatus(
   // a halt) answers "who stopped the fleet" without opening a file (#185). An
   // unparseable sentinel — paused but with no datable line 1 — is itself news:
   // it means a run admitted before an *unknown* pause cannot prove innocence
-  // (#174), so every mutation is refused.
+  // (#174), so completion mutations fail closed while release gates remain usable.
   const dispatchLine =
     layers.dispatch === "paused"
       ? (() => {
@@ -1036,7 +1037,7 @@ export function formatFleetStatus(
             return `dispatch  paused (source: ${prov.source}${reason})`;
           }
           return isPaused() && pausedAt() === undefined
-            ? "dispatch  paused (unparseable sentinel — all mutations refused)"
+            ? "dispatch  paused (unparseable sentinel — new work and completion mutations refused; release gates remain available)"
             : "dispatch  paused";
         })()
       : `dispatch  ${layers.dispatch}`;
@@ -1110,6 +1111,9 @@ function formatProjectBody(s: StatusSnapshot): string {
           })`,
         ]),
     `  new worker turns   ${s.caps.workerMaxTurns}`,
+    ...s.turnOverrides.map(
+      ({ issue, maxTurns }) => `  turn override      #${issue} → ${maxTurns} (next attempt)`,
+    ),
     `  worker wall clock  ${Math.round(s.caps.workerWallClockMs / 60_000)}m`,
     `  failed attempts    ${s.caps.maxAttemptsPerIssue}`,
     `  continuations      ${s.caps.maxContinuationsPerIssue}`,
@@ -1136,6 +1140,7 @@ function formatProjectBody(s: StatusSnapshot): string {
       if (flagged !== undefined) lines.push(`      ${flagged}`);
     }
   }
+  lines.push(...formatBaseChecks(s.baseChecks));
   lines.push(...formatSalvagedRuns(s.salvagedRuns));
   lines.push(...formatOpenReports(s.openReports));
   if (s.liveWorkers > 0) {

package/src/omp.ts

@@ -19,7 +19,7 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 
 import { worktreeConfinement } from "./confinement.ts";
-import { releasePolicyTripwire } from "./release-policy.ts";
+import { releasePolicyTripwire, type ReleaseBlockContext } from "./release-policy.ts";
 import type {
   HostToParent,
   ParentToHost,
@@ -158,7 +158,7 @@ export async function createLocalSession(opts: {
   /** Install the release/deploy tool-call gate with these per-shape grants. */
   releaseGrants?: ResolvedGrants;
   /** Durable audit callback invoked only when that gate rejects a call. */
-  onReleaseBlocked?: (shape: ReleaseShape) => void;
+  onReleaseBlocked?: (shape: ReleaseShape, context: ReleaseBlockContext) => void;
   /**
    * The conductor verb socket this session's mutation tools call (#126).
    *
@@ -393,7 +393,7 @@ export interface CreateSessionOptions {
   resume?: boolean;
   role: SessionRole;
   releaseGrants?: ResolvedGrants;
-  onReleaseBlocked?: (shape: ReleaseShape) => void;
+  onReleaseBlocked?: (shape: ReleaseShape, context: ReleaseBlockContext) => void;
 
   /**
    * Where the control socket is bound. The daemon puts it beside the run's own
@@ -681,7 +681,11 @@ export async function createSession(opts: CreateSessionOptions): Promise<AgentSe
           break;
         }
         case "release-blocked":
-          opts.onReleaseBlocked?.(message.shape);
+          opts.onReleaseBlocked?.(message.shape, {
+            tool: message.tool,
+            reason: message.reason,
+            args: message.args,
+          });
           break;
       }
     }

package/src/orchestrator-tick.ts

@@ -62,6 +62,7 @@ import {
 } from "./setup.ts";
 import {
   recordReleaseBlock,
+  redactReleaseArgs,
   releaseDriftDigestLine,
   releaseRefusal,
   releaseShapeFromTool,
@@ -412,39 +413,48 @@ export function queueDigestLine(
 export const TICK_SCOPE_CONSTRAINTS: { readonly [K in ReportScope]: string } = {
   material: "Report material events per your brief.",
   escalations:
-    "Report NOTHING this turn except a Tier 1 or Tier 2 escalation; everything else -- releases included -- waits for the daily digest.",
+    "Interrupt only for: tier2, fleet-stopped; everything else — releases included — waits for the daily digest.",
   decisions:
     "Reporting scope decisions: interrupt only for a decision you need (tier-2) or a condition that stops the fleet. Every other material event accumulates and ships as ONE message with this tick's report via omp-conductor report -- a merge, a green PR, a pulled issue wait for the tick; nothing between ticks.",
 };
 
 /**
- * The reporting constraint appended to a default tick prompt (#229).
+ * The reporting constraint appended to a default tick prompt (#229, #242).
  *
- * A legacy `scopePreset` keeps its exact words — those are what the policy
- * tests and the fleet already read — with a DUE/not-due clause appended only
- * when the digest is actually scheduled (`daily` + `at`). An explicit
- * non-preset policy derives one sentence naming its allowed interrupt
- * categories and stating that everything else accumulates for the digest.
+ * Material and decisions keep their legacy preset words. The escalations
+ * preset instead names the policy's actual interrupt categories, so the prompt
+ * cannot drift from the gate. Every daily cadence gets an explicit due state:
+ * model-timed digests need that instruction just as scheduled digests do.
  */
 export function tickReportingConstraint(
   policy: ReportingPolicy | undefined,
-  digest: { due: boolean; scheduled: boolean; at?: string; timezone?: string },
+  digest: {
+    due: boolean;
+    cadence: ReportingPolicy["digest"]["cadence"];
+    at?: string;
+    timezone?: string;
+  },
   held: number,
 ): string {
   const preset = policy?.scopePreset;
+  const allowed = policy?.interruptOn ?? [];
   let base: string;
-  if (preset !== undefined) {
+  if (preset === "escalations") {
+    base = `Interrupt only for: ${allowed.join(", ")}; everything else — releases included — waits for the daily digest.`;
+  } else if (preset !== undefined) {
     base = TICK_SCOPE_CONSTRAINTS[preset];
   } else {
-    const allowed = policy?.interruptOn ?? [];
     base =
       allowed.length === 0
         ? "Report nothing that would interrupt this turn; everything else accumulates for the digest."
         : `Interrupt only for: ${allowed.join(", ")}. Everything else accumulates for the digest.`;
   }
-  if (!digest.scheduled) return base;
-  return digest.due
-    ? `${base} The daily digest is DUE now — compose it from this tick's accumulated events and the ${held} held notice(s) below, then send via omp-conductor report --kind digest.`
+  if (digest.cadence !== "daily") return base;
+  if (digest.due) {
+    return `${base} The daily digest is DUE now — compose it from this tick's accumulated events and the ${held} held notice(s) below, then send via omp-conductor report --kind digest.`;
+  }
+  return digest.at === undefined
+    ? `${base} The daily digest was already sent today; do not send another.`
     : `${base} The daily digest is not due (scheduled ${digest.at}${digest.timezone === undefined ? "" : ` ${digest.timezone}`}); do not send one.`;
 }
 
@@ -1377,7 +1387,7 @@ function tick(pi: TickApi, ctx: TickContext, config: TickConfig, session: TickSe
     if (scope.projectName !== undefined) {
       const policy = scope.policy;
       const digestPolicy = policy?.digest ?? DEFAULT_REPORT_POLICY.digest;
-      const scheduled = digestPolicy.cadence === "daily" && digestPolicy.at !== undefined;
+      const cadence = digestPolicy.cadence;
       const at = Date.now();
       const store = openStore(dbPath());
       try {
@@ -1387,7 +1397,7 @@ function tick(pi: TickApi, ctx: TickContext, config: TickConfig, session: TickSe
           policy,
           {
             due: digestDue(policy ?? DEFAULT_REPORT_POLICY, lastDay, at),
-            scheduled,
+            cadence,
             at: digestPolicy.at,
             timezone: digestPolicy.timezone,
           },
@@ -1683,9 +1693,17 @@ export default function orchestratorTickExtension(pi: TickApi): void {
       // `createSession`; suppress this second copy only after this session has
       // proved it owns the external heartbeat.
       if (releaseAuthorityAccepted && !external) return undefined;
+      // Before ownership is proved this session holds no grant at all, so a
+      // covered shape still refuses with the deny-all wording.
+      const decision = refusal ?? releaseRefusal(DENIED_RELEASE_GRANTS, "orchestrator", shape);
+      if (decision === undefined) return undefined;
       if (projectName !== undefined) {
         try {
-          recordReleaseBlock(projectName, "orchestrator", shape);
+          recordReleaseBlock(projectName, "orchestrator", shape, {
+            tool: event.toolName,
+            reason: decision.reason,
+            args: redactReleaseArgs(event.input),
+          });
         } catch (err) {
           pi.logger.error(
             `[omp-conductor] could not record release-policy block: ${
@@ -1694,10 +1712,7 @@ export default function orchestratorTickExtension(pi: TickApi): void {
           );
         }
       }
-      // Before ownership is proved this session holds no grant at all, so a
-      // covered shape still refuses — with the wording it would get from a
-      // deny-all map rather than a claim about a grant it cannot yet use.
-      return refusal ?? releaseRefusal(DENIED_RELEASE_GRANTS, "orchestrator", shape);
+      return decision;
     });
   };
 

package/src/orchestrator.ts

@@ -33,6 +33,7 @@ import { stateDir } from "./config.ts";
 import { formatEscalation } from "./escalate.ts";
 import { createSession, disposeSession } from "./omp.ts";
 import type { AgentSessionLike } from "./omp.ts";
+import type { ReleaseBlockContext } from "./release-policy.ts";
 import type { Escalation, ReleaseShape, ResolvedGrants, SessionRole } from "./types.ts";
 
 /**
@@ -46,7 +47,7 @@ export type CreateSessionFn = (opts: {
   resume?: boolean;
   role: SessionRole;
   releaseGrants?: ResolvedGrants;
-  onReleaseBlocked?: (shape: ReleaseShape) => void;
+  onReleaseBlocked?: (shape: ReleaseShape, context: ReleaseBlockContext) => void;
   onSpawn?: (pid: number) => void;
   socketPath?: string;
   verbSocketPath?: string;
@@ -84,7 +85,7 @@ export interface OrchestratorOpts {
   sessionDir?: string;
   model?: string;
   releaseGrants?: ResolvedGrants;
-  onReleaseBlocked?: (shape: ReleaseShape) => void;
+  onReleaseBlocked?: (shape: ReleaseShape, context: ReleaseBlockContext) => void;
   /** The child's pid, the instant it exists. See {@link VerbListener.bindPid}. */
   onSpawn?: (pid: number) => void;
   /** Control socket for the session child, beside its own working directory. */

package/src/plugin.ts

@@ -794,7 +794,8 @@ const askCaps: AreaAsker = async (ctx, a) => {
   const tuneCaps = await ctx.ui.confirm(
     "Caps",
     `Defaults: ${workersDefault} workers, ` +
-      `${spendLabel}, ${DEFAULT_CAPS.workerMaxTurns} turns and ` +
+      `${spendLabel}, ${DEFAULT_CAPS.workerMaxTurns} base / ` +
+      `${DEFAULT_CAPS.workerMaxTurnsCeiling} max turns and ` +
       `${Math.round(DEFAULT_CAPS.workerWallClockMs / 60000)} min per worker, ` +
       `${DEFAULT_CAPS.maxAttemptsPerIssue} failed attempts and ` +
       `${DEFAULT_CAPS.maxContinuationsPerIssue} operational continuations per issue.${smallHostNote} Change them?`,
@@ -821,7 +822,32 @@ const askCaps: AreaAsker = async (ctx, a) => {
     "Spend ceiling per rolling day (USD) — blank = no spend cap",
     caps.dailySpendUsd !== undefined ? caps.dailySpendUsd : DEFAULT_CAPS.dailySpendUsd,
   );
-  caps.workerMaxTurns = await askNumber(ctx, "Turn ceiling per worker", caps.workerMaxTurns ?? DEFAULT_CAPS.workerMaxTurns);
+  const workerMaxTurns = await askNumber(
+    ctx,
+    "Turn ceiling per worker",
+    caps.workerMaxTurns ?? DEFAULT_CAPS.workerMaxTurns,
+  );
+  caps.workerMaxTurns = workerMaxTurns;
+  const turnCeilingFallback = Math.max(
+    workerMaxTurns,
+    caps.workerMaxTurnsCeiling ??
+      Math.min(workerMaxTurns * 2, Number.MAX_SAFE_INTEGER),
+  );
+  const workerMaxTurnsCeiling = await askNumber(
+    ctx,
+    "Maximum turn ceiling for one issue",
+    turnCeilingFallback,
+  );
+  if (workerMaxTurnsCeiling < workerMaxTurns) {
+    ctx.ui.notify(
+      `Maximum turn ceiling ${workerMaxTurnsCeiling} cannot be below the ` +
+        `${workerMaxTurns}-turn worker base — keeping ${turnCeilingFallback}.`,
+      "warning",
+    );
+    caps.workerMaxTurnsCeiling = turnCeilingFallback;
+  } else {
+    caps.workerMaxTurnsCeiling = workerMaxTurnsCeiling;
+  }
   caps.workerWallClockMs = await askNumber(
     ctx,
     "Wall-clock ceiling per worker (ms)",

package/src/release-policy.ts

@@ -36,11 +36,19 @@ import type { ReleaseShape, ResolvedGrants, SessionRole } from "./types.ts";
 
 export const RELEASE_POLICY_AUDIT_FILE = "release-policy-blocks.jsonl";
 
-export interface ReleaseBlock {
+export interface ReleaseBlockContext {
+  tool: string;
+  reason: string;
+  args: Record<string, string>;
+}
+
+export interface ReleaseBlock extends Partial<ReleaseBlockContext> {
   project: string;
   source: "worker" | "orchestrator";
   shape: ReleaseShape;
   at: string;
+  issue?: number;
+  runId?: string;
 }
 
 export type ReleaseDecision = { block: true; reason: string };
@@ -271,6 +279,32 @@ export function releaseDecision(
   return decision === undefined ? undefined : { shape, decision };
 }
 
+const RELEASE_ARG_ALLOWLIST = new Set([
+  "repo",
+  "stack",
+  "artefact",
+  "artifact",
+  "environment",
+  "tag",
+  "version",
+  "image",
+  "prUrl",
+  "branch",
+  "service",
+]);
+
+/** Keep only explicitly safe release-target strings; redact every other value. */
+export function redactReleaseArgs(input: Record<string, unknown>): Record<string, string> {
+  const redacted: Record<string, string> = {};
+  for (const [key, value] of Object.entries(input)) {
+    redacted[key] =
+      RELEASE_ARG_ALLOWLIST.has(key) && typeof value === "string"
+        ? value.slice(0, 120)
+        : "(redacted)";
+  }
+  return redacted;
+}
+
 interface ReleasePolicyPi {
   on(
     event: "tool_call",
@@ -285,14 +319,18 @@ interface ReleasePolicyPi {
 export function releasePolicyTripwire(
   grants: ResolvedGrants,
   role: SessionRole,
-  onBlocked: (shape: ReleaseShape) => void = () => {},
+  onBlocked: (shape: ReleaseShape, context: ReleaseBlockContext) => void = () => {},
 ): (pi: ReleasePolicyPi) => void {
   return (pi) => {
     pi.on("tool_call", (event) => {
       const blocked = releaseDecision(grants, role, event.toolName, event.input);
       if (blocked === undefined) return undefined;
       try {
-        onBlocked(blocked.shape);
+        onBlocked(blocked.shape, {
+          tool: event.toolName,
+          reason: blocked.decision.reason,
+          args: redactReleaseArgs(event.input),
+        });
       } catch {
         // Audit is evidence, not the gate. A full disk must not turn a deny into allow.
       }
@@ -305,11 +343,22 @@ export function recordReleaseBlock(
   project: string,
   source: ReleaseBlock["source"],
   shape: ReleaseShape,
+  details: Omit<ReleaseBlock, "project" | "source" | "shape" | "at"> = {},
   root = stateDir(),
   now = new Date(),
 ): void {
   mkdirSync(root, { recursive: true });
-  const record: ReleaseBlock = { project, source, shape, at: now.toISOString() };
+  // Redact again at the durable boundary. Callers normally pass the tripwire's
+  // already-safe context, but no alternate recorder path gets to rely on that.
+  const { args, ...attribution } = details;
+  const record: ReleaseBlock = {
+    project,
+    source,
+    shape,
+    ...attribution,
+    ...(args === undefined ? {} : { args: redactReleaseArgs(args) }),
+    at: now.toISOString(),
+  };
   appendFileSync(join(root, RELEASE_POLICY_AUDIT_FILE), `${JSON.stringify(record)}\n`, { mode: 0o600 });
 }
 
@@ -354,12 +403,23 @@ export function releaseDriftToday(
   return latest === undefined ? undefined : { count, latest };
 }
 
-export function releaseDriftDigestLine(project: string, root = stateDir(), now = new Date()): string | undefined {
+export function releaseDriftDigestLine(
+  project: string,
+  root = stateDir(),
+  now = new Date(),
+): string | undefined {
   const drift = releaseDriftToday(project, root, now);
   if (drift === undefined) return undefined;
+  const latest = drift.latest;
+  const attribution = [
+    `${latest.source} ${latest.shape} at ${latest.at}`,
+    ...(latest.issue === undefined ? [] : [`issue #${latest.issue}`]),
+    ...(latest.runId === undefined ? [] : [`run ${latest.runId}`]),
+    ...(latest.tool === undefined ? [] : [`tool ${latest.tool}`]),
+  ].join(", ");
   return (
     `Release-policy drift today: ${drift.count} release/deploy tool call(s) were blocked ` +
-    `(latest: ${drift.latest.source} ${drift.latest.shape} at ${drift.latest.at}). ` +
+    `(latest: ${attribution}). ` +
     "Include this divergence from releasePolicy=none in today's digest."
   );
 }

package/src/session-host.ts

@@ -22,6 +22,7 @@
 import { connect } from "node:net";
 
 import { createLocalSession, disposeSession, type AgentSessionLike } from "./omp.ts";
+import type { ReleaseBlockContext } from "./release-policy.ts";
 
 import type { ReleaseShape, ResolvedGrants, SessionRole } from "./types.ts";
 
@@ -65,7 +66,7 @@ export type HostToParent =
   | { t: "session-file"; path: string }
   | { t: "prompt-result"; id: number; ok: boolean; error?: string }
   | { t: "park-result"; id: number; ok: boolean; error?: string }
-  | { t: "release-blocked"; shape: ReleaseShape };
+  | ({ t: "release-blocked"; shape: ReleaseShape } & ReleaseBlockContext);
 
 /**
  * Depth at which a harness event stops being copied for the wire.
@@ -186,8 +187,8 @@ export async function runSessionHost(
       // The release audit lives in the daemon's state directory, which this
       // process may not be able to write and must not be trusted to. It
       // becomes a message; the parent performs the durable write.
-      onReleaseBlocked: (shape) => {
-        send({ t: "release-blocked", shape });
+      onReleaseBlocked: (shape, context) => {
+        send({ t: "release-blocked", shape, ...context });
       },
     });
   } catch (err) {

package/src/setup.ts

@@ -251,6 +251,7 @@ export const RELEASE_REQUIREMENT_CHOICES: { readonly [K in ReleaseRequirement]:
   "runs-settled": "every run this release covers actually merged, not merely reached a green PR",
   "no-open-prs": "no pull request is still open against the branch being released",
   "queue-drained": "nothing still carries the queue label",
+  "base-branch-green": "the newest observed post-merge base-branch workflows are green",
   "epic-children-closed": "the epic this release closes has no open children",
 };
 
@@ -1191,14 +1192,15 @@ export const AMEND_AREAS: {
     // The model rides with the caps because it is the other per-worker knob, and
     // an area no menu offers is a setting only a full re-interview can reach.
     name: "caps & worker model",
-    asks: "concurrency, spend, turns, wall clock, failed attempts, continuations — then the worker model",
+    asks: "concurrency, spend, turn base and extension ceiling, wall clock, failed attempts, continuations — then the worker model",
     describe: (p) => {
       const c = resolveCaps(p, DEFAULT_CAPS);
       const answered = Object.keys(p.caps).length > 0;
       const spend =
         c.dailySpendUsd === null ? "no spend cap" : `$${c.dailySpendUsd}/day`;
       return (
-        `${c.maxConcurrentWorkers} workers (${c.maxConcurrentWorkersPerRepo}/repo), ${c.workerMaxTurns} turns, ` +
+        `${c.maxConcurrentWorkers} workers (${c.maxConcurrentWorkersPerRepo}/repo), ` +
+        `${c.workerMaxTurns} base/${c.workerMaxTurnsCeiling} max turns, ` +
         `${Math.round(c.workerWallClockMs / 60000)}m, ${spend}, ` +
         `${c.maxAttemptsPerIssue} failed attempt${c.maxAttemptsPerIssue === 1 ? "" : "s"}, ` +
         `${c.maxContinuationsPerIssue} continuation${c.maxContinuationsPerIssue === 1 ? "" : "s"}` +