@osolmaz/pi-workflows 0.2.0 → 0.4.0

package/examples/controllers/pull-request.controller.ts

@@ -0,0 +1,215 @@
+import {
+  conditionFalse,
+  conditionTrue,
+  conditionUnknown,
+  defineController,
+  type ChildWorkflowRecord,
+} from "@osolmaz/pi-workflows/controllers";
+
+type PullRequestSpec = {
+  apiBaseUrl: string;
+  repository: string;
+  number: number;
+  expectedHeadSha: string;
+  repairWorkflow: string;
+  mergeApproved: boolean;
+};
+
+type PullRequestStatus = {
+  phase: "observing" | "repairing" | "waiting" | "ready" | "merged" | "blocked";
+  observedHeadSha?: string;
+};
+
+type PullRequest = {
+  merged: boolean;
+  merge_commit_sha?: string | null;
+  head: { sha: string };
+};
+
+type CommitStatus = {
+  state: "error" | "failure" | "pending" | "success";
+};
+
+export default defineController<PullRequestSpec, PullRequestStatus>({
+  name: "pull-request",
+  initialStatus: () => ({ phase: "observing" }),
+
+  async reconcile(ctx, resource) {
+    const client = new GitHubClient(resource.spec.apiBaseUrl, resource.spec.repository);
+    const pullRequest = await client.pullRequest(resource.spec.number, ctx.signal);
+    const observed = { observedHeadSha: pullRequest.head.sha };
+
+    if (pullRequest.merged) {
+      return ctx.settled({
+        controllerStatus: { phase: "merged", ...observed },
+        conditions: [conditionTrue("Ready", "Merged")],
+        workflowRun: null,
+      });
+    }
+    if (pullRequest.head.sha !== resource.spec.expectedHeadSha) {
+      return ctx.settled({
+        controllerStatus: { phase: "blocked", ...observed },
+        conditions: [conditionFalse("Ready", "HeadChanged")],
+      });
+    }
+
+    const child = await ctx.workflows.ensure({
+      requestKey: `repair:${resource.metadata.generation}:${pullRequest.head.sha}`,
+      workflow: resource.spec.repairWorkflow,
+      input: {
+        repository: resource.spec.repository,
+        number: resource.spec.number,
+        expectedHeadSha: pullRequest.head.sha,
+      },
+    });
+    const workflowRun = workflowReference(child);
+    if (child.state === "failed") {
+      return ctx.settled({
+        controllerStatus: { phase: "blocked", ...observed },
+        conditions: [conditionFalse("Ready", "RepairFailed", child.error)],
+        workflowRun,
+      });
+    }
+    if (child.state !== "succeeded") {
+      return ctx.requeueAfter(5_000, {
+        controllerStatus: { phase: "repairing", ...observed },
+        conditions: [conditionUnknown("Ready", "RepairRunning")],
+        workflowRun,
+      });
+    }
+
+    const checks = await client.commitStatus(pullRequest.head.sha, ctx.signal);
+    if (checks.state !== "success") {
+      return ctx.requeueAfter(30_000, {
+        controllerStatus: { phase: "waiting", ...observed },
+        conditions: [conditionUnknown("Ready", "ChecksPending", checks.state)],
+        workflowRun,
+      });
+    }
+    if (!resource.spec.mergeApproved) {
+      return ctx.settled({
+        controllerStatus: { phase: "ready", ...observed },
+        conditions: [conditionFalse("Ready", "ApprovalRequired")],
+        workflowRun,
+      });
+    }
+
+    const effect = await ctx.effects.ensure({
+      key: `merge:${resource.metadata.generation}:${pullRequest.head.sha}`,
+      kind: "github-merge",
+      request: {
+        repository: resource.spec.repository,
+        number: resource.spec.number,
+        expectedHeadSha: pullRequest.head.sha,
+      },
+      observe: async (signal) => {
+        const latest = await client.pullRequest(resource.spec.number, signal);
+        return latest.merged
+          ? {
+              state: "applied",
+              ...(latest.merge_commit_sha ? { externalRef: latest.merge_commit_sha } : {}),
+            }
+          : { state: "not_applied" };
+      },
+      apply: async (signal) =>
+        await client.merge(resource.spec.number, pullRequest.head.sha, signal),
+    });
+    if (effect.state === "rejected") {
+      return ctx.settled({
+        controllerStatus: { phase: "blocked", ...observed },
+        conditions: [conditionFalse("Ready", "MergeRejected", effect.error)],
+        workflowRun,
+      });
+    }
+    if (effect.state === "indeterminate") {
+      return ctx.requeueAfter(10_000, {
+        controllerStatus: { phase: "waiting", ...observed },
+        conditions: [conditionUnknown("Ready", "MergeUncertain", effect.error)],
+        workflowRun,
+      });
+    }
+    return ctx.requeue({
+      controllerStatus: { phase: "waiting", ...observed },
+      conditions: [conditionUnknown("Ready", "MergeSubmitted")],
+      workflowRun,
+    });
+  },
+});
+
+class GitHubClient {
+  private readonly baseUrl: URL;
+  private readonly owner: string;
+  private readonly repository: string;
+
+  constructor(baseUrl: string, repository: string) {
+    this.baseUrl = new URL(baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`);
+    const parts = repository.split("/");
+    if (parts.length !== 2 || parts.some((part) => part.length === 0)) {
+      throw new Error(`Invalid repository: ${repository}`);
+    }
+    this.owner = parts[0] as string;
+    this.repository = parts[1] as string;
+  }
+
+  async pullRequest(number: number, signal: AbortSignal): Promise<PullRequest> {
+    return await this.request<PullRequest>(`pulls/${number}`, { signal });
+  }
+
+  async commitStatus(sha: string, signal: AbortSignal): Promise<CommitStatus> {
+    return await this.request<CommitStatus>(`commits/${encodeURIComponent(sha)}/status`, {
+      signal,
+    });
+  }
+
+  async merge(number: number, headSha: string, signal: AbortSignal) {
+    const response = await this.rawRequest(`pulls/${number}/merge`, {
+      method: "PUT",
+      signal,
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ sha: headSha }),
+    });
+    const body = (await response.json()) as {
+      merged?: boolean;
+      message?: string;
+      sha?: string;
+    };
+    if (!response.ok || body.merged !== true) {
+      return { state: "rejected" as const, error: body.message ?? `HTTP ${response.status}` };
+    }
+    return {
+      state: "applied" as const,
+      ...(body.sha !== undefined ? { externalRef: body.sha } : {}),
+    };
+  }
+
+  private async request<T>(path: string, init: RequestInit): Promise<T> {
+    const response = await this.rawRequest(path, init);
+    if (!response.ok) {
+      throw new Error(`GitHub request failed with HTTP ${response.status}`);
+    }
+    return (await response.json()) as T;
+  }
+
+  private async rawRequest(path: string, init: RequestInit): Promise<Response> {
+    const url = new URL(
+      `repos/${encodeURIComponent(this.owner)}/${encodeURIComponent(this.repository)}/${path}`,
+      this.baseUrl,
+    );
+    return await fetch(url, {
+      ...init,
+      headers: {
+        accept: "application/vnd.github+json",
+        ...init.headers,
+      },
+    });
+  }
+}
+
+function workflowReference(child: ChildWorkflowRecord) {
+  return {
+    requestId: child.requestId,
+    ...(child.runId !== undefined ? { runId: child.runId } : {}),
+    state: child.state,
+    attempt: child.attempt,
+  };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@osolmaz/pi-workflows",
-  "version": "0.2.0",
-  "description": "Workflow engine, JSON control-flow tool, and live terminal viewer for the pi coding agent",
+  "version": "0.4.0",
+  "description": "Workflow and controller runtime with a live terminal viewer for the pi coding agent",
   "keywords": [
     "pi-package"
   ],
@@ -34,6 +34,10 @@
     "./extension": {
       "types": "./dist/extension/index.d.ts",
       "default": "./dist/extension/index.js"
+    },
+    "./controllers": {
+      "types": "./dist/controllers/index.d.ts",
+      "default": "./dist/controllers/index.js"
     }
   },
   "publishConfig": {
@@ -53,10 +57,13 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
+    "better-sqlite3": "^13.0.2",
     "jiti": "^2.7.0"
   },
   "devDependencies": {
+    "@earendil-works/pi-ai": "^0.80.10",
     "@earendil-works/pi-coding-agent": "^0.80.10",
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^26.1.1",
     "@vitest/coverage-istanbul": "^4.1.10",
     "oxfmt": "^0.59.0",
@@ -67,6 +74,7 @@
     "vitest": "^4.1.10"
   },
   "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*",
     "typebox": "*"
   },

package/src/builtins/catalog.ts

@@ -0,0 +1,22 @@
+import { BuiltinWorkflowCatalog } from "../workflows/catalog.js";
+import monitorWorkflow from "./monitor.workflow.js";
+
+export const builtinWorkflowCatalog = new BuiltinWorkflowCatalog([
+  {
+    id: "monitor",
+    revision: "1",
+    definition: monitorWorkflow,
+    legacySources: [
+      {
+        workflowHash: "7a22158da94d18ec1c9fe42e70d72017a4e0620d5e5142ae839d0cd6eea55c06",
+        revision: "1",
+        pathSuffixes: [
+          "/src/builtins/monitor.workflow.ts",
+          "/dist/builtins/monitor.workflow.js",
+          "/src/workflows/monitor.workflow.ts",
+          "/dist/workflows/monitor.workflow.js",
+        ],
+      },
+    ],
+  },
+]);

package/src/builtins/monitor.workflow.ts

@@ -0,0 +1,302 @@
+import { agent, compute, defineWorkflow, shell } from "../workflows/definition.js";
+import type { WorkflowNodeContext } from "../workflows/types.js";
+
+const MIN_INTERVAL_MINUTES = 1;
+const MAX_INTERVAL_MINUTES = 24 * 60;
+const MIN_CHECK_TIMEOUT_MINUTES = 5;
+const MAX_CHECK_TIMEOUT_MINUTES = 24 * 60;
+const DEFAULT_MIN_CHECK_TIMEOUT_MINUTES = 60;
+const DEFAULT_MAX_CHECKS = 1_000;
+const MAX_CHECKS = 1_000;
+const MAX_OBSERVATION_CHARS = 8_000;
+const MAX_REPORT_CHARS = 4_000;
+const MAX_REASON_CHARS = 2_000;
+const SLEEP_TIMEOUT_MARGIN_MS = 60_000;
+const NODE_TIMEOUT_MARGIN_MS = 2 * 60_000;
+
+type MonitorInput = {
+  task: string;
+  everyMinutes: number;
+  reportWhen?: string;
+  stopWhen?: string;
+  maxChecks?: number;
+  checkTimeoutMinutes?: number;
+};
+
+type MonitorConfig = {
+  task: string;
+  everyMinutes: number;
+  reportWhen: string;
+  stopWhen: string;
+  maxChecks: number;
+  checkTimeoutMinutes: number;
+};
+
+type MonitorRoute = "continue_quiet" | "continue_report" | "stop_quiet" | "stop_report";
+
+type MonitorCheck = {
+  route: MonitorRoute;
+  observation: string;
+  report?: string;
+  reason: string;
+};
+
+const MONITOR_ROUTES = new Set<MonitorRoute>([
+  "continue_quiet",
+  "continue_report",
+  "stop_quiet",
+  "stop_report",
+]);
+
+function requireRecord(value: unknown, label: string): Record<string, unknown> {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value as Record<string, unknown>;
+}
+
+function requireBoundedString(value: unknown, label: string, maxChars: number): string {
+  if (typeof value !== "string") {
+    throw new Error(`${label} must be a string`);
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    throw new Error(`${label} must not be empty`);
+  }
+  if (trimmed.length > maxChars) {
+    throw new Error(`${label} must be at most ${maxChars} characters`);
+  }
+  return trimmed;
+}
+
+function prepareInput(input: unknown): MonitorConfig {
+  const value = requireRecord(input, "monitor input") as Partial<MonitorInput>;
+  const task = requireBoundedString(value.task, "task", 8_000);
+  if (
+    typeof value.everyMinutes !== "number" ||
+    !Number.isInteger(value.everyMinutes) ||
+    value.everyMinutes < MIN_INTERVAL_MINUTES ||
+    value.everyMinutes > MAX_INTERVAL_MINUTES
+  ) {
+    throw new Error(
+      `everyMinutes must be an integer from ${MIN_INTERVAL_MINUTES} through ${MAX_INTERVAL_MINUTES}`,
+    );
+  }
+  const maxChecks = value.maxChecks ?? DEFAULT_MAX_CHECKS;
+  if (!Number.isInteger(maxChecks) || maxChecks <= 0 || maxChecks > MAX_CHECKS) {
+    throw new Error(`maxChecks must be an integer from 1 through ${MAX_CHECKS}`);
+  }
+  const checkTimeoutMinutes =
+    value.checkTimeoutMinutes ?? Math.max(DEFAULT_MIN_CHECK_TIMEOUT_MINUTES, value.everyMinutes);
+  if (
+    !Number.isInteger(checkTimeoutMinutes) ||
+    checkTimeoutMinutes < MIN_CHECK_TIMEOUT_MINUTES ||
+    checkTimeoutMinutes > MAX_CHECK_TIMEOUT_MINUTES
+  ) {
+    throw new Error(
+      `checkTimeoutMinutes must be an integer from ${MIN_CHECK_TIMEOUT_MINUTES} through ${MAX_CHECK_TIMEOUT_MINUTES}`,
+    );
+  }
+  return {
+    task,
+    everyMinutes: value.everyMinutes,
+    reportWhen:
+      value.reportWhen === undefined
+        ? "The observed state changes materially or needs the user's attention."
+        : requireBoundedString(value.reportWhen, "reportWhen", 4_000),
+    stopWhen:
+      value.stopWhen === undefined
+        ? "The user cancels the monitor or it reaches its maximum check count."
+        : requireBoundedString(value.stopWhen, "stopWhen", 4_000),
+    maxChecks,
+    checkTimeoutMinutes,
+  };
+}
+
+function configFrom(outputs: Record<string, unknown>): MonitorConfig {
+  return outputs.prepare as MonitorConfig;
+}
+
+function agentTimeoutMs({ outputs }: WorkflowNodeContext): number {
+  return configFrom(outputs).checkTimeoutMinutes * 60_000;
+}
+
+function completedChecks(context: WorkflowNodeContext): number {
+  return context.state.steps.filter((step) => step.nodeId === "check" && step.outcome === "ok")
+    .length;
+}
+
+function validateCheck(output: unknown): MonitorCheck {
+  const value = requireRecord(output, "monitor check output");
+  if (typeof value.route !== "string" || !MONITOR_ROUTES.has(value.route as MonitorRoute)) {
+    throw new Error(`route must be one of ${[...MONITOR_ROUTES].join(", ")}`);
+  }
+  const route = value.route as MonitorRoute;
+  const observation = requireBoundedString(value.observation, "observation", MAX_OBSERVATION_CHARS);
+  const reason = requireBoundedString(value.reason, "reason", MAX_REASON_CHARS);
+  const reports = route === "continue_report" || route === "stop_report";
+  const report =
+    value.report === undefined
+      ? undefined
+      : requireBoundedString(value.report, "report", MAX_REPORT_CHARS);
+  if (reports && report === undefined) {
+    throw new Error(`route ${route} requires a report`);
+  }
+  return {
+    route,
+    observation,
+    ...(report !== undefined ? { report } : {}),
+    reason,
+  };
+}
+
+function validateReportAck(output: unknown): { reported: true } {
+  const value = requireRecord(output, "report acknowledgement");
+  if (value.reported !== true) {
+    throw new Error("report acknowledgement must set reported to true");
+  }
+  return { reported: true };
+}
+
+function reportPrompt(outputs: Record<string, unknown>): string {
+  const check = outputs.check as MonitorCheck;
+  return [
+    "Write one concise normal assistant message to the user with this monitoring update:",
+    check.report ?? check.observation,
+    "Do not add unrelated detail.",
+    "After writing the update, submit the acknowledgement required by the workflow step contract.",
+  ].join("\n\n");
+}
+
+export default defineWorkflow({
+  name: "monitor",
+  title: ({ input }) => {
+    try {
+      const task = prepareInput(input).task;
+      return `monitor: ${task.slice(0, 80)}`;
+    } catch {
+      return "monitor";
+    }
+  },
+  presentationPrompt: ({ finalOutput }) => {
+    const result = requireRecord(finalOutput, "monitor result");
+    if (result.reported === true) {
+      return undefined;
+    }
+    return `Tell the user concisely why this monitor stopped: ${String(result.reason ?? "monitor ended")}`;
+  },
+  startAt: "prepare",
+  maxSteps: 5_010,
+  nodes: {
+    prepare: compute({
+      run: ({ input }) => prepareInput(input),
+    }),
+    guard: compute({
+      run: (context) => {
+        const config = configFrom(context.outputs);
+        const checks = completedChecks(context);
+        return checks >= config.maxChecks
+          ? { route: "stop", checks, reason: `Reached the ${config.maxChecks}-check limit.` }
+          : { route: "check", checks };
+      },
+    }),
+    continue_guard: compute({
+      run: (context) => {
+        const config = configFrom(context.outputs);
+        const checks = completedChecks(context);
+        return checks >= config.maxChecks
+          ? { route: "stop", checks, reason: `Reached the ${config.maxChecks}-check limit.` }
+          : { route: "sleep", checks };
+      },
+    }),
+    check: agent({
+      statusDetail: "checking monitored target",
+      timeoutMs: agentTimeoutMs,
+      prompt: (context) => {
+        const config = configFrom(context.outputs);
+        const previous = context.outputs.check as MonitorCheck | undefined;
+        const checkNumber = completedChecks(context) + 1;
+        return [
+          `Perform monitoring check ${checkNumber} of at most ${config.maxChecks}.`,
+          `Task: ${config.task}`,
+          `Report when: ${config.reportWhen}`,
+          `Stop when: ${config.stopWhen}`,
+          previous === undefined
+            ? "There is no previous observation. Report the initial state only when the report condition calls for it."
+            : `Previous accepted observation: ${previous.observation}`,
+          "Use available tools to inspect the current state. Observe only unless the task explicitly authorizes a mutation.",
+          "Choose continue_quiet, continue_report, stop_quiet, or stop_report. A report route requires concise report text.",
+        ].join("\n\n");
+      },
+      expectedOutput:
+        '{ "route": "continue_quiet" | "continue_report" | "stop_quiet" | "stop_report", "observation": "current factual state", "report": "required for report routes", "reason": "short reason" }',
+      validate: (output) => validateCheck(output),
+    }),
+    report_continue: agent({
+      statusDetail: "reporting monitor update",
+      timeoutMs: agentTimeoutMs,
+      prompt: ({ outputs }) => reportPrompt(outputs),
+      expectedOutput: '{ "reported": true }',
+      validate: (output) => validateReportAck(output),
+    }),
+    report_stop: agent({
+      statusDetail: "reporting final monitor update",
+      timeoutMs: agentTimeoutMs,
+      prompt: ({ outputs }) => reportPrompt(outputs),
+      expectedOutput: '{ "reported": true }',
+      validate: (output) => validateReportAck(output),
+    }),
+    sleep: shell({
+      statusDetail: "waiting for next monitor check",
+      timeoutMs: MAX_INTERVAL_MINUTES * 60_000 + NODE_TIMEOUT_MARGIN_MS,
+      exec: ({ outputs }) => {
+        const config = configFrom(outputs);
+        const sleepMs = config.everyMinutes * 60_000;
+        return {
+          command: process.execPath,
+          args: ["-e", "setTimeout(() => {}, Number(process.argv[1]))", String(sleepMs)],
+          timeoutMs: sleepMs + SLEEP_TIMEOUT_MARGIN_MS,
+          maxOutputChars: 1_024,
+        };
+      },
+      parse: (_result, { outputs }) => ({ waitedMinutes: configFrom(outputs).everyMinutes }),
+    }),
+    finish: compute({
+      run: ({ outputs }) => {
+        const check = outputs.check as MonitorCheck | undefined;
+        const guard = outputs.guard as { reason?: string } | undefined;
+        const continueGuard = outputs.continue_guard as { reason?: string } | undefined;
+        return {
+          reason: continueGuard?.reason ?? guard?.reason ?? check?.reason ?? "Monitor finished.",
+          observation: check?.observation ?? null,
+          reported:
+            outputs.report_stop !== undefined ||
+            (check !== undefined && check.route === "stop_report"),
+        };
+      },
+    }),
+  },
+  edges: [
+    { from: "prepare", to: "guard" },
+    { from: "guard", switch: { on: "$.route", cases: { check: "check", stop: "finish" } } },
+    {
+      from: "check",
+      switch: {
+        on: "$.route",
+        cases: {
+          continue_quiet: "continue_guard",
+          continue_report: "report_continue",
+          stop_quiet: "finish",
+          stop_report: "report_stop",
+        },
+      },
+    },
+    { from: "report_continue", to: "continue_guard" },
+    { from: "report_stop", to: "finish" },
+    {
+      from: "continue_guard",
+      switch: { on: "$.route", cases: { sleep: "sleep", stop: "finish" } },
+    },
+    { from: "sleep", to: "guard" },
+  ],
+});

package/src/controllers/conditions.ts

@@ -0,0 +1,110 @@
+import type {
+  ControllerCondition,
+  ControllerConditionInput,
+  ControllerConditionStatus,
+  ControllerResourceStatus,
+  ControllerStatusPatch,
+} from "./types.js";
+
+export function conditionTrue(
+  type: string,
+  reason: string,
+  message?: string,
+): ControllerConditionInput {
+  return condition(type, true, reason, message);
+}
+
+export function conditionFalse(
+  type: string,
+  reason: string,
+  message?: string,
+): ControllerConditionInput {
+  return condition(type, false, reason, message);
+}
+
+export function conditionUnknown(
+  type: string,
+  reason: string,
+  message?: string,
+): ControllerConditionInput {
+  return condition(type, "unknown", reason, message);
+}
+
+export function applyStatusPatch<TStatus>(
+  current: ControllerResourceStatus<TStatus>,
+  patch: ControllerStatusPatch<TStatus> | undefined,
+  generation: number,
+  now: string,
+): ControllerResourceStatus<TStatus> {
+  return {
+    observedGeneration: generation,
+    conditions: mergeConditions(current.conditions, patch?.conditions ?? [], generation, now),
+    controllerStatus:
+      patch !== undefined && Object.hasOwn(patch, "controllerStatus")
+        ? (patch.controllerStatus as TStatus)
+        : current.controllerStatus,
+    ...(patch?.workflowRun === null
+      ? {}
+      : patch?.workflowRun !== undefined
+        ? { workflowRun: patch.workflowRun }
+        : current.workflowRun !== undefined
+          ? { workflowRun: current.workflowRun }
+          : {}),
+  };
+}
+
+export function mergeConditions(
+  current: ControllerCondition[],
+  updates: ControllerConditionInput[],
+  generation: number,
+  now: string,
+): ControllerCondition[] {
+  const byType = new Map(current.map((item) => [item.type, item]));
+  const seen = new Set<string>();
+  for (const update of updates) {
+    validateCondition(update);
+    if (seen.has(update.type)) {
+      throw new Error(`Condition ${JSON.stringify(update.type)} was updated more than once`);
+    }
+    seen.add(update.type);
+    const previous = byType.get(update.type);
+    const next: ControllerCondition = {
+      ...update,
+      observedGeneration: generation,
+      lastTransitionTime:
+        previous !== undefined && previous.status === update.status
+          ? previous.lastTransitionTime
+          : now,
+    };
+    byType.set(update.type, next);
+  }
+  return [...byType.values()];
+}
+
+function condition(
+  type: string,
+  status: ControllerConditionStatus,
+  reason: string,
+  message: string | undefined,
+): ControllerConditionInput {
+  const value: ControllerConditionInput = {
+    type,
+    status,
+    reason,
+    ...(message !== undefined ? { message } : {}),
+  };
+  validateCondition(value);
+  return value;
+}
+
+function validateCondition(value: ControllerConditionInput): void {
+  if (value.type.trim().length === 0) {
+    throw new Error("Condition type must not be empty");
+  }
+  if (value.reason.trim().length === 0) {
+    throw new Error("Condition reason must not be empty");
+  }
+  if (value.status !== true && value.status !== false && value.status !== "unknown") {
+    throw new Error(`Invalid condition status for ${JSON.stringify(value.type)}`);
+  }
+}