elanous 0.2.0 → 0.2.4

package/src/nexus/api/graph-kinds.ts

@@ -0,0 +1,69 @@
+import { parse as parseYaml } from 'yaml';
+import { debug } from '../../debug/log.js';
+import { listNodeKinds, type GraphKind } from '../../graph-kinds/registry.js';
+import { parseGraphTemplateYaml } from '../../self-implement/graph-yaml.js';
+import { parseWorkflowYaml } from '../../workflow-runtime/parser.js';
+import { checkAuth, type MetaApiOpts } from './meta-api.js';
+import { jsonResponse } from './json-response.js';
+
+function isGraph(value: unknown): value is GraphKind {
+  return value === 'harness' || value === 'workflow';
+}
+
+export function handleGraphKindsGet(req: Request, opts: MetaApiOpts): Response {
+  if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
+  const url = new URL(req.url);
+  const graph = url.searchParams.get('graph');
+  if (graph !== null && !isGraph(graph)) return jsonResponse({ error: 'bad_request', reason: 'graph must be harness or workflow' }, 400);
+  return jsonResponse({ kinds: listNodeKinds(graph ?? undefined).map(({ graph, kind, plugin, description, schema, core }) => ({ graph, kind, plugin, description, schema, core })) });
+}
+
+const harnessShape = {
+  graph_id: true, version: true, entry_node: true, terminal_nodes: true,
+  docs_only_gate_skip: true, state: true,
+  loop: { title: true, description: true, trigger: { cron: true, events: true } },
+  run_contract: { substrate: true, profile: true, effects: true },
+  nodes: [{ node_id: true, kind: true, recipe: true, max_visits: true, progress: true, phases: true, terminal_stages: true, fan_out: true,
+    contract: { inputs: true, tools: true, outputs: true } }],
+  edges: [{ from: true, to: true, on: true, map: '*' as const, observed: true,
+    fallback: [{ node: true, requires: true, observed: true }] }],
+};
+
+// The workflow validator keeps each node's input object intact, while it
+// normalizes the top-level fields and picks only the supported _meta fields.
+const workflowShape = {
+  name: true, description: true, provider: true, model: true, interactive: true,
+  nodes: ['*' as const], _meta: { missionId: true, intakeId: true, sourceTaskKey: true },
+};
+
+function ignoredPaths(input: unknown, shape: unknown, path = ''): string[] {
+  if (shape === '*' || shape === true) return [];
+  if (Array.isArray(input)) {
+    if (!Array.isArray(shape)) return [];
+    return input.flatMap((value, index) => ignoredPaths(value, shape[0], `${path}[${index}]`));
+  }
+  if (!input || typeof input !== 'object' || Array.isArray(shape) || !shape || typeof shape !== 'object') return [];
+  const allowed = shape as Record<string, unknown>;
+  return Object.entries(input as Record<string, unknown>).flatMap(([key, value]) => {
+    const child = path ? `${path}.${key}` : key;
+    return Object.hasOwn(allowed, key) ? ignoredPaths(value, allowed[key], child) : [child];
+  });
+}
+
+export async function handleGraphsValidatePost(req: Request, opts: MetaApiOpts): Promise<Response> {
+  if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
+  let body: unknown;
+  try { body = await req.json(); } catch { return jsonResponse({ error: 'bad_request', reason: 'JSON body required' }, 400); }
+  if (!body || typeof body !== 'object' || Array.isArray(body) || !isGraph((body as Record<string, unknown>).graph) || typeof (body as Record<string, unknown>).yaml !== 'string') {
+    return jsonResponse({ error: 'bad_request', reason: 'graph (harness|workflow) and yaml (string) required' }, 400);
+  }
+  const { graph, yaml } = body as { graph: GraphKind; yaml: string };
+  const result = graph === 'harness' ? parseGraphTemplateYaml(yaml) : parseWorkflowYaml(yaml);
+  const errors = graph === 'harness' ? (result as ReturnType<typeof parseGraphTemplateYaml>).errors : (result as ReturnType<typeof parseWorkflowYaml>).issues;
+  let input: unknown;
+  try { input = parseYaml(yaml); } catch { /* The parser already reports the YAML error. */ }
+  const ignoredKeys = ignoredPaths(input, graph === 'harness' ? harnessShape : workflowShape);
+  const ok = errors.length === 0;
+  debug.log('graph.kinds', 'validate', { graph, ok, errors, ignored: ignoredKeys });
+  return jsonResponse({ ok, errors, ignoredKeys }, ok ? 200 : 422);
+}

package/src/nexus/api/graphs-api.ts

@@ -0,0 +1,221 @@
+import { mkdtempSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { elanousStateRoot } from '../../autopilot/state-paths.js';
+import { defaultGraphsDir, loadGraphTemplatesFrom } from '../../self-implement/graph-templates.js';
+import { loadGraphTemplates } from '../../self-implement/graph-yaml.js';
+import { jsonResponse } from './json-response.js';
+
+/** Declared graph ids only. A user string is never joined onto a filesystem path. */
+const GRAPH_ID = /^[a-z0-9-]+$/;
+
+export interface GraphCatalogEntry {
+  id: string;
+  source: 'core' | 'mine';
+  editable: boolean;
+  nodeCount: number;
+}
+
+export interface GraphsApiDeps {
+  coreDir?: string;
+  mineDir?: string;
+}
+
+function mineGraphsDir(): string {
+  return join(elanousStateRoot(), 'graphs');
+}
+
+function resolveId(raw: string): string | null {
+  let id: string;
+  try { id = decodeURIComponent(raw); }
+  catch { return null; }
+  return GRAPH_ID.test(id) ? id : null;
+}
+
+function readDirYaml(dir: string): string[] {
+  try {
+    return readdirSync(dir).filter((name) => name.endsWith('.yaml') || name.endsWith('.yml')).sort();
+  } catch {
+    return [];
+  }
+}
+
+/** Index by the declared `graph_id`, never by the file name the caller supplied. */
+function indexByDeclaredId(dir: string): Map<string, { file: string; text: string }> {
+  const found = new Map<string, { file: string; text: string }>();
+  for (const file of readDirYaml(dir)) {
+    let text: string;
+    try { text = readFileSync(join(dir, file), 'utf8'); }
+    catch { continue; }
+    let raw: unknown;
+    try { raw = parseYaml(text); }
+    catch { continue; }
+    const id = raw !== null && typeof raw === 'object' && typeof (raw as { graph_id?: unknown }).graph_id === 'string'
+      ? (raw as { graph_id: string }).graph_id
+      : '';
+    if (!GRAPH_ID.test(id) || found.has(id)) continue;
+    found.set(id, { file, text });
+  }
+  return found;
+}
+
+function coreCatalog(dir: string): { ok: true; graphs: GraphCatalogEntry[] } | { ok: false; issues: unknown } {
+  const loaded = loadGraphTemplatesFrom(dir);
+  if (loaded.source !== 'yaml') return { ok: false, issues: loaded.issues };
+  const specs = loadGraphTemplates(dir);
+  if (specs.errors.length > 0) return { ok: false, issues: specs.errors };
+  return {
+    ok: true,
+    graphs: Object.values(loaded.templates).map((template) => ({
+      id: template.graphId, source: 'core', editable: false, nodeCount: template.nodes.length,
+    })),
+  };
+}
+
+function mineCatalog(dir: string): GraphCatalogEntry[] {
+  const specs = loadGraphTemplates(dir);
+  return Object.values(specs.templates)
+    .filter((template) => GRAPH_ID.test(template.graphId))
+    .map((template) => ({ id: template.graphId, source: 'mine' as const, editable: true, nodeCount: template.nodes.length }));
+}
+
+function detailOf(id: string, source: 'core' | 'mine', editable: boolean, dir: string): Response | null {
+  const loaded = loadGraphTemplatesFrom(dir);
+  const specs = loadGraphTemplates(dir);
+  const template = Object.hasOwn(loaded.templates, id) ? loaded.templates[id] : undefined;
+  const spec = Object.hasOwn(specs.templates, id) ? specs.templates[id] : undefined;
+  if (!template || !spec || template.graphId !== id) return null;
+  return jsonResponse({
+    id: spec.graphId,
+    source,
+    editable,
+    entry_node: template.entryNode,
+    terminal_nodes: template.terminalNodes,
+    nodes: template.nodes.map(({ nodeId, kind, recipe, maxVisits }) => ({ node_id: nodeId, kind, recipe, max_visits: maxVisits })),
+    edges: spec.edges.map(({ from, to, on, map }) => ({
+      from,
+      ...(to === undefined ? {} : { to }),
+      ...(on === undefined ? {} : { on }),
+      ...(map === undefined ? {} : { map }),
+    })),
+  });
+}
+
+/** Rewrite only the declared graph_id scalar. Every other byte, including comments, stays. */
+export function rewriteGraphId(text: string, newId: string): string | null {
+  const match = /^([ \t]*graph_id:[ \t]*)([^\n#]*?)([ \t]*(?:#.*)?)$/m.exec(text);
+  if (!match || match.index === undefined) return null;
+  const current = match[2]!.trim().replace(/^['"]|['"]$/g, '');
+  if (!GRAPH_ID.test(current)) return null;
+  return `${text.slice(0, match.index)}${match[1]}${newId}${match[3]}${text.slice(match.index + match[0].length)}`;
+}
+
+function validateInTemp(text: string, expectedId: string): { ok: true } | { ok: false; errors: unknown } {
+  const scratch = mkdtempSync(join(tmpdir(), 'elanous-graph-'));
+  try {
+    writeFileSync(join(scratch, `${expectedId}.yaml`), text);
+    const loaded = loadGraphTemplates(scratch);
+    if (loaded.errors.length > 0 || !Object.hasOwn(loaded.templates, expectedId)) {
+      return { ok: false, errors: loaded.errors.length > 0 ? loaded.errors : [{ path: expectedId, message: 'graph_id 가 요청 id 와 다르다' }] };
+    }
+    return { ok: true };
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+}
+
+/** Core graphs are read from the same YAML loader as the harness, never rewritten by this API. */
+export function handleGraphsGet(pathname: string, dir = defaultGraphsDir(), deps: GraphsApiDeps = {}): Response {
+  const coreDir = deps.coreDir ?? dir;
+  const mineDir = deps.mineDir ?? mineGraphsDir();
+  const core = coreCatalog(coreDir);
+  if (!core.ok && pathname === '/v1/graphs') return jsonResponse({ error: 'graphs-unavailable', issues: core.issues }, 503);
+
+  if (pathname === '/v1/graphs') {
+    const mine = mineCatalog(mineDir);
+    const coreIds = new Set((core.ok ? core.graphs : []).map((graph) => graph.id));
+    return jsonResponse({ graphs: [...(core.ok ? core.graphs : []), ...mine.filter((graph) => !coreIds.has(graph.id))] });
+  }
+
+  const yamlMatch = /^\/v1\/graphs\/([^/]+)\/yaml$/.exec(pathname);
+  if (yamlMatch) {
+    const id = resolveId(yamlMatch[1]!);
+    if (!id) return jsonResponse({ error: 'bad_request', reason: 'invalid graph id' }, 400);
+    const mineHit = indexByDeclaredId(mineDir).get(id);
+    const coreHit = core.ok ? indexByDeclaredId(coreDir).get(id) : undefined;
+    const hit = mineHit ?? coreHit;
+    if (!hit) return jsonResponse({ error: 'not-found', id }, 404);
+    return jsonResponse({ id, source: mineHit ? 'mine' : 'core', editable: Boolean(mineHit), yaml: hit.text });
+  }
+
+  const match = /^\/v1\/graphs\/([^/]+)$/.exec(pathname);
+  if (!match) return jsonResponse({ error: 'not-found' }, 404);
+  const id = resolveId(match[1]!);
+  if (!id) return jsonResponse({ error: 'not-found' }, 404);
+  if (core.ok && Object.hasOwn(loadGraphTemplatesFrom(coreDir).templates, id)) {
+    return detailOf(id, 'core', false, coreDir) ?? jsonResponse({ error: 'not-found', id }, 404);
+  }
+  if (indexByDeclaredId(mineDir).has(id)) {
+    return detailOf(id, 'mine', true, mineDir) ?? jsonResponse({ error: 'not-found', id }, 404);
+  }
+  return jsonResponse({ error: 'not-found', id }, 404);
+}
+
+/** PUT writes only under the state-root graphs directory. Core YAML is never opened for write. */
+export async function handleGraphsPut(pathname: string, req: Request, deps: GraphsApiDeps = {}): Promise<Response> {
+  const match = /^\/v1\/graphs\/([^/]+)\/yaml$/.exec(pathname);
+  if (!match) return jsonResponse({ error: 'not-found' }, 404);
+  const id = resolveId(match[1]!);
+  if (!id) return jsonResponse({ error: 'bad_request', reason: 'invalid graph id' }, 400);
+  const coreDir = deps.coreDir ?? defaultGraphsDir();
+  const mineDir = deps.mineDir ?? mineGraphsDir();
+  const core = coreCatalog(coreDir);
+  const coreOwns = core.ok && indexByDeclaredId(coreDir).has(id);
+  const mineOwns = indexByDeclaredId(mineDir).has(id);
+  if (coreOwns && !mineOwns) return jsonResponse({ error: 'core-read-only', id }, 403);
+  if (!mineOwns) return jsonResponse({ error: 'not-found', id }, 404);
+  let body: { yaml?: unknown };
+  try { body = await req.json() as { yaml?: unknown }; }
+  catch { return jsonResponse({ error: 'bad_request', reason: 'json body required' }, 400); }
+  if (typeof body.yaml !== 'string') return jsonResponse({ error: 'bad_request', reason: 'yaml string required' }, 400);
+  const checked = validateInTemp(body.yaml, id);
+  if (!checked.ok) return jsonResponse({ error: 'invalid-graph', errors: checked.errors }, 400);
+  const existing = indexByDeclaredId(mineDir).get(id)!;
+  writeFileSync(join(mineDir, existing.file), body.yaml);
+  return jsonResponse({ id, source: 'mine', editable: true, saved: true });
+}
+
+/** Copy core bytes into «my graphs», changing only the declared graph_id. */
+export async function handleGraphsClone(pathname: string, req: Request, deps: GraphsApiDeps = {}): Promise<Response> {
+  const match = /^\/v1\/graphs\/([^/]+)\/clone$/.exec(pathname);
+  if (!match) return jsonResponse({ error: 'not-found' }, 404);
+  const id = resolveId(match[1]!);
+  if (!id) return jsonResponse({ error: 'bad_request', reason: 'invalid graph id' }, 400);
+  let body: { newId?: unknown };
+  try { body = await req.json() as { newId?: unknown }; }
+  catch { return jsonResponse({ error: 'bad_request', reason: 'json body required' }, 400); }
+  if (typeof body.newId !== 'string' || !GRAPH_ID.test(body.newId) || body.newId === id) {
+    return jsonResponse({ error: 'bad_request', reason: 'newId must match [a-z0-9-]' }, 400);
+  }
+  const coreDir = deps.coreDir ?? defaultGraphsDir();
+  const mineDir = deps.mineDir ?? mineGraphsDir();
+  const source = indexByDeclaredId(coreDir).get(id) ?? indexByDeclaredId(mineDir).get(id);
+  if (!source) return jsonResponse({ error: 'not-found', id }, 404);
+  if (indexByDeclaredId(mineDir).has(body.newId) || indexByDeclaredId(coreDir).has(body.newId)) {
+    return jsonResponse({ error: 'conflict', id: body.newId }, 409);
+  }
+  const rewritten = rewriteGraphId(source.text, body.newId);
+  if (rewritten === null) return jsonResponse({ error: 'bad_request', reason: 'source graph_id is not rewritable' }, 400);
+  const checked = validateInTemp(rewritten, body.newId);
+  if (!checked.ok) return jsonResponse({ error: 'invalid-graph', errors: checked.errors }, 400);
+  mkdirSync(mineDir, { recursive: true });
+  writeFileSync(join(mineDir, `${body.newId}.yaml`), rewritten);
+  return jsonResponse({ id: body.newId, source: 'mine', editable: true, clonedFrom: id }, 201);
+}
+
+export async function handleGraphsMutation(pathname: string, req: Request, deps: GraphsApiDeps = {}): Promise<Response | null> {
+  if (req.method === 'PUT' && /^\/v1\/graphs\/[^/]+\/yaml$/.test(pathname)) return handleGraphsPut(pathname, req, deps);
+  if (req.method === 'POST' && /^\/v1\/graphs\/[^/]+\/clone$/.test(pathname)) return handleGraphsClone(pathname, req, deps);
+  return null;
+}

package/src/nexus/api/harness-api.ts

@@ -2,12 +2,16 @@ import { readFileSync, writeFileSync } from 'node:fs';
 import { relative } from 'node:path';
 import { debug } from '../../debug/log.js';
 import { enqueueSoftStop } from '../../harness/control-inbox.js';
-import { listHarnessScreens } from '../../harness/harness-screen.js';
+import { listHarnessScreens, readHarnessScreenTail } from '../../harness/harness-screen.js';
+import { queryRunScreenKey } from '../../self-implement/run-ledger.js';
+import { logsDbPath } from '../../mss/logging/log-store.js';
+import { redactSecretText } from '../../debug/log.js';
 import { runAskLaunchFlow, type AskLaunchFlowResult } from '../../self-dev/ask-launch-flow.js';
 import * as askIo from '../../self-dev/ask-launch-io.js';
 import { DAEMON_HARNESS_ASK_ENTRANCE } from '../../self-dev/entrance-registry.js';
 import { prepareAskLaunch } from '../../self-dev/launch-preflight.js';
 import { launchDevGoalFileDetached } from '../../self-implement/seams.js';
+import { encodeReportOriginEnv, readReportOrigin, REPORT_ORIGIN_ENV } from '../../self-implement/report-origin.js';
 import { loadGoalRunQuery, type GoalRunRecord } from '../../self-implement/goal-run-store.js';
 import { resolveHarnessTarget } from '../../self-implement/harness-target-options.js';
 import { queryRunningRuns, type RunningRunsResult } from '../../self-implement/running-runs.js';
@@ -94,6 +98,8 @@ export interface HarnessApiDeps {
   readonly askStatusRunLogStore?: Pick<LogStore, 'queryByDataKeys'>;
   readonly listHarnessScreens?: typeof listHarnessScreens;
   readonly enqueueSoftStop?: typeof enqueueSoftStop;
+  readonly queryRunScreenKey?: (runId: string) => Pick<ReturnType<typeof queryRunScreenKey>, 'screenKey' | 'logStoreStatus' | 'lastEvent'>;
+  readonly readHarnessScreenTail?: typeof readHarnessScreenTail;
   readonly createAcceptanceId?: () => string;
   readonly log?: (event: string, data: Record<string, unknown>) => void;
   readonly createFeedbackEmitter?: (acceptanceId: string) => (env: FeedbackEnvelope) => void | Promise<void>;
@@ -237,6 +243,10 @@ export async function handleHarnessAskPost(req: Request, _metaApi: HarnessMetaAp
 
   const acceptanceId = deps.createAcceptanceId?.() ?? crypto.randomUUID();
   const log = deps.log ?? ((event, data) => debug.log('harness-http', event, data));
+  const suppliedOrigin = (body as { origin?: unknown }).origin;
+  const origin = suppliedOrigin === undefined ? null
+    : readReportOrigin({ [REPORT_ORIGIN_ENV]: JSON.stringify(suppliedOrigin) });
+  if (suppliedOrigin !== undefined && !origin) log('ask-origin-ignored', { acceptanceId, reason: 'invalid-origin' });
   const ask = deps.runAskLaunchFlow ?? runAskLaunchFlow;
   const launch = deps.launchDevGoalFileDetached ?? launchDevGoalFileDetached;
   const emitFeedback = deps.createFeedbackEmitter?.(acceptanceId);
@@ -276,7 +286,7 @@ export async function handleHarnessAskPost(req: Request, _metaApi: HarnessMetaAp
       log('ask-flow-settled', { acceptanceId, kind: result.kind });
       if (result.kind === 'launch') {
         log('ask-launch-started', { acceptanceId, goalFile: result.goalFile });
-        await launch({ goalFile: result.goalFile, correlation: acceptanceId, ...(typeof target === 'string' ? { target } : {}) });
+        await launch({ goalFile: result.goalFile, correlation: acceptanceId, ...(typeof target === 'string' ? { target } : {}), ...(origin ? { env: encodeReportOriginEnv(origin) } : {}) });
         log('ask-launch-settled', { acceptanceId, goalFile: result.goalFile });
         emitCompletion(`Harness ask launched: ${result.goalFile}`);
       } else {
@@ -364,6 +374,25 @@ export function handleHarnessRunEventsGet(req: Request, _metaApi: HarnessMetaApi
   return json(events);
 }
 
+/** GET /v1/harness/run-screen?runId=&lines= — 런의 «화면»(Live 탭 런 서랍 · 🅢 09-28 «런 클릭 → 화면·로그·멈춤»).
+ *  runId → 화면 키는 `self screen --run` 과 같은 해석(`headless.spawn` 로그). ⛔ 이 인스턴스 로그만 본다 —
+ *  전 우주 스캔은 GET 한 번에 수백 저장소를 연다. 못 찾으면 «이유»를 값으로 돌려준다(오류 아님).
+ *  화면 글은 비밀처럼 보이는 조각을 가린다. `stoppable` = 그 화면이 살아 있어 `POST /v1/harness/stop` 이 받는다. */
+export function handleHarnessRunScreenGet(req: Request, _metaApi: HarnessMetaApi, deps: HarnessApiDeps = {}): Response {
+  const url = new URL(req.url);
+  const runId = url.searchParams.get('runId')?.trim() ?? '';
+  if (!runId || /[\\/]|\.\./.test(runId)) return json({ error: 'usage: GET /v1/harness/run-screen?runId=<runId>[&lines=60]' }, 400);
+  const lines = Math.min(200, Math.max(5, Number(url.searchParams.get('lines')) || 60));
+  const q = (deps.queryRunScreenKey ?? ((id: string) => queryRunScreenKey(id, { logStorePath: logsDbPath() })))(runId);
+  if (!q.screenKey) {
+    return json({ runId, screenKey: null, text: null, stoppable: false, reason: q.logStoreStatus === 'read' ? 'no-screen-key' : `log-store-${q.logStoreStatus}`, lastEvent: q.lastEvent });
+  }
+  const tail = (deps.readHarnessScreenTail ?? readHarnessScreenTail)(q.screenKey, lines);
+  const stoppable = (deps.listHarnessScreens ?? listHarnessScreens)().some((screen) => screen.spaceId === q.screenKey);
+  if (!tail) return json({ runId, screenKey: q.screenKey, text: null, stoppable, reason: 'screen-missing', lastEvent: q.lastEvent });
+  return json({ runId, screenKey: q.screenKey, text: redactSecretText(tail.text), outcome: tail.outcome, stoppable, lastEvent: q.lastEvent });
+}
+
 /** Queue a soft stop for an existing harness screen. */
 export async function handleHarnessStopPost(req: Request, _metaApi: HarnessMetaApi, deps: HarnessApiDeps = {}): Promise<Response> {
   let body: unknown;

package/src/nexus/api/health.ts

@@ -19,6 +19,17 @@ export type HealthTestUniverse = boolean | typeof UNKNOWN;
 /** Bind identity the HTTP server selected for Bun.listen. */
 export interface HealthBindContext {
   bindHost?: string;
+  /**
+   * 기동 때 한 번 정한 셋업 상태. `handleHealth` 의 선택 셋업 인자다.
+   * mode 가 참일 때만 health JSON 에 setupMode·setupMissing 을 싣는다.
+   */
+  setup?: HealthSetupContext;
+}
+
+/** 기동 때 한 번 정한 셋업 상태. mode 가 참일 때만 health JSON 에 칸을 싣는다. */
+export interface HealthSetupContext {
+  mode: boolean;
+  missing: string[];
 }
 
 interface HealthIdentityResolvers {
@@ -102,6 +113,7 @@ export function handleHealth(
   for (const t of tabs) {
     byStatus[t.status] = (byStatus[t.status] ?? 0) + 1;
   }
+  const setup = bind?.setup;
   return jsonResponse({
     ok: true,
     nexusVersion: state.nexusVersion,
@@ -116,5 +128,8 @@ export function handleHealth(
     universeRoot: safeUniverseRoot(),
     testUniverse: safeTestUniverse(),
     bindHost: safeBindHost(bind),
+    ...(setup?.mode === true
+      ? { setupMode: true as const, setupMissing: setup.missing }
+      : {}),
   });
 }