elanous 0.2.23 → 0.2.25

package/src/compact/verify-probe.ts

@@ -13,6 +13,7 @@
 
 import type { LLMMessage } from '../llm.js';
 import { streamLLM } from '../llm.js';
+import { debug } from '../debug/log.js';
 import { resolveSummarizerModel } from './provider.js';
 import { buildCompactTranscript, stripCompactScratchpad } from './summarize.js';
 
@@ -36,13 +37,26 @@ export interface VerifyProbeArgs {
   activeModelId?: string;
   summarizerModel?: string;
   timeoutMs?: number;
+  /** Injectable stream call — default `streamLLM` (byte-identical
+   *  behavior when omitted). Tests inject a stub so the probe can be
+   *  exercised with zero real LLM calls. */
+  stream?: typeof streamLLM;
 }
 
+export type VerifyProbeStatus = 'pass' | 'fail' | 'error';
+
 export interface VerifyProbeResult {
   /** True when the probe judged the summary acceptable. */
   ok: boolean;
   /** Probe's response text (free form). Empty when probe failed. */
   notes: string;
+  /** Outcome classification: 'pass' = probe accepted the summary,
+   *  'fail' = probe found a lost detail (ok:false), 'error' = probe
+   *  call failed/timed out (fail-open — ok stays true). */
+  status: VerifyProbeStatus;
+  /** The model the probe ran on (resolveSummarizerModel result);
+   *  null when unresolved. */
+  model: string | null;
 }
 
 export async function runVerifyProbe(
@@ -61,18 +75,24 @@ export async function runVerifyProbe(
     },
   ];
   const timeoutMs = args.timeoutMs ?? 30_000;
+  const stream = args.stream ?? streamLLM;
   try {
     const text = await Promise.race([
-      streamLLM(req, () => { /* silent */ }, model ? { model } : {}),
+      stream(req, () => { /* silent */ }, model ? { model } : {}),
       new Promise<string>((_, reject) =>
         setTimeout(() => reject(new Error('verify probe timeout')), timeoutMs),
       ),
     ]);
     const notes = stripCompactScratchpad(text).trim();
     const ok = /^none\b/i.test(notes) || notes.length === 0;
-    return { ok, notes };
+    const status: VerifyProbeStatus = ok ? 'pass' : 'fail';
+    const result: VerifyProbeResult = { ok, notes, status, model: model ?? null };
+    debug.log('compact.verify-probe', 'probe-result', { status, model });
+    return result;
   } catch {
     // Probe failure is non-fatal — accept the summary by default.
-    return { ok: true, notes: '' };
+    const result: VerifyProbeResult = { ok: true, notes: '', status: 'error', model: model ?? null };
+    debug.log('compact.verify-probe', 'probe-result', { status: result.status, model: result.model });
+    return result;
   }
 }

package/src/context-card/index.ts

@@ -43,3 +43,53 @@ export function serializeContextCard(card: ContextCard, maxChars = CONTEXT_CARD_
   if (length(text) > maxChars) throw new RangeError('card core and omission counts exceed maxChars');
   return text;
 }
+
+/** RFC context-diet §3a — exact fallback wording for a PR body that states no conclusion / could not be read. */
+export const PR_CONCLUSION_NONE = '없음(원문에 결론 없음)';
+export const PR_CONCLUSION_UNREADABLE = '확인 불가';
+
+export interface PrConclusionCardInput {
+  readonly id: string;
+  /** First paragraph of the original body; empty or omitted means the original states no conclusion. */
+  readonly firstParagraph?: string;
+  /** Set when the original body could not be read at all. */
+  readonly unreadable?: boolean;
+  readonly pointers: readonly string[];
+  readonly source: string;
+  readonly updatedAt: string;
+  readonly supersedes?: string;
+}
+
+/** First blank-line-delimited paragraph of the original body, or '' when the body is blank. */
+export function firstParagraphOf(body: string): string {
+  const trimmed = body.trim();
+  return trimmed ? (trimmed.split(/\n\s*\n/)[0] ?? '') : '';
+}
+
+const oneLine = (text: string): string => text.replace(/\s+/g, ' ').trim();
+
+/** kind-'pr' conclusion card on the existing ContextCard schema; why/verdict/remaining stay empty unless grounded. */
+export function buildPrConclusionCard(input: PrConclusionCardInput): ContextCard {
+  const conclusion = input.unreadable
+    ? PR_CONCLUSION_UNREADABLE
+    : oneLine(input.firstParagraph ?? '') || PR_CONCLUSION_NONE;
+  return {
+    id: input.id,
+    kind: 'pr',
+    conclusion,
+    why: '',
+    verdict: '',
+    remaining: [],
+    pointers: [...input.pointers],
+    source: input.source,
+    updatedAt: input.updatedAt,
+    ...(input.supersedes === undefined ? {} : { supersedes: input.supersedes }),
+  };
+}
+
+/** §3a display header; fallback conclusions keep the prescribed wording verbatim with no pointer suffix. */
+export function prConclusionCardHeader(card: ContextCard): string {
+  const fallback = card.conclusion === PR_CONCLUSION_NONE || card.conclusion === PR_CONCLUSION_UNREADABLE;
+  const pointers = card.pointers.join(' · ');
+  return `결론: ${card.conclusion}${fallback || !pointers ? '' : ` · 포인터: ${pointers}`}`;
+}

package/src/control/control-status.ts

@@ -1,5 +1,7 @@
 import { readHqLease } from '../hq/hq.js';
 import { fileLeaseStore } from '../hq/lease.js';
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { getElanousConfigDirOverride } from '../elanous-config-dir.js';
@@ -20,6 +22,8 @@ export interface ControlStatusRow {
 export interface ControlStatusDeps {
   readLease?: () => ReturnType<typeof readHqLease> | Promise<ReturnType<typeof readHqLease>>;
   readVersion?: () => ControlStatusRow | Promise<ControlStatusRow>;
+  /** Prefix that holds this machine's install.json. Defaults to ~/.local/share/elanous. */
+  installRoot?: string;
   readResources?: () => ControlStatusRow | Promise<ControlStatusRow>;
   readCredentials?: () => ControlStatusRow | Promise<ControlStatusRow>;
   readFreeze?: () => ReturnType<typeof readLandingFreeze> | Promise<ReturnType<typeof readLandingFreeze>>;
@@ -31,6 +35,31 @@ export interface ControlStatusDeps {
 
 const missing = (row: ControlStatusRowName, reason: string): ControlStatusRow => ({ row, state: 'unmeasured', text: '못 쟀다', reason });
 
+function localInstallRoot(): string {
+  return join(homedir(), '.local', 'share', 'elanous');
+}
+
+/** This machine's install.json only — daemon and public versions stay unconnected. */
+function localInstallVersionRow(installRoot = localInstallRoot()): ControlStatusRow {
+  let raw: string;
+  try {
+    raw = readFileSync(join(installRoot, 'install.json'), 'utf8');
+  } catch (error) {
+    return missing('판', (error as NodeJS.ErrnoException).code === 'ENOENT' ? '이 기계 install.json 없음' : '이 기계 install.json 읽기 실패');
+  }
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return missing('판', '이 기계 install.json 파싱 실패');
+    const record = parsed as { version?: unknown; commit?: unknown };
+    const version = typeof record.version === 'string' ? record.version.trim() : '';
+    const sha = typeof record.commit === 'string' ? record.commit.trim() : '';
+    if (!version || !sha) return missing('판', '이 기계 install.json에 판·sha 없음');
+    return { row: '판', state: 'ok', text: `설치본 ${version} · ${sha}` };
+  } catch {
+    return missing('판', '이 기계 install.json 파싱 실패');
+  }
+}
+
 /** Read-only snapshot: each source fails independently; no lease renewal, freeze mutation or config sync. */
 export async function collectControlStatus(deps: ControlStatusDeps = {}): Promise<ControlStatusRow[]> {
   const rows: ControlStatusRow[] = [];
@@ -55,7 +84,7 @@ export async function collectControlStatus(deps: ControlStatusDeps = {}): Promis
     return { row: '집', state: expired ? 'warn' : 'ok',
       text: `본부 ${record.holder} · 세대 ${record.generation} · ${ageSeconds}초 전 · ${expired ? '만료' : '유효'}` };
   });
-  await add('판', deps.readVersion ?? (() => missing('판', '기계별 install.json·데몬 판·공개 판 원천 미연결')));
+  await add('판', deps.readVersion ?? (() => localInstallVersionRow(deps.installRoot)));
   await add('자원', deps.readResources ?? (() => missing('자원', '기계별 Pod 실행/대기/실패·풀 상한·호스트 부하 원천 미연결')));
   await add('자격', deps.readCredentials ?? (() => missing('자격', '계정별 만료·쿼터·갱신자 원천 미연결')));
   await add('동결·몫', async () => {

package/src/core-turn/run-goal-loop.ts

@@ -212,9 +212,10 @@ export const GOAL_INTENT_STALL_PROMPT = [
 /** 재촉 상한 — 이 횟수를 쓰고도 텍스트만이면 종전 ④(텍스트 수용)로 그대로 떨어진다. */
 export const GOAL_INTENT_STALL_MAX_REPROMPTS = 2;
 
-/** 재촉 가드가 켜지는 provider — ⭐ 이번 조각은 OpenRouter(오픈웨이트 모델) 구현 자식 «한정»이다
- *  (OP 10-10 결정 · 실측 GLM Flash 첫 턴 40토큰 말만 하고 abandoned). 다른 provider 는 종전 그대로. */
-export const GOAL_INTENT_STALL_PROVIDERS: ReadonlySet<string> = new Set(['openrouter']);
+/** 재촉 가드가 켜지는 provider — 구현 자식을 내는 provider 전부(10-11 · 첫 조각 #25876 은 OpenRouter 한정이었다 ·
+ *  실측 GLM Flash 첫 턴 40토큰 말만 하고 abandoned). 재촉은 «도구 0회·텍스트만» 턴에만 걸리므로 도구를 부르는 자식에는 영향이 없다.
+ *  목록 밖 provider(local 등)는 종전 그대로 바로 수용한다. */
+export const GOAL_INTENT_STALL_PROVIDERS: ReadonlySet<string> = new Set(['openrouter', 'openai-codex', 'anthropic', 'grok', 'bedrock']);
 
 /** evidence 누락 complete 재주입 — update_goal(complete) 를 호출했으나 evidence 가 비었을 때. */
 export const GOAL_EVIDENCE_REQUIRED_PROMPT = [
@@ -280,7 +281,7 @@ export interface GoalLoopOptions {
   controlSpaceId?: string | null;
   /** Test seam — file-backed child liveness heartbeat. Default starts the workspace-file writer. */
   startLivenessHeartbeat?: typeof startChildLivenessHeartbeat;
-  /** GOAL-LOOP-INTENT-STALL — 구현 자식의 LLM provider. `openrouter` 일 때만 «도구 0회·텍스트만» 턴을
+  /** GOAL-LOOP-INTENT-STALL — 구현 자식의 LLM provider. GOAL_INTENT_STALL_PROVIDERS 에 있을 때만 «도구 0회·텍스트만» 턴을
    *  최대 2번 재촉한다. 생략하면 harness role 이 executor 인 프로세스에서만 활성 provider 로 푼다.
    *  null = 가드 꺼짐. 시험은 이 인자를 명시해 env 에 기대지 않는다. */
   intentStallProvider?: string | null;

package/src/dashboard/ad-run-setup-bindings.ts

@@ -0,0 +1,279 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { buildAdRunSetup } from '../ad-pipeline/ad-run-setup.js';
+import type { CommandRunner } from '../ad-pipeline/higgsfield-backend.js';
+import type { ShootRunOptions } from '../ad-pipeline/shoot-run.js';
+import type { QcThresholds } from '../ad-pipeline/qc.js';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import {
+  createDashboardAdSlashRuntime as createAdSlashRuntime,
+  type DashboardAdSlashRuntime,
+  type DashboardAdSlashRuntimeDeps,
+} from './ad-slash-runtime.js';
+
+const dashboardDefaultShootRunOptions: Required<Pick<ShootRunOptions, 'pollIntervalMs' | 'maxPollsPerJob' | 'submitStaggerMs'>> = {
+  pollIntervalMs: 3_000,
+  // 2026-09-12 seedance_2_0 measured 330–400s; 174 polls = 522s, leaving 402s after six 20s staggers.
+  maxPollsPerJob: 174,
+  submitStaggerMs: 20_000,
+};
+
+/**
+ * ⛔ `src/ad-pipeline/ad-run-setup.ts` 의 `optionalProductionInputs` «사본»이다 — 그 목록은 export 가 아니다.
+ * 여기서 다시 세는 이유: 이 파일이 `buildAdRunSetup` «뒤»에 `assemblyMaterials` 를 덧붙이므로,
+ * 그 함수가 «입력» 기준으로 낸 목록은 최종 `production` 과 어긋난다(`#17880`).
+ * ⚠️ 사본이라 «늙는다» — `src/dashboard/index.test.ts` 가 권위 목록과 같은지 단언한다.
+ */
+export const dashboardOptionalProductionInputs = [
+  'assembly',
+  'assemblyMaterials',
+  'captionFontPath',
+  'musicBedPath',
+  'qcThresholds',
+  'voiceover',
+  'soundtrack',
+  'referenceAssets',
+  'shootRunOptions',
+  'ground',
+  'invariants',
+] as const;
+
+export interface DashboardAdAssetPreset {
+  readonly captionFontPath?: string;
+  readonly musicBedPath?: string;
+  readonly referenceAssets?: Readonly<Record<string, string[]>>;
+  readonly shootRunOptions?: ShootRunOptions;
+  readonly qcThresholds?: QcThresholds;
+}
+
+/** Operator-owned, instance-scoped optional asset preset; never a repository asset path. */
+export function dashboardAdAssetPresetPath(stateRoot = elanousStateRoot()): string {
+  return join(stateRoot, 'ad-assets.json');
+}
+
+/** Reads optional operator-owned asset paths without inventing local defaults. */
+export function loadDashboardAdAssetPreset(path: string): DashboardAdAssetPreset {
+  let raw: string;
+  try {
+    raw = readFileSync(path, 'utf8');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return {};
+    throw new Error(`dashboard ad asset preset unreadable at ${path}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`dashboard ad asset preset malformed at ${path}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error(`dashboard ad asset preset malformed at ${path}: expected an object`);
+  }
+
+  const preset = parsed as Record<string, unknown>;
+  for (const key of ['captionFontPath', 'musicBedPath'] as const) {
+    if (preset[key] !== undefined && typeof preset[key] !== 'string') {
+      throw new Error(`dashboard ad asset preset malformed at ${path}: ${key} must be a string`);
+    }
+  }
+  if (preset.referenceAssets !== undefined && (
+    preset.referenceAssets === null
+    || typeof preset.referenceAssets !== 'object'
+    || Array.isArray(preset.referenceAssets)
+    || Object.values(preset.referenceAssets).some((value) => !Array.isArray(value) || value.some((entry) => typeof entry !== 'string'))
+  )) {
+    throw new Error(`dashboard ad asset preset malformed at ${path}: referenceAssets must be a record of string arrays`);
+  }
+  if (preset.shootRunOptions !== undefined && (
+    preset.shootRunOptions === null
+    || typeof preset.shootRunOptions !== 'object'
+    || Array.isArray(preset.shootRunOptions)
+  )) {
+    throw new Error(`dashboard ad asset preset malformed at ${path}: shootRunOptions must be an object`);
+  }
+  const shootRunOptions = preset.shootRunOptions as Record<string, unknown> | undefined;
+  for (const key of ['pollIntervalMs', 'maxPollsPerJob', 'maxPollElapsedMs', 'submitStaggerMs', 'submitRetries'] as const) {
+    if (shootRunOptions?.[key] !== undefined && (typeof shootRunOptions[key] !== 'number' || !Number.isFinite(shootRunOptions[key]))) {
+      throw new Error(`dashboard ad asset preset malformed at ${path}: shootRunOptions.${key} must be a finite number`);
+    }
+  }
+  if (preset.qcThresholds !== undefined && (
+    preset.qcThresholds === null
+    || typeof preset.qcThresholds !== 'object'
+    || Array.isArray(preset.qcThresholds)
+  )) {
+    throw new Error(`dashboard ad asset preset malformed at ${path}: qcThresholds must be an object`);
+  }
+  const qcThresholds = preset.qcThresholds as Record<string, unknown> | undefined;
+  for (const key of ['dialogueLufsTolerance', 'colorDistance', 'frameDiffVariance'] as const) {
+    if (qcThresholds?.[key] !== undefined && (typeof qcThresholds[key] !== 'number' || !Number.isFinite(qcThresholds[key]))) {
+      throw new Error(`dashboard ad asset preset malformed at ${path}: qcThresholds.${key} must be a finite number`);
+    }
+  }
+  if (qcThresholds?.durationRanges !== undefined && (
+    qcThresholds.durationRanges === null
+    || typeof qcThresholds.durationRanges !== 'object'
+    || Array.isArray(qcThresholds.durationRanges)
+  )) {
+    throw new Error(`dashboard ad asset preset malformed at ${path}: qcThresholds.durationRanges must be an object`);
+  }
+  const durationRanges = qcThresholds?.durationRanges as Record<string, unknown> | undefined;
+  for (const scope of ['cut', 'master'] as const) {
+    if (durationRanges?.[scope] !== undefined && (
+      durationRanges[scope] === null
+      || typeof durationRanges[scope] !== 'object'
+      || Array.isArray(durationRanges[scope])
+    )) {
+      throw new Error(`dashboard ad asset preset malformed at ${path}: qcThresholds.durationRanges.${scope} must be an object`);
+    }
+    const range = durationRanges?.[scope] as Record<string, unknown> | undefined;
+    if (range !== undefined) {
+      const minimumSeconds = range.minimumSeconds;
+      const maximumSeconds = range.maximumSeconds;
+      if (typeof minimumSeconds !== 'number' || !Number.isFinite(minimumSeconds)) {
+        throw new Error(`dashboard ad asset preset malformed at ${path}: qcThresholds.durationRanges.${scope}.minimumSeconds must be a finite number`);
+      }
+      if (typeof maximumSeconds !== 'number' || !Number.isFinite(maximumSeconds)) {
+        throw new Error(`dashboard ad asset preset malformed at ${path}: qcThresholds.durationRanges.${scope}.maximumSeconds must be a finite number`);
+      }
+      if (minimumSeconds > maximumSeconds) {
+        throw new Error(`dashboard ad asset preset malformed at ${path}: qcThresholds.durationRanges.${scope}.minimumSeconds must be less than or equal to maximumSeconds`);
+      }
+    }
+  }
+  return {
+    ...(typeof preset.captionFontPath === 'string' ? { captionFontPath: preset.captionFontPath } : {}),
+    ...(typeof preset.musicBedPath === 'string' ? { musicBedPath: preset.musicBedPath } : {}),
+    ...(preset.referenceAssets === undefined ? {} : { referenceAssets: preset.referenceAssets as Record<string, string[]> }),
+    ...(shootRunOptions === undefined ? {} : { shootRunOptions: shootRunOptions as ShootRunOptions }),
+    ...(qcThresholds === undefined ? {} : { qcThresholds: qcThresholds as QcThresholds }),
+  };
+}
+
+export const dashboardAdCommandRunner: CommandRunner = {
+  async run(argv, options) {
+    const process = Bun.spawn([...argv], {
+      stdout: 'pipe',
+      stderr: 'pipe',
+      ...(options?.timeoutMs ? { timeout: options.timeoutMs } : {}),
+    });
+    const [raw, stderr, exitCode] = await Promise.all([
+      new Response(process.stdout).bytes(),
+      new Response(process.stderr).text(),
+      process.exited,
+    ]);
+    return { stdout: new TextDecoder().decode(raw), stderr, exitCode, raw };
+  },
+};
+
+export function createDashboardAdRunSetupFactory(input: {
+  readonly home: string;
+  readonly date: string;
+  readonly contractsJson: string;
+  readonly runner: CommandRunner;
+  readonly assetPresetPath?: string;
+}): (allowSpend: boolean) => ReturnType<typeof buildAdRunSetup> {
+  let runSequence = 0;
+  let activeRunSlug: string | undefined;
+
+  return (allowSpend) => {
+    if (!allowSpend) {
+      const runStart = new Date();
+      const time = [runStart.getHours(), runStart.getMinutes(), runStart.getSeconds()]
+        .map((part) => String(part).padStart(2, '0'))
+        .join('');
+      activeRunSlug = `dashboard-ad-${time}-${++runSequence}`;
+    }
+    const slug = activeRunSlug ?? (() => {
+      const runStart = new Date();
+      const time = [runStart.getHours(), runStart.getMinutes(), runStart.getSeconds()]
+        .map((part) => String(part).padStart(2, '0'))
+        .join('');
+      return `dashboard-ad-${time}-${++runSequence}`;
+    })();
+    const assetPreset = input.assetPresetPath === undefined ? {} : loadDashboardAdAssetPreset(input.assetPresetPath);
+    let setup = buildAdRunSetup({
+      home: input.home,
+      slug,
+      date: input.date,
+      version: 1,
+      aspect: '9x16',
+      contractsJson: input.contractsJson,
+      runner: input.runner,
+      ...assetPreset,
+      referenceAssets: assetPreset.referenceAssets ?? {},
+      shootRunOptions: { ...dashboardDefaultShootRunOptions, ...assetPreset.shootRunOptions },
+      soundtrack: input.runner,
+      voiceover: { runner: input.runner, lines: [] },
+      allowSpend,
+    });
+    if (!('error' in setup) && setup.production) {
+      const production = {
+        ...setup.production,
+        assemblyMaterials: { options: { workDir: setup.workDir, outputName: setup.outputName } },
+      };
+      setup = {
+        ...setup,
+        production,
+        missingProductionInputs: dashboardOptionalProductionInputs.filter((key) => production[key] === undefined),
+      };
+    }
+    return setup;
+  };
+}
+
+/** Builds the /ad runtime bindings used by showDashboard for each invocation's spend intent. */
+export function createDashboardAdRunSetupBindings(
+  buildDashboardAdRunSetup: ReturnType<typeof createDashboardAdRunSetupFactory>,
+) {
+  let adRunSetup: ReturnType<typeof buildAdRunSetup> | undefined;
+  let outputSetupError: string | undefined;
+  try {
+    adRunSetup = buildDashboardAdRunSetup(false);
+    outputSetupError = 'error' in adRunSetup ? adRunSetup.error : undefined;
+  } catch (error) {
+    outputSetupError = error instanceof Error ? error.message : String(error);
+  }
+
+  return {
+    production: adRunSetup && !('error' in adRunSetup) ? adRunSetup.production : undefined,
+    productionForSpend: (allowSpend: boolean) => {
+      try {
+        const setup = buildDashboardAdRunSetup(allowSpend);
+        if ('error' in setup) {
+          outputSetupError = setup.error;
+          return undefined;
+        }
+        return setup.production;
+      } catch (error) {
+        outputSetupError = error instanceof Error ? error.message : String(error);
+        return undefined;
+      }
+    },
+    missingProductionInputs: adRunSetup && !('error' in adRunSetup) ? adRunSetup.missingProductionInputs : undefined,
+    get outputSetupError() {
+      return outputSetupError;
+    },
+  };
+}
+
+/** Connects the dashboard's setup state to the actual /ad runtime. */
+export function createDashboardAdSlashRuntime(
+  input: Omit<DashboardAdSlashRuntimeDeps, 'production' | 'productionForSpend' | 'missingProductionInputs' | 'outputSetupError'> & {
+    readonly adRunSetupBindings?: ReturnType<typeof createDashboardAdRunSetupBindings>;
+    readonly adRunSetupError?: string;
+  },
+): DashboardAdSlashRuntime {
+  const { adRunSetupBindings, adRunSetupError, ...deps } = input;
+  return createAdSlashRuntime({
+    ...deps,
+    production: adRunSetupBindings?.production,
+    productionForSpend: adRunSetupBindings?.productionForSpend,
+    missingProductionInputs: adRunSetupBindings?.missingProductionInputs,
+    get outputSetupError() {
+      return adRunSetupBindings?.outputSetupError ?? adRunSetupError;
+    },
+  });
+}
+