@omercnet/paseo-omp 0.2.1

package/server/quota.ts

@@ -0,0 +1,54 @@
+import { DatabaseSync } from "node:sqlite";
+import type { RpcInput } from "@getpaseo/plugin";
+import { z } from "zod";
+import type { listOmpQuotas, OmpQuota } from "../shared/quota";
+import { ompAgentDir } from "./paths";
+
+const QuotaRowSchema = z.object({
+  provider: z.string(),
+  label: z.string(),
+  windowLabel: z.string().nullable(),
+  usedFraction: z.number().min(0).nullable(),
+  status: z.string().nullable(),
+  resetsAt: z.number().int().nullable(),
+  recordedAt: z.number().int(),
+});
+
+export function listOmpQuotasFrom(path: string): OmpQuota[] {
+  try {
+    const database = new DatabaseSync(path, { readOnly: true, timeout: 500 });
+    try {
+      const rows = database
+        .prepare(
+          `SELECT provider, label, window_label AS windowLabel, used_fraction AS usedFraction,
+                  status, resets_at AS resetsAt, recorded_at AS recordedAt
+           FROM (
+             SELECT provider, account_key, limit_id, label, window_label, used_fraction, status,
+                    resets_at, recorded_at, id,
+                    ROW_NUMBER() OVER (
+                      PARTITION BY provider, account_key, limit_id
+                      ORDER BY recorded_at DESC, id DESC
+                    ) AS position
+             FROM usage_history
+           )
+           WHERE position = 1
+           ORDER BY COALESCE(usedFraction, -1) DESC, provider, label`,
+        )
+        .all();
+      return rows.flatMap((row) => {
+        const parsed = QuotaRowSchema.safeParse(row);
+        return parsed.success ? [parsed.data] : [];
+      });
+    } finally {
+      database.close();
+    }
+  } catch {
+    return [];
+  }
+}
+
+export function resolveListOmpQuotas(_input: RpcInput<typeof listOmpQuotas>): {
+  quotas: OmpQuota[];
+} {
+  return { quotas: listOmpQuotasFrom(`${ompAgentDir()}/agent.db`) };
+}

package/server/sessions.ts

@@ -0,0 +1,58 @@
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import type { RpcInput } from "@getpaseo/plugin";
+import { z } from "zod";
+import type { listOmpSessions, OmpSessionEntry } from "../shared/sessions";
+import { ompAgentDir } from "./paths";
+
+const PROMPT_LIMIT = 400;
+const ROW_LIMIT = 100;
+
+const SessionRowSchema = z.object({
+  id: z.number().int(),
+  sessionId: z.string().nullable(),
+  title: z.string().nullable(),
+  prompt: z.string(),
+  createdAt: z.number().int(),
+});
+
+export function listOmpSessionsFrom(path: string, cwd: string): OmpSessionEntry[] {
+  try {
+    const database = new DatabaseSync(path, { readOnly: true, timeout: 500 });
+    try {
+      const rows = database
+        .prepare(
+          `SELECT h.id AS id, h.session_id AS sessionId, t.title AS title,
+                  h.prompt AS prompt, h.created_at AS createdAt
+           FROM history h
+           LEFT JOIN session_titles t ON t.session_id = h.session_id
+           WHERE h.cwd = ?
+           ORDER BY h.created_at DESC, h.id DESC
+           LIMIT ?`,
+        )
+        .all(cwd, ROW_LIMIT);
+      return rows.flatMap((row) => {
+        const parsed = SessionRowSchema.safeParse(row);
+        if (!parsed.success) return [];
+        const truncated = parsed.data.prompt.length > PROMPT_LIMIT;
+        return [
+          {
+            ...parsed.data,
+            prompt: truncated ? parsed.data.prompt.slice(0, PROMPT_LIMIT) : parsed.data.prompt,
+            truncated,
+          },
+        ];
+      });
+    } finally {
+      database.close();
+    }
+  } catch {
+    return [];
+  }
+}
+
+export function resolveListOmpSessions({ cwd }: RpcInput<typeof listOmpSessions>): {
+  sessions: OmpSessionEntry[];
+} {
+  return { sessions: listOmpSessionsFrom(join(ompAgentDir(), "history.db"), cwd) };
+}

package/shared/hub.ts

@@ -0,0 +1,43 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+
+// Mirrors the on-disk shape omp's hub writes under
+// ~/.omp/run/daemons/<projectHash>/daemons/<name>/meta.json. That layout is an internal,
+// unversioned implementation detail of the omp harness, not a published API, so every field
+// here is optional-safe on the server side and this schema is intentionally permissive
+// (state is a free-form string, not a fixed enum) to avoid rejecting shapes we have not seen.
+export const HubProcessSchema = z.object({
+  name: z.string(),
+  application: z.string(),
+  args: z.array(z.string()),
+  cwd: z.string(),
+  state: z.string(),
+  owner: z.string().nullable(),
+  restartCount: z.number().int().nonnegative(),
+  persist: z.boolean(),
+  detached: z.boolean(),
+  createdAt: z.number().nullable(),
+  startedAt: z.number().nullable(),
+  readyAt: z.number().nullable(),
+  exitedAt: z.number().nullable(),
+  exitCode: z.number().nullable(),
+});
+export type HubProcess = z.infer<typeof HubProcessSchema>;
+const CwdSchema = z.string().min(1).max(4_096);
+const ProcessNameSchema = z
+  .string()
+  .min(1)
+  .max(128)
+  .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+
+export const listHubProcesses = defineRpc({
+  name: "paseo-omp.list-processes",
+  input: z.object({ cwd: CwdSchema }),
+  output: z.object({ processes: z.array(HubProcessSchema) }),
+});
+
+export const tailHubLog = defineRpc({
+  name: "paseo-omp.tail-log",
+  input: z.object({ cwd: CwdSchema, name: ProcessNameSchema }),
+  output: z.object({ content: z.string(), truncated: z.boolean() }),
+});

package/shared/memory.ts

@@ -0,0 +1,23 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+
+const CwdSchema = z.string().min(1).max(4_096);
+
+export const OmpMemoryFactSchema = z.object({
+  id: z.string(),
+  subject: z.string(),
+  predicate: z.string(),
+  object: z.string(),
+  confidence: z.number().min(0).max(1),
+  timestamp: z.string().nullable(),
+});
+export type OmpMemoryFact = z.infer<typeof OmpMemoryFactSchema>;
+
+export const listOmpMemory = defineRpc({
+  name: "paseo-omp.list-memory",
+  input: z.object({ cwd: CwdSchema }),
+  output: z.object({
+    bank: z.string().nullable(),
+    facts: z.array(OmpMemoryFactSchema),
+  }),
+});

package/shared/omp-config.ts

@@ -0,0 +1,81 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+
+// Mirrors the safe, non-secret subset of omp's on-disk ~/.omp/agent/config.yml. That file is an
+// internal, unversioned config format owned by the omp harness (source: omp's
+// settings-schema.ts), not a published API, so this is an explicit allowlist rather than a
+// passthrough: every section below has been checked against that schema's `credential: true`
+// markers and carries none. Sections the schema marks as credential-bearing (auth broker
+// tokens, mnemopi/hindsight embedding and LLM API keys, searxng basic-auth, blob-destination
+// headers) are deliberately absent and must stay that way. A field not listed here is never
+// read, rendered, or forwarded across the RPC boundary — server/omp-config.ts parses each
+// section independently and omits it entirely if it fails to match, rather than guessing or
+// widening the schema.
+
+export const OmpModelRolesSchema = z.record(z.string(), z.string());
+
+export const OmpFallbackChainsSchema = z.record(z.string(), z.array(z.string()));
+
+export const OmpThemeSectionSchema = z.object({
+  dark: z.string().optional(),
+  light: z.string().optional(),
+});
+
+export const OmpMemorySectionSchema = z.object({
+  backend: z.enum(["off", "local", "hindsight", "mnemopi", "sharpshooter"]).optional(),
+});
+
+export const OmpGithubCacheSectionSchema = z.object({
+  enabled: z.boolean().optional(),
+  softTtlSec: z.number().optional(),
+  hardTtlSec: z.number().optional(),
+});
+
+export const OmpGithubSectionSchema = z.object({
+  enabled: z.boolean().optional(),
+  cache: OmpGithubCacheSectionSchema.optional(),
+});
+
+export const OmpRetrySectionSchema = z.object({
+  enabled: z.boolean().optional(),
+  maxRetries: z.number().optional(),
+  baseDelayMs: z.number().optional(),
+  maxDelayMs: z.number().optional(),
+  waitForUsageReset: z.boolean().optional(),
+  modelFallback: z.boolean().optional(),
+  usageAwareFallback: z.boolean().optional(),
+  usageReservePct: z.number().optional(),
+  usageReservePolicy: z.enum(["confirm", "auto", "fail-closed"]).optional(),
+  fallbackRevertPolicy: z.enum(["cooldown-expiry", "never"]).optional(),
+  fallbackChains: OmpFallbackChainsSchema.optional(),
+});
+
+export const OmpDevSectionSchema = z.object({
+  autoqaConsent: z.enum(["unset", "granted", "denied"]).optional(),
+});
+
+export const OmpConfigSchema = z.object({
+  setupVersion: z.number().optional(),
+  symbolPreset: z.enum(["unicode", "nerd", "ascii"]).optional(),
+  defaultThinkingLevel: z.string().optional(),
+  theme: OmpThemeSectionSchema.optional(),
+  memory: OmpMemorySectionSchema.optional(),
+  github: OmpGithubSectionSchema.optional(),
+  disabledProviders: z.array(z.string()).optional(),
+  modelProviderOrder: z.array(z.string()).optional(),
+  modelRoles: OmpModelRolesSchema.optional(),
+  enabledModels: z.array(z.string()).optional(),
+  retry: OmpRetrySectionSchema.optional(),
+  dev: OmpDevSectionSchema.optional(),
+});
+export type OmpConfig = z.infer<typeof OmpConfigSchema>;
+
+export const listOmpConfig = defineRpc({
+  name: "paseo-omp.list-config",
+  input: z.object({}),
+  output: z.object({
+    path: z.string(),
+    available: z.boolean(),
+    config: OmpConfigSchema.nullable(),
+  }),
+});

package/shared/omp-plugins.ts

@@ -0,0 +1,223 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+
+export const OMP_PLUGIN_LIMIT = 256;
+export const OMP_PLUGIN_ARGUMENT_LIMIT = 512;
+
+const SAFE_NPM_PACKAGE = /^(?:@[a-z0-9][a-z0-9._~-]*\/)?[a-z0-9][a-z0-9._~-]*$/u;
+const SAFE_MARKETPLACE_ID =
+  /^[a-z0-9](?:[a-z0-9.-]{0,62}[a-z0-9])?@[a-z0-9](?:[a-z0-9.-]{0,62}[a-z0-9])?$/u;
+
+function utf8ByteLength(value: string): number {
+  let bytes = 0;
+  for (const character of value) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    bytes += codePoint <= 0x7f ? 1 : codePoint <= 0x7ff ? 2 : codePoint <= 0xffff ? 3 : 4;
+  }
+  return bytes;
+}
+
+function hasUnsafeArgumentCharacter(value: string): boolean {
+  for (const character of value) {
+    const code = character.codePointAt(0) ?? 0;
+    if (code <= 0x1f || code === 0x7f) return true;
+  }
+  return false;
+}
+
+export const OmpPluginNameSchema = z
+  .string()
+  .min(1)
+  .max(214)
+  .regex(SAFE_NPM_PACKAGE, "Expected an installed OMP package name");
+
+export const OmpMarketplacePluginIdSchema = z
+  .string()
+  .min(3)
+  .max(128)
+  .regex(SAFE_MARKETPLACE_ID, "Expected name@marketplace");
+
+export const OmpPluginTargetSchema = z.union([OmpPluginNameSchema, OmpMarketplacePluginIdSchema]);
+
+export const OmpPluginInstallSourceSchema = z
+  .string()
+  .min(1)
+  .max(OMP_PLUGIN_ARGUMENT_LIMIT)
+  .refine(
+    (value) => utf8ByteLength(value) <= OMP_PLUGIN_ARGUMENT_LIMIT,
+    "Plugin source is too large",
+  )
+  .refine((value) => value.trim() === value, "Plugin source must not have surrounding whitespace")
+  .refine(
+    (value) => !hasUnsafeArgumentCharacter(value),
+    "Plugin source contains an unsafe character",
+  )
+  .refine((value) => !value.startsWith("-"), "Plugin source must not be an option");
+
+export const OmpPluginScopeSchema = z.enum(["user", "project"]);
+export type OmpPluginScope = z.infer<typeof OmpPluginScopeSchema>;
+
+export const OmpInstalledPluginSchema = z
+  .object({
+    id: z.string().min(1).max(214),
+    packageName: OmpPluginNameSchema.optional(),
+    version: z.string().min(1).max(128).nullable(),
+    source: z.enum(["npm", "marketplace"]),
+    scope: OmpPluginScopeSchema.nullable(),
+    enabled: z.boolean(),
+    shadowed: z.boolean(),
+    path: z.string().min(1).max(4_096).nullable(),
+    description: z.string().max(1_024).nullable(),
+    enabledFeatures: z.array(z.string().min(1).max(128)).max(128),
+    availableFeatures: z.array(z.string().min(1).max(128)).max(128),
+    configurable: z.boolean(),
+    ambiguous: z.boolean(),
+    usesDefaultFeatures: z.boolean(),
+  })
+  .strict();
+export type OmpInstalledPlugin = z.infer<typeof OmpInstalledPluginSchema>;
+
+export const OmpPluginStateSchema = z
+  .object({
+    available: z.boolean(),
+    plugins: z.array(OmpInstalledPluginSchema).max(OMP_PLUGIN_LIMIT),
+    droppedCount: z.number().int().nonnegative(),
+    error: z.string().max(256).optional(),
+  })
+  .strict();
+export type OmpPluginState = z.infer<typeof OmpPluginStateSchema>;
+
+export const listOmpPlugins = defineRpc({
+  name: "paseo-omp.list-plugins",
+  input: z.object({}).strict(),
+  output: OmpPluginStateSchema,
+});
+
+export const OmpPluginConfigSettingSchema = z
+  .object({
+    key: z.string().min(1).max(128),
+    type: z.enum(["string", "number", "boolean", "enum"]),
+    description: z.string().max(512),
+    configured: z.boolean(),
+    secret: z.boolean(),
+    enumValues: z.array(z.string().min(1).max(256)).max(128),
+    minimum: z.number().finite().optional(),
+    maximum: z.number().finite().optional(),
+    step: z.number().finite().positive().optional(),
+  })
+  .strict();
+export type OmpPluginConfigSetting = z.infer<typeof OmpPluginConfigSettingSchema>;
+
+export const OmpPluginConfigStateSchema = z
+  .object({
+    available: z.boolean(),
+    plugin: OmpPluginNameSchema,
+    settings: z.array(OmpPluginConfigSettingSchema).max(OMP_PLUGIN_LIMIT),
+    droppedCount: z.number().int().nonnegative(),
+    error: z.string().max(256).optional(),
+  })
+  .strict();
+export type OmpPluginConfigState = z.infer<typeof OmpPluginConfigStateSchema>;
+
+export const inspectOmpPluginConfig = defineRpc({
+  name: "paseo-omp.inspect-plugin-config",
+  input: z.object({ plugin: OmpPluginNameSchema }).strict(),
+  output: OmpPluginConfigStateSchema,
+});
+
+export const OmpPluginConfigKeySchema = z
+  .string()
+  .min(1)
+  .max(128)
+  .refine((value) => value.trim() === value, "Setting key must not have surrounding whitespace")
+  .refine((value) => !hasUnsafeArgumentCharacter(value), "Setting key contains an unsafe character")
+  .refine((value) => !value.startsWith("-"), "Setting key must not be an option");
+
+export const OmpPluginConfigStringValueSchema = z
+  .string()
+  .min(1)
+  .max(4_096)
+  .refine((value) => utf8ByteLength(value) <= 4_096, "Setting value is too large")
+  .refine(
+    (value) => !hasUnsafeArgumentCharacter(value),
+    "Setting value contains an unsafe character",
+  )
+  .refine((value) => !value.startsWith("-"), "Setting value must not be an option");
+
+export const OmpPluginConfigMutationSchema = z.discriminatedUnion("action", [
+  z
+    .object({
+      action: z.literal("set"),
+      plugin: OmpPluginNameSchema,
+      key: OmpPluginConfigKeySchema,
+      value: z.union([OmpPluginConfigStringValueSchema, z.number().finite(), z.boolean()]),
+    })
+    .strict(),
+  z
+    .object({
+      action: z.literal("delete"),
+      plugin: OmpPluginNameSchema,
+      key: OmpPluginConfigKeySchema,
+    })
+    .strict(),
+]);
+export type OmpPluginConfigMutation = z.infer<typeof OmpPluginConfigMutationSchema>;
+
+export const mutateOmpPluginConfig = defineRpc({
+  name: "paseo-omp.mutate-plugin-config",
+  input: OmpPluginConfigMutationSchema,
+  output: z
+    .object({
+      ok: z.boolean(),
+      message: z.string().min(1).max(256),
+      config: OmpPluginConfigStateSchema,
+    })
+    .strict(),
+});
+
+const ScopedMutationShape = {
+  scope: z.literal("user").optional(),
+};
+
+export const OmpPluginMutationSchema = z.discriminatedUnion("action", [
+  z
+    .object({
+      action: z.literal("install"),
+      source: OmpPluginInstallSourceSchema,
+      ...ScopedMutationShape,
+    })
+    .strict(),
+  z
+    .object({ action: z.literal("enable"), plugin: OmpPluginTargetSchema, ...ScopedMutationShape })
+    .strict(),
+  z
+    .object({ action: z.literal("disable"), plugin: OmpPluginTargetSchema, ...ScopedMutationShape })
+    .strict(),
+  z
+    .object({
+      action: z.literal("uninstall"),
+      plugin: OmpPluginTargetSchema,
+      ...ScopedMutationShape,
+    })
+    .strict(),
+  z
+    .object({
+      action: z.literal("upgrade"),
+      plugin: OmpMarketplacePluginIdSchema,
+      ...ScopedMutationShape,
+    })
+    .strict(),
+]);
+export type OmpPluginMutation = z.infer<typeof OmpPluginMutationSchema>;
+
+export const mutateOmpPlugin = defineRpc({
+  name: "paseo-omp.mutate-plugin",
+  input: OmpPluginMutationSchema,
+  output: z
+    .object({
+      ok: z.boolean(),
+      message: z.string().min(1).max(256),
+      state: OmpPluginStateSchema,
+    })
+    .strict(),
+});

package/shared/omp-settings.ts

@@ -0,0 +1,207 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+
+export const OMP_SETTINGS_CATALOG_VERSION = 1;
+
+export const OmpSettingTypeSchema = z.enum([
+  "boolean",
+  "string",
+  "number",
+  "enum",
+  "array",
+  "record",
+]);
+export type OmpSettingType = z.infer<typeof OmpSettingTypeSchema>;
+export const OmpScalarValueSchema = z.union([z.boolean(), z.number(), z.string()]);
+export type OmpScalarValue = z.infer<typeof OmpScalarValueSchema>;
+
+export const OmpSettingSchema = z
+  .object({
+    path: z.string(),
+    type: OmpSettingTypeSchema,
+    description: z.string(),
+    value: z.unknown().optional(),
+    redacted: z.boolean().optional(),
+    configured: z.boolean().optional(),
+  })
+  .strict();
+export type OmpSetting = z.infer<typeof OmpSettingSchema>;
+
+export const OMP_SETTING_CATEGORIES = [
+  "appearance",
+  "model",
+  "interaction",
+  "context",
+  "memory",
+  "files",
+  "shell",
+  "tools",
+  "tasks",
+  "providers",
+  "general",
+] as const;
+export type OmpSettingCategory = (typeof OMP_SETTING_CATEGORIES)[number];
+
+const CATEGORY_PREFIXES: Readonly<Record<OmpSettingCategory, readonly string[]>> = {
+  appearance: [
+    "theme.",
+    "symbolPreset",
+    "colorBlindMode",
+    "composer.",
+    "statusLine.",
+    "terminal.",
+    "tui.",
+    "display.",
+    "showHardwareCursor",
+    "images.",
+  ],
+  model: [
+    "modelRoles",
+    "modelTags",
+    "modelRoleStorage",
+    "cycleOrder",
+    "enabledModels",
+    "defaultThinkingLevel",
+    "thinkingBudgets.",
+    "hideThinkingBlock",
+    "proseOnlyThinking",
+    "omitThinking",
+    "externalThinking",
+    "model.",
+    "inlineToolDescriptors",
+    "includeModelInPrompt",
+    "includeWorkspaceTree",
+    "personality",
+    "temperature",
+    "topP",
+    "topK",
+    "minP",
+    "presencePenalty",
+    "repetitionPenalty",
+    "textVerbosity",
+    "retry.",
+    "advisor.",
+    "prewalk.",
+    "tier.",
+  ],
+  interaction: [
+    "autoResume",
+    "power.",
+    "steeringMode",
+    "ask.",
+    "stt.",
+    "speech.",
+    "live.",
+    "collab.",
+    "magicKeywords",
+    "git.",
+  ],
+  context: ["compaction.", "context.", "contextPromotion.", "ttsr.", "recap.", "branchSummary."],
+  memory: ["memory.", "memories.", "mnemopi.", "hindsight.", "sharpshooter."],
+  files: ["edit.", "read.", "files.", "file.", "lsp.", "tree"],
+  shell: ["bash.", "eval.", "shell", "shellMinimizer."],
+  tools: [
+    "tools.",
+    "todo.",
+    "glob.",
+    "grep.",
+    "astGrep.",
+    "astEdit.",
+    "debug.",
+    "launch.",
+    "fetch.",
+    "vault.",
+    "github.",
+    "web_search.",
+    "browser.",
+    "computer.",
+    "checkpoint.",
+    "async.",
+    "irc.",
+    "mcp.",
+    "secrets.",
+    "extensionHandlers.",
+    "dev.",
+  ],
+  tasks: [
+    "plan.",
+    "goal.",
+    "task.",
+    "tasks.",
+    "worktree.",
+    "skills.",
+    "commands.",
+    "extensions",
+    "disabledExtensions",
+  ],
+  providers: [
+    "providers.",
+    "provider.",
+    "enabledProviders",
+    "disabledProviders",
+    "modelProviderOrder",
+    "exa.",
+    "searxng.",
+    "codexResets.",
+  ],
+  general: [],
+};
+
+export function categorizeOmpSetting(path: string): OmpSettingCategory {
+  for (const category of OMP_SETTING_CATEGORIES) {
+    if (CATEGORY_PREFIXES[category].some((prefix) => path === prefix || path.startsWith(prefix))) {
+      return category;
+    }
+  }
+  return "general";
+}
+
+export function formatOmpSettingLabel(path: string): string {
+  const leaf = path.split(".").at(-1) ?? path;
+  const words = leaf
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .replace(/[_-]+/g, " ")
+    .trim();
+  return words ? `${words[0]?.toUpperCase() ?? ""}${words.slice(1)}` : path;
+}
+
+export const listOmpSettings = defineRpc({
+  name: "paseo-omp.list-settings",
+  input: z.object({}),
+  output: z.object({
+    catalogVersion: z.literal(OMP_SETTINGS_CATALOG_VERSION),
+    revision: z.string().optional(),
+    path: z.string().optional(),
+    available: z.boolean(),
+    droppedCount: z.number().int().nonnegative(),
+    settings: z.array(OmpSettingSchema),
+    error: z.string().optional(),
+  }),
+});
+
+const OmpSettingChangeSchema = z.discriminatedUnion("operation", [
+  z.object({ operation: z.literal("set"), path: z.string().min(1), value: OmpScalarValueSchema }),
+  z.object({ operation: z.literal("reset"), path: z.string().min(1) }),
+]);
+
+export const updateOmpSettings = defineRpc({
+  name: "paseo-omp.update-settings",
+  input: z.object({
+    revision: z.string(),
+    changes: z.array(OmpSettingChangeSchema).min(1).max(100),
+  }),
+  output: z.object({
+    conflict: z.boolean(),
+    appliedPaths: z.array(z.string()),
+    failed: z.object({ path: z.string(), message: z.string() }).optional(),
+    catalog: z.object({
+      catalogVersion: z.literal(OMP_SETTINGS_CATALOG_VERSION),
+      available: z.boolean(),
+      revision: z.string().optional(),
+      path: z.string().optional(),
+      droppedCount: z.number().int().nonnegative(),
+      settings: z.array(OmpSettingSchema),
+      error: z.string().optional(),
+    }),
+  }),
+});