agent-mockingbird 0.0.1

package/apps/server/src/backend/config/semantic.ts

@@ -0,0 +1,149 @@
+import type { ConfigProvidersResponse } from "@opencode-ai/sdk/client";
+
+import type { AgentMockingbirdConfig } from "./schema";
+import { ConfigApplyError, type ConfigSemanticSummary } from "./types";
+import { createOpencodeClientFromConnection, unwrapSdkData } from "../opencode/client";
+
+export function resolveModelRefForValidation(
+  rawRef: string,
+  defaultProviderId: string,
+  modelsByProvider: Map<string, Set<string>>,
+) {
+  const trimmed = rawRef.trim();
+  const defaultProvider = defaultProviderId.trim();
+  if (!trimmed) {
+    throw new ConfigApplyError("schema", "Model reference must not be empty");
+  }
+  if (!defaultProvider) {
+    throw new ConfigApplyError("schema", "Default provider must not be empty");
+  }
+
+  // Model IDs can contain "/" (for example "zai-org/GLM-4.7-Flash"). Prefer
+  // exact match on the selected provider before treating the value as a
+  // qualified "provider/model" reference.
+  const defaultProviderModels = modelsByProvider.get(defaultProvider);
+  if (defaultProviderModels?.has(trimmed)) {
+    return { providerId: defaultProvider, modelId: trimmed };
+  }
+
+  if (!trimmed.includes("/")) {
+    return { providerId: defaultProvider, modelId: trimmed };
+  }
+
+  const [providerCandidate = "", ...rest] = trimmed.split("/");
+  const modelId = rest.join("/").trim();
+  const providerId = providerCandidate.trim();
+  if (!providerId || !modelId) {
+    throw new ConfigApplyError("schema", `Invalid model reference: ${rawRef}`);
+  }
+
+  if (modelsByProvider.has(providerId)) {
+    return { providerId, modelId };
+  }
+
+  return { providerId: defaultProvider, modelId: trimmed };
+}
+
+async function loadProviderModelMap(config: AgentMockingbirdConfig) {
+  try {
+    const client = createOpencodeClientFromConnection({
+      baseUrl: config.runtime.opencode.baseUrl,
+      directory: config.runtime.opencode.directory,
+    });
+    const payload = unwrapSdkData<ConfigProvidersResponse>(
+      await client.config.providers({
+        responseStyle: "data",
+        throwOnError: true,
+        signal: AbortSignal.timeout(config.runtime.opencode.timeoutMs),
+      }),
+    );
+    const modelsByProvider = new Map<string, Set<string>>();
+    let modelCount = 0;
+    for (const provider of payload.providers) {
+      const modelSet = new Set<string>();
+      for (const [modelKey, model] of Object.entries(provider.models)) {
+        modelSet.add((model.id ?? modelKey).trim());
+        modelCount += 1;
+      }
+      modelsByProvider.set(provider.id, modelSet);
+    }
+    return {
+      modelsByProvider,
+      providerCount: payload.providers.length,
+      modelCount,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to load OpenCode providers";
+    throw new ConfigApplyError("semantic", message);
+  }
+}
+
+function assertModelAvailable(
+  modelsByProvider: Map<string, Set<string>>,
+  providerId: string,
+  modelId: string,
+  field: string,
+) {
+  const providerModels = modelsByProvider.get(providerId);
+  if (!providerModels) {
+    throw new ConfigApplyError("semantic", `${field} references unknown provider: ${providerId}`);
+  }
+  if (!providerModels.has(modelId)) {
+    throw new ConfigApplyError("semantic", `${field} references unknown model: ${providerId}/${modelId}`);
+  }
+}
+
+export async function runSemanticValidation(config: AgentMockingbirdConfig): Promise<ConfigSemanticSummary> {
+  const providerMap = await loadProviderModelMap(config);
+  const primaryRef = resolveModelRefForValidation(
+    config.runtime.opencode.modelId,
+    config.runtime.opencode.providerId,
+    providerMap.modelsByProvider,
+  );
+  assertModelAvailable(providerMap.modelsByProvider, primaryRef.providerId, primaryRef.modelId, "runtime.opencode.modelId");
+
+  const smallModelRef = resolveModelRefForValidation(
+    config.runtime.opencode.smallModel,
+    config.runtime.opencode.providerId,
+    providerMap.modelsByProvider,
+  );
+  assertModelAvailable(
+    providerMap.modelsByProvider,
+    smallModelRef.providerId,
+    smallModelRef.modelId,
+    "runtime.opencode.smallModel",
+  );
+
+  for (const fallbackRef of config.runtime.opencode.fallbackModels) {
+    const parsedFallback = resolveModelRefForValidation(
+      fallbackRef,
+      config.runtime.opencode.providerId,
+      providerMap.modelsByProvider,
+    );
+    assertModelAvailable(
+      providerMap.modelsByProvider,
+      parsedFallback.providerId,
+      parsedFallback.modelId,
+      "runtime.opencode.fallbackModels",
+    );
+  }
+
+  if (config.runtime.opencode.imageModel?.trim()) {
+    const imageModelRef = resolveModelRefForValidation(
+      config.runtime.opencode.imageModel,
+      config.runtime.opencode.providerId,
+      providerMap.modelsByProvider,
+    );
+    assertModelAvailable(
+      providerMap.modelsByProvider,
+      imageModelRef.providerId,
+      imageModelRef.modelId,
+      "runtime.opencode.imageModel",
+    );
+  }
+
+  return {
+    providerCount: providerMap.providerCount,
+    modelCount: providerMap.modelCount,
+  };
+}

package/apps/server/src/backend/config/service.test.ts

@@ -0,0 +1,75 @@
+import { expect, test } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import { resolveExampleConfigPath } from "./testFixtures";
+
+test("applyConfigPatch skips OpenCode semantic validation for memory-only changes", async () => {
+  const tempRoot = mkdtempSync(path.join(tmpdir(), "agent-mockingbird-config-service-"));
+  const configPath = path.join(tempRoot, "agent-mockingbird.config.json");
+  const workspacePath = path.join(tempRoot, "workspace");
+  const fixturePath = resolveExampleConfigPath();
+  const raw = JSON.parse(readFileSync(fixturePath, "utf8")) as {
+    runtime?: {
+      configPolicy?: Record<string, unknown>;
+    };
+  };
+
+  const previousConfigPath = process.env.AGENT_MOCKINGBIRD_CONFIG_PATH;
+  const previousWorkspacePath = process.env.AGENT_MOCKINGBIRD_MEMORY_WORKSPACE_DIR;
+  const previousNodeEnv = process.env.NODE_ENV;
+  const previousFetch = globalThis.fetch;
+  const blockingFetch = Object.assign(
+    (input: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => {
+      void input;
+      void init;
+      throw new Error("semantic validation should not call fetch for memory-only patches");
+    },
+    previousFetch,
+  );
+
+  writeFileSync(configPath, JSON.stringify(raw, null, 2), "utf8");
+  process.env.NODE_ENV = "test";
+  process.env.AGENT_MOCKINGBIRD_CONFIG_PATH = configPath;
+  process.env.AGENT_MOCKINGBIRD_MEMORY_WORKSPACE_DIR = workspacePath;
+  globalThis.fetch = blockingFetch;
+
+  try {
+    const { getConfigSnapshot, applyConfigPatch } = await import("./service");
+    getConfigSnapshot();
+    const result = await applyConfigPatch({
+      runSmokeTest: false,
+      patch: {
+        runtime: {
+          memory: {
+            enabled: true,
+            embedProvider: "ollama",
+            embedModel: "granite-embedding:278m",
+            ollamaBaseUrl: "http://172.16.1.100:11434",
+          },
+        },
+      },
+    });
+
+    expect(result.snapshot.config.runtime.memory.ollamaBaseUrl).toBe("http://172.16.1.100:11434");
+  } finally {
+    globalThis.fetch = previousFetch;
+    if (previousConfigPath === undefined) {
+      delete process.env.AGENT_MOCKINGBIRD_CONFIG_PATH;
+    } else {
+      process.env.AGENT_MOCKINGBIRD_CONFIG_PATH = previousConfigPath;
+    }
+    if (previousWorkspacePath === undefined) {
+      delete process.env.AGENT_MOCKINGBIRD_MEMORY_WORKSPACE_DIR;
+    } else {
+      process.env.AGENT_MOCKINGBIRD_MEMORY_WORKSPACE_DIR = previousWorkspacePath;
+    }
+    if (previousNodeEnv === undefined) {
+      delete process.env.NODE_ENV;
+    } else {
+      process.env.NODE_ENV = previousNodeEnv;
+    }
+    rmSync(tempRoot, { recursive: true, force: true });
+  }
+});

package/apps/server/src/backend/config/service.ts

@@ -0,0 +1,207 @@
+import {
+  assertConfigPolicyAllows,
+  evaluateConfigPolicyForPatch,
+  evaluateConfigPolicyForReplace,
+} from "./policy";
+import type { AgentMockingbirdConfig } from "./schema";
+import { runSemanticValidation } from "./semantic";
+import { runSmokeTest } from "./smoke";
+import {
+  assertExpectedHashMatches,
+  ensureConfigSnapshot,
+  getConfig,
+  getConfigSnapshot,
+  mergeConfigPatch,
+  parseConfig,
+  persistConfigSnapshot,
+} from "./store";
+import {
+  ConfigApplyError,
+  type ConfigPolicySummary,
+  type ConfigSemanticSummary,
+  type ConfigSmokeTestSummary,
+} from "./types";
+
+export {
+  ConfigApplyError,
+  type ApplyConfigResult,
+} from "./types";
+
+async function applyCandidateConfig(
+  input: {
+    currentPath: string;
+    currentConfig: AgentMockingbirdConfig;
+    candidate: AgentMockingbirdConfig;
+    runSemanticValidation: boolean;
+    runSmokeValidation: boolean;
+    autoRollbackOnFailure: boolean;
+  },
+): Promise<{
+  snapshot: ReturnType<typeof persistConfigSnapshot>;
+  semantic: ConfigSemanticSummary;
+  smokeTest: ConfigSmokeTestSummary | null;
+}> {
+  const semantic = input.runSemanticValidation
+    ? await runSemanticValidation(input.candidate)
+    : { providerCount: 0, modelCount: 0 };
+  if (!input.runSmokeValidation) {
+    const snapshot = persistConfigSnapshot(input.currentPath, input.candidate);
+    return { snapshot, semantic, smokeTest: null };
+  }
+
+  if (!input.autoRollbackOnFailure) {
+    const smokeTest = await runSmokeTest(input.candidate);
+    const snapshot = persistConfigSnapshot(input.currentPath, input.candidate);
+    return { snapshot, semantic, smokeTest };
+  }
+
+  const attemptedSnapshot = persistConfigSnapshot(input.currentPath, input.candidate);
+  try {
+    const smokeTest = await runSmokeTest(input.candidate);
+    return { snapshot: attemptedSnapshot, semantic, smokeTest };
+  } catch (error) {
+    let rollbackSnapshot: ReturnType<typeof persistConfigSnapshot> | null = null;
+    try {
+      rollbackSnapshot = persistConfigSnapshot(input.currentPath, input.currentConfig);
+    } catch (rollbackError) {
+      const rollbackMessage =
+        rollbackError instanceof Error ? rollbackError.message : "Failed to rollback config";
+      throw new ConfigApplyError("rollback", rollbackMessage, {
+        attemptedHash: attemptedSnapshot.hash,
+        originalError: error instanceof Error ? error.message : "Smoke test failed",
+      });
+    }
+
+    if (error instanceof ConfigApplyError) {
+      throw new ConfigApplyError(error.stage, error.message, {
+        ...(error.details ?? {}),
+        rolledBack: true,
+        attemptedHash: attemptedSnapshot.hash,
+        restoredHash: rollbackSnapshot.hash,
+      });
+    }
+
+    const message = error instanceof Error ? error.message : "Smoke test failed";
+    throw new ConfigApplyError("smoke", message, {
+      rolledBack: true,
+      attemptedHash: attemptedSnapshot.hash,
+      restoredHash: rollbackSnapshot.hash,
+    });
+  }
+}
+
+export { ensureConfigSnapshot as ensureConfigFile, getConfigSnapshot, getConfig };
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function shouldRunSemanticValidation(current: AgentMockingbirdConfig, candidate: AgentMockingbirdConfig) {
+  return JSON.stringify(current.runtime.opencode) !== JSON.stringify(candidate.runtime.opencode);
+}
+
+export async function applyConfigPatch(input: {
+  patch: unknown;
+  expectedHash?: string;
+  runSmokeTest?: boolean;
+  safeMode?: boolean;
+}) {
+  const current = ensureConfigSnapshot();
+  if (!isPlainObject(input.patch)) {
+    throw new ConfigApplyError("request", "patch must be an object");
+  }
+
+  let policy: ConfigPolicySummary | null = null;
+  if (input.safeMode) {
+    policy = evaluateConfigPolicyForPatch(current.config, input.patch);
+    assertConfigPolicyAllows(policy);
+    if (policy.requireExpectedHash && !input.expectedHash) {
+      throw new ConfigApplyError("request", "expectedHash is required in safe mode");
+    }
+  }
+  assertExpectedHashMatches(current.hash, input.expectedHash);
+
+  const merged = mergeConfigPatch(current.config, input.patch);
+  const candidate = parseConfig(merged);
+  if (input.safeMode) {
+    policy = evaluateConfigPolicyForReplace(current.config, candidate);
+    assertConfigPolicyAllows(policy);
+  }
+
+  const runSmokeValidation = policy?.requireSmokeTest ? true : input.runSmokeTest !== false;
+  const runSemanticValidation = shouldRunSemanticValidation(current.config, candidate);
+  const validated = await applyCandidateConfig({
+    currentPath: current.path,
+    currentConfig: current.config,
+    candidate,
+    runSemanticValidation,
+    runSmokeValidation,
+    autoRollbackOnFailure: policy?.autoRollbackOnFailure ?? false,
+  });
+
+  return {
+    snapshot: validated.snapshot,
+    semantic: validated.semantic,
+    smokeTest: validated.smokeTest,
+    policy,
+  };
+}
+
+export async function replaceConfig(input: {
+  config: unknown;
+  expectedHash?: string;
+  runSmokeTest?: boolean;
+  safeMode?: boolean;
+}) {
+  const current = ensureConfigSnapshot();
+  const candidate = parseConfig(input.config);
+  let policy: ConfigPolicySummary | null = null;
+  if (input.safeMode) {
+    policy = evaluateConfigPolicyForReplace(current.config, candidate);
+    assertConfigPolicyAllows(policy);
+    if (policy.requireExpectedHash && !input.expectedHash) {
+      throw new ConfigApplyError("request", "expectedHash is required in safe mode");
+    }
+  }
+  assertExpectedHashMatches(current.hash, input.expectedHash);
+
+  const runSmokeValidation = policy?.requireSmokeTest ? true : input.runSmokeTest !== false;
+  const runSemanticValidation = shouldRunSemanticValidation(current.config, candidate);
+  const validated = await applyCandidateConfig({
+    currentPath: current.path,
+    currentConfig: current.config,
+    candidate,
+    runSemanticValidation,
+    runSmokeValidation,
+    autoRollbackOnFailure: policy?.autoRollbackOnFailure ?? false,
+  });
+
+  return {
+    snapshot: validated.snapshot,
+    semantic: validated.semantic,
+    smokeTest: validated.smokeTest,
+    policy,
+  };
+}
+
+export async function applyConfigPatchSafe(input: {
+  patch: unknown;
+  expectedHash?: string;
+  runSmokeTest?: boolean;
+}) {
+  return applyConfigPatch({
+    ...input,
+    safeMode: true,
+  });
+}
+
+export async function replaceConfigSafe(input: {
+  config: unknown;
+  expectedHash?: string;
+  runSmokeTest?: boolean;
+}) {
+  return replaceConfig({
+    ...input,
+    safeMode: true,
+  });
+}

package/apps/server/src/backend/config/smoke.ts

@@ -0,0 +1,77 @@
+import type { Part, Session } from "@opencode-ai/sdk/client";
+
+import type { AgentMockingbirdConfig } from "./schema";
+import { ConfigApplyError, type ConfigSmokeTestSummary } from "./types";
+import { createOpencodeClientFromConnection, unwrapSdkData } from "../opencode/client";
+
+function extractAssistantText(parts: Array<Part>) {
+  return parts
+    .filter((part): part is Extract<Part, { type: "text" }> => part.type === "text")
+    .map(part => part.text.trim())
+    .filter(Boolean)
+    .join("\n\n");
+}
+
+export async function runSmokeTest(config: AgentMockingbirdConfig): Promise<ConfigSmokeTestSummary> {
+  const client = createOpencodeClientFromConnection({
+    baseUrl: config.runtime.opencode.baseUrl,
+    directory: config.runtime.opencode.directory,
+  });
+
+  let expectedPattern: RegExp;
+  try {
+    expectedPattern = new RegExp(config.runtime.smokeTest.expectedResponsePattern, "i");
+  } catch {
+    throw new ConfigApplyError("schema", "runtime.smokeTest.expectedResponsePattern is not a valid regex");
+  }
+
+  try {
+    const session = unwrapSdkData<Session>(
+      await client.session.create({
+        body: { title: "agent-mockingbird-config-smoke" },
+        responseStyle: "data",
+        throwOnError: true,
+        signal: AbortSignal.timeout(config.runtime.opencode.timeoutMs),
+      }),
+    );
+
+    const response = unwrapSdkData<{ info: { role: string }; parts: Array<Part> }>(
+      await client.session.prompt({
+        path: { id: session.id },
+        body: {
+          model: {
+            providerID: config.runtime.opencode.providerId,
+            modelID: config.runtime.opencode.modelId,
+          },
+          parts: [{ type: "text", text: config.runtime.smokeTest.prompt }],
+        },
+        responseStyle: "data",
+        throwOnError: true,
+        signal: AbortSignal.timeout(config.runtime.opencode.promptTimeoutMs),
+      }),
+    );
+
+    const text = extractAssistantText(response.parts);
+    if (!text) {
+      throw new ConfigApplyError("smoke", "Smoke test returned no assistant text response");
+    }
+    if (!expectedPattern.test(text)) {
+      throw new ConfigApplyError(
+        "smoke",
+        `Smoke test response did not match expected pattern: ${config.runtime.smokeTest.expectedResponsePattern}`,
+        { responseText: text },
+      );
+    }
+
+    return {
+      sessionId: session.id,
+      responseText: text,
+    };
+  } catch (error) {
+    if (error instanceof ConfigApplyError) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : "Smoke test failed";
+    throw new ConfigApplyError("smoke", message);
+  }
+}

package/apps/server/src/backend/config/store.test.ts

@@ -0,0 +1,123 @@
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+import { parseConfig } from "./store";
+import { resolveExampleConfigPath } from "./testFixtures";
+import { ConfigApplyError } from "./types";
+
+test("parseConfig reports a clear error when AGENT_MOCKINGBIRD_CONFIG_PATH points to OpenCode config.json", () => {
+  expect(() =>
+    parseConfig({
+      $schema: "https://opencode.ai/config.json",
+      model: "anthropic/claude-opus-4-5",
+    }),
+  ).toThrowError(
+    new ConfigApplyError(
+      "schema",
+      "Config file appears to be OpenCode config.json, not Agent Mockingbird config. Set AGENT_MOCKINGBIRD_CONFIG_PATH to an Agent Mockingbird config file (default: ./data/agent-mockingbird.config.json).",
+    ),
+  );
+});
+
+test("parseConfig uses AGENT_MOCKINGBIRD_OPENCODE_* env vars as runtime fallbacks when fields are unset", () => {
+  const previousModelId = process.env.AGENT_MOCKINGBIRD_OPENCODE_MODEL_ID;
+  process.env.AGENT_MOCKINGBIRD_OPENCODE_MODEL_ID = "env-only-model";
+  try {
+    const filePath = resolveExampleConfigPath();
+    const raw = JSON.parse(readFileSync(filePath, "utf8")) as {
+      runtime?: { opencode?: Record<string, unknown> };
+    };
+    if (!raw.runtime?.opencode) {
+      throw new Error("Test fixture missing runtime.opencode");
+    }
+    delete raw.runtime.opencode.modelId;
+    expect(parseConfig(raw).runtime.opencode.modelId).toBe("env-only-model");
+  } finally {
+    if (previousModelId === undefined) {
+      delete process.env.AGENT_MOCKINGBIRD_OPENCODE_MODEL_ID;
+    } else {
+      process.env.AGENT_MOCKINGBIRD_OPENCODE_MODEL_ID = previousModelId;
+    }
+  }
+});
+
+test("parseConfig aligns runtime workspace paths to workspace.pinnedDirectory", () => {
+  const filePath = resolveExampleConfigPath();
+  const raw = JSON.parse(readFileSync(filePath, "utf8")) as {
+    workspace?: Record<string, unknown>;
+  };
+  if (!raw.workspace) {
+    throw new Error("Test fixture missing workspace settings");
+  }
+
+  raw.workspace.pinnedDirectory = "./custom-workspace";
+  const parsed = parseConfig(raw);
+  const expected = path.resolve(process.cwd(), "custom-workspace");
+  expect(parsed.workspace.pinnedDirectory).toBe(expected);
+  expect(parsed.runtime.opencode.directory).toBe(expected);
+  expect(parsed.runtime.memory.workspaceDir).toBe(expected);
+});
+
+test("parseConfig ignores legacy mismatched runtime workspace fields in favor of workspace.pinnedDirectory", () => {
+  const filePath = resolveExampleConfigPath();
+  const raw = JSON.parse(readFileSync(filePath, "utf8")) as {
+    workspace?: Record<string, unknown>;
+    runtime?: { opencode?: Record<string, unknown>; memory?: Record<string, unknown> };
+  };
+  if (!raw.workspace || !raw.runtime?.opencode || !raw.runtime.memory) {
+    throw new Error("Test fixture missing runtime workspace settings");
+  }
+
+  raw.workspace.pinnedDirectory = "/tmp/pinned-workspace";
+  raw.runtime.opencode.directory = "/tmp/opencode-workspace";
+  raw.runtime.memory.workspaceDir = "/tmp/memory-workspace";
+  const parsed = parseConfig(raw);
+  expect(parsed.workspace.pinnedDirectory).toBe("/tmp/pinned-workspace");
+  expect(parsed.runtime.opencode.directory).toBe("/tmp/pinned-workspace");
+  expect(parsed.runtime.memory.workspaceDir).toBe("/tmp/pinned-workspace");
+});
+
+test("example config no longer ships heartbeat config on the default build agent", () => {
+  const filePath = resolveExampleConfigPath();
+  const raw = JSON.parse(readFileSync(filePath, "utf8")) as {
+    ui?: { agentTypes?: Array<{ id?: string; heartbeat?: unknown }> };
+  };
+
+  const buildAgent = raw.ui?.agentTypes?.find(agent => agent.id === "build");
+  expect(buildAgent).toBeDefined();
+  expect(buildAgent?.heartbeat).toBeUndefined();
+});
+
+test("parseConfig migrates legacy agent heartbeat blocks into runtime.heartbeat", () => {
+  const filePath = resolveExampleConfigPath();
+  const raw = JSON.parse(readFileSync(filePath, "utf8")) as {
+    runtime?: Record<string, unknown>;
+    ui?: { agentTypes?: Array<Record<string, unknown>> };
+  };
+  if (!raw.runtime || !raw.ui?.agentTypes?.[0]) {
+    throw new Error("Test fixture missing runtime/ui.agentTypes");
+  }
+
+  delete raw.runtime.heartbeat;
+  raw.ui.agentTypes[0] = {
+    ...raw.ui.agentTypes[0],
+    id: "build",
+    model: "opencode/legacy-heartbeat-model",
+    heartbeat: {
+      enabled: true,
+      interval: "45m",
+      prompt: "legacy heartbeat prompt",
+      ackMaxChars: 123,
+    },
+  };
+
+  const parsed = parseConfig(raw);
+  expect(parsed.runtime.heartbeat.agentId).toBe("build");
+  expect(parsed.runtime.heartbeat.model).toBe("opencode/legacy-heartbeat-model");
+  expect(parsed.runtime.heartbeat.interval).toBe("45m");
+  expect(parsed.runtime.heartbeat.prompt).toBe("legacy heartbeat prompt");
+  expect(parsed.runtime.heartbeat.ackMaxChars).toBe(123);
+  expect(parsed.ui.agentTypes[0]?.id).toBe("build");
+  expect("heartbeat" in (parsed.ui.agentTypes[0] ?? {})).toBe(false);
+});