@desplega.ai/agent-swarm 2.7.6 → 2.7.7

package/src/be/db-client.ts

@@ -177,6 +177,11 @@ export type BusyRetryOptions = {
    * Defaults to `DEFAULT_FINAL_ATTEMPT_SPIN_MS`.
    */
   finalAttemptSpinMs?: number;
+  /**
+   * Longest gap between spinning probes while an external holder is
+   * detected (see `BusyGate`). Defaults to `DEFAULT_MAX_GATE_MS`.
+   */
+  maxGateMs?: number;
 };
 
 /**
@@ -247,8 +252,81 @@ function isSqliteBusy(err: unknown): boolean {
   return typeof code === "string" && code.startsWith("SQLITE_BUSY");
 }
 
+/** Ceiling on the gap between spinning probes while a holder is detected. */
+const DEFAULT_MAX_GATE_MS = 1_000;
+/** A quiet stretch this long ends a BUSY episode even without a proven write. */
+const GATE_DECAY_MS = 5_000;
+
+/**
+ * Process-wide memory of a cross-process write-lock holder.
+ *
+ * Every retrying writer used to spin `attemptSpinMs` (100ms, or 250ms for the
+ * last attempt) SYNCHRONOUSLY inside the FIFO lock on every attempt. With N
+ * writers queued behind a holder that lasts minutes, one round of attempts
+ * costs N x 100ms of blocked event loop, and each attempt waits for that
+ * whole round before its own turn. A 5-minute Litestream snapshot turned
+ * the nominal 11s retry budget into 90-105s request hangs, 3s /health and
+ * 3s page loads, although only writes were contending.
+ *
+ * The gate records a BUSY seen by a spinning probe. For the next interval
+ * (doubling from `attemptSpinMs` up to `maxGateMs`) every attempt runs with
+ * a ZERO busy_timeout: it still tries, so recovery is immediate, but it
+ * fails in microseconds instead of blocking the loop, and the async backoff
+ * sleeps do the waiting. Once the interval lapses, the next attempt is the
+ * lone spinning probe again.
+ */
+class BusyGate {
+  private openUntil = 0;
+  private streak = 0;
+  private lastBusyAt = 0;
+  private episodeStartedAt = 0;
+  private episodeProbes = 0;
+
+  constructor(
+    private readonly baseMs: number,
+    private readonly maxMs: number,
+  ) {}
+
+  /** True while attempts must not spin. */
+  isOpen(now = performance.now()): boolean {
+    return now < this.openUntil;
+  }
+
+  /** A spinning probe hit BUSY: a holder exists. Open the gate and widen it. */
+  recordBusy(now = performance.now()): void {
+    if (this.streak > 0 && now - this.lastBusyAt > GATE_DECAY_MS) this.endEpisode(now, "decayed");
+    if (this.streak === 0) {
+      this.episodeStartedAt = now;
+      this.episodeProbes = 0;
+      console.warn(
+        "[db-client] SQLITE_BUSY: another process holds the write lock; spinning at most one probe per gate interval until it releases",
+      );
+    }
+    this.streak += 1;
+    this.episodeProbes += 1;
+    this.lastBusyAt = now;
+    const interval = Math.min(this.maxMs, this.baseMs * 2 ** Math.min(this.streak - 1, 20));
+    this.openUntil = now + interval;
+  }
+
+  /** A write got through after BUSY: the holder is gone. */
+  recordRecovered(now = performance.now()): void {
+    if (this.streak === 0) return;
+    this.endEpisode(now, "released");
+  }
+
+  private endEpisode(now: number, how: "released" | "decayed"): void {
+    console.warn(
+      `[db-client] write lock ${how} after ${Math.round(now - this.episodeStartedAt)}ms (${this.episodeProbes} spinning probes)`,
+    );
+    this.streak = 0;
+    this.openUntil = 0;
+  }
+}
+
 class BunSqliteClient implements DbClient {
   private readonly lock = new FifoLock();
+  private readonly gate: BusyGate;
   private savepointSeq = 0;
   /** Lazily captured ambient busy_timeout, restored after each short-spin attempt. */
   private restoreBusyTimeoutMs: number | null = null;
@@ -256,7 +334,12 @@ class BunSqliteClient implements DbClient {
   constructor(
     private readonly getDatabase: () => Database,
     private readonly busyRetry: BusyRetryOptions = DEFAULT_BUSY_RETRY,
-  ) {}
+  ) {
+    this.gate = new BusyGate(
+      busyRetry.attemptSpinMs,
+      Math.max(busyRetry.attemptSpinMs, busyRetry.maxGateMs ?? DEFAULT_MAX_GATE_MS),
+    );
+  }
 
   query<T>(sql: string, params: DbParam[] = []): Promise<T[]> {
     return this.execute(sql, (db) => db.query<T, DbParam[]>(sql).all(...params));
@@ -352,6 +435,7 @@ class BunSqliteClient implements DbClient {
           // not. The short spin keeps the driver's synchronous busy wait off
           // the event loop; the real waiting is the caller's async backoff.
           this.shortSpin(db, () => db.run("BEGIN IMMEDIATE"), finalAttempt);
+          this.gate.recordRecovered();
         } catch (err) {
           if (isSqliteBusy(err)) return { ok: false, busyBegin: err };
           throw err;
@@ -366,7 +450,7 @@ class BunSqliteClient implements DbClient {
         // is exact. The open transaction pins the connection, so these
         // retries hold the FIFO lock and their sleeps block queued work;
         // WAL-mode COMMIT BUSY is rare enough for that to be acceptable.
-        await this.retryHoldingLock(() => this.shortSpin(db, () => db.run("COMMIT")));
+        await this.retryHoldingLock(() => this.shortSpin(db, () => db.run("COMMIT"), false, false));
       }
       for (const hook of ctx.afterCommit) this.scheduleHook(hook);
       return { ok: true, value: result };
@@ -478,6 +562,7 @@ class BunSqliteClient implements DbClient {
       return timed(() => op(db));
     }
     let sleptMs = 0;
+    let sawBusy = false;
     for (let attemptIndex = 0; ; attemptIndex++) {
       const next = this.busyRetry.backoffMs[attemptIndex];
       const canRetryAfter = next !== undefined && sleptMs + next <= this.busyRetry.maxWaitMs;
@@ -488,9 +573,14 @@ class BunSqliteClient implements DbClient {
         // exact. The final attempt spins `finalAttemptSpinMs` (see
         // transaction()).
         const db = this.getDatabase();
-        return timed(() => this.shortSpin(db, () => op(db), !canRetryAfter), canRetryAfter);
+        const result = timed(() => this.shortSpin(db, () => op(db), !canRetryAfter), canRetryAfter);
+        // A statement that was BUSY earlier in this call and now landed is a
+        // write that got through: the external holder is gone.
+        if (sawBusy) this.gate.recordRecovered();
+        return result;
       } catch (err) {
         if (!isSqliteBusy(err) || !canRetryAfter || next === undefined) throw err;
+        sawBusy = true;
         backoff = next;
         sleptMs += next;
       } finally {
@@ -509,17 +599,27 @@ class BunSqliteClient implements DbClient {
    * lock is held, so the set/attempt/restore sequence cannot interleave with
    * other client work.
    */
-  private shortSpin<T>(db: Database, attempt: () => T, finalAttempt = false): T {
+  private shortSpin<T>(db: Database, attempt: () => T, finalAttempt = false, gateable = true): T {
     if (this.restoreBusyTimeoutMs === null) {
       const row = db.query<{ timeout: number }, []>("PRAGMA busy_timeout").get();
       this.restoreBusyTimeoutMs = row?.timeout ?? 5000;
     }
-    const spinMs = finalAttempt
-      ? (this.busyRetry.finalAttemptSpinMs ?? DEFAULT_FINAL_ATTEMPT_SPIN_MS)
-      : this.busyRetry.attemptSpinMs;
+    // While a holder is known (BusyGate) the attempt runs without a spin: it
+    // still tries, so a released lock is taken at once, but a held one costs
+    // microseconds of event loop instead of a full spin per queued writer.
+    // Only the spinning probe that follows a lapsed gate reports BUSY back.
+    const gated = gateable && this.gate.isOpen();
+    const spinMs = gated
+      ? 0
+      : finalAttempt
+        ? (this.busyRetry.finalAttemptSpinMs ?? DEFAULT_FINAL_ATTEMPT_SPIN_MS)
+        : this.busyRetry.attemptSpinMs;
     db.exec(`PRAGMA busy_timeout = ${spinMs}`);
     try {
       return attempt();
+    } catch (err) {
+      if (gateable && !gated && isSqliteBusy(err)) this.gate.recordBusy();
+      throw err;
     } finally {
       db.exec(`PRAGMA busy_timeout = ${this.restoreBusyTimeoutMs}`);
     }

package/src/be/db.ts

@@ -198,6 +198,7 @@ import {
 } from "./db/context-versions";
 import { clearAgentModelProfileOnOverrideChange } from "./db/model-profiles";
 import { pageSearchSql } from "./db/page-search";
+import { parsePageThemeTokens } from "./db/page-theme-tokens";
 import { getDb, getDbClient } from "./db/runtime";
 import {
   assertAssetKeyMovesAllowed,
@@ -413,6 +414,7 @@ export {
   recordTaskProviderIfUnset,
   resetOrphanedInProgressTasksForAgent,
   resumeTask,
+  setTaskTitleIfUnset,
   settleSupersededTaskDependents,
   startTask,
   supersedeTask,
@@ -8619,6 +8621,9 @@ type PageRow = {
   createdAt: string;
   updatedAt: string;
   view_count: number;
+  theme: string | null;
+  theme_tokens: string | null;
+  design_version: number;
 };
 
 function rowToPage(row: PageRow): Page {
@@ -8636,6 +8641,9 @@ function rowToPage(row: PageRow): Page {
     needsCredentials: row.needsCredentials
       ? (JSON.parse(row.needsCredentials) as string[])
       : undefined,
+    theme: row.theme ?? null,
+    themeTokens: parsePageThemeTokens(row.theme_tokens),
+    designVersion: typeof row.design_version === "number" ? row.design_version : 1,
     viewCount: typeof row.view_count === "number" ? row.view_count : 0,
     createdAt: normalizeDateRequired(row.createdAt),
     updatedAt: normalizeDateRequired(row.updatedAt),
@@ -8653,13 +8661,17 @@ export async function createPage(data: {
   passwordHash?: string;
   body: string;
   needsCredentials?: string[];
+  theme?: string | null;
+  themeTokens?: Page["themeTokens"];
+  /** Defaults to 2 (the swarm design system). Rows inserted outside this function default to 1. */
+  designVersion?: number;
 }): Promise<Page> {
   // Match the historical SQL default ID shape while making the value
   // available before insert so the default namespace can include it.
   const id = crypto.randomUUID().replace(/-/g, "");
   const row = await getDbClient().get<PageRow>(
-    `INSERT INTO pages (id, "key", agentId, slug, title, description, contentType, authMode, passwordHash, body, needsCredentials)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
+    `INSERT INTO pages (id, "key", agentId, slug, title, description, contentType, authMode, passwordHash, body, needsCredentials, theme, theme_tokens, design_version)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
     [
       id,
       normalizeAssetKey(data.key ?? defaultAssetKey("page", id)),
@@ -8672,6 +8684,9 @@ export async function createPage(data: {
       data.passwordHash ?? null,
       data.body,
       data.needsCredentials ? JSON.stringify(data.needsCredentials) : null,
+      data.theme ?? null,
+      data.themeTokens ? JSON.stringify(data.themeTokens) : null,
+      data.designVersion ?? 2,
     ],
   );
   if (!row) throw new Error("Failed to create page");
@@ -8858,6 +8873,11 @@ export async function updatePage(
     body?: string;
     needsCredentials?: string[] | null;
     slug?: string;
+    /** undefined keeps the stored value, null clears it. */
+    theme?: string | null;
+    /** undefined keeps the stored value, null clears it. */
+    themeTokens?: Page["themeTokens"];
+    designVersion?: number;
   },
 ): Promise<Page | null> {
   const updates: string[] = [];
@@ -8898,6 +8918,18 @@ export async function updatePage(
     updates.push("slug = ?");
     params.push(data.slug);
   }
+  if (data.theme !== undefined) {
+    updates.push("theme = ?");
+    params.push(data.theme);
+  }
+  if (data.themeTokens !== undefined) {
+    updates.push("theme_tokens = ?");
+    params.push(data.themeTokens ? JSON.stringify(data.themeTokens) : null);
+  }
+  if (data.designVersion !== undefined) {
+    updates.push("design_version = ?");
+    params.push(data.designVersion);
+  }
   if (updates.length === 0) return getPage(id);
   updates.push("updatedAt = ?");
   params.push(new Date().toISOString());

package/src/be/migrations/269_pages_design_system.sql

@@ -0,0 +1,23 @@
+-- Pages design system v2: three columns that say how an HTML page is styled.
+--
+-- design_version  Which design system serves the page. 1 is the original
+--                 look (Tailwind v3 Play CDN, `--swarm-*` hex tokens) and stays
+--                 frozen. 2 is the swarm design system (theme tokens, `swarm-*`
+--                 primitives, Tailwind v4). The DEFAULT makes every existing row
+--                 read 1, so old pages keep their look. New pages get 2 from
+--                 createPage(), which inserts the value explicitly.
+-- theme           Preset id from the dashboard theme registry (for example
+--                 `paper`). NULL pins nothing: the page follows the viewer's
+--                 theme, then falls back to `hive`. Design version 2 only.
+-- theme_tokens    JSON `{"light": {...}, "dark": {...}}` of per-page overrides,
+--                 keyed by page token names (`--color-primary`, `--radius-lg`).
+--                 Stored normalized by importThemeTokens() (src/themes/import.ts).
+--                 NULL means no overrides. Design version 2 only.
+--
+-- Both theme columns are NULL for every existing row. Neither one has a CHECK:
+-- the preset ids live in code (src/themes/presets.ts), so the write paths
+-- validate them, and a stale id read from the table is ignored at render time.
+
+ALTER TABLE pages ADD COLUMN theme TEXT;
+ALTER TABLE pages ADD COLUMN theme_tokens TEXT;
+ALTER TABLE pages ADD COLUMN design_version INTEGER NOT NULL DEFAULT 1;

package/src/be/seed/schedules-seeder.ts

@@ -29,12 +29,6 @@ import dailySwarmUpdateCheckConfig from "../../../templates/schedules/daily-swar
 import dailySwarmUpdateCheckContent from "../../../templates/schedules/daily-swarm-update-check/content.md" with {
   type: "text",
 };
-import dailyWorkflowHealthAuditConfig from "../../../templates/schedules/daily-workflow-health-audit/config.json" with {
-  type: "text",
-};
-import dailyWorkflowHealthAuditContent from "../../../templates/schedules/daily-workflow-health-audit/content.md" with {
-  type: "text",
-};
 import dreamingDailyConfig from "../../../templates/schedules/dreaming-daily/config.json" with {
   type: "text",
 };
@@ -153,10 +147,6 @@ const BUILT_IN_SCHEDULE_SOURCES: readonly ScheduleTemplateSource[] = [
     config: asText(dailySwarmUpdateCheckConfig),
     content: asText(dailySwarmUpdateCheckContent),
   },
-  {
-    config: asText(dailyWorkflowHealthAuditConfig),
-    content: asText(dailyWorkflowHealthAuditContent),
-  },
   { config: asText(dreamingDailyConfig), content: asText(dreamingDailyContent) },
   { config: asText(gtmWeeklyReviewConfig), content: asText(gtmWeeklyReviewContent) },
   {

package/src/be/seed-scripts/catalog/catalog-report.inline.ts

@@ -745,6 +745,8 @@ export async function publishCatalogReportPage(report: CatalogReport, ctx: any):
     description: report.description,
     contentType: "text/html",
     authMode: "authed",
+    // The report ships its own palette, written for the v1 page head.
+    designVersion: 1,
     body: renderCatalogReportPage(report),
   });
   const payload = response?.data ?? response;

package/src/be/seed-scripts/catalog/catalog-report.ts

@@ -745,6 +745,8 @@ export async function publishCatalogReportPage(report: CatalogReport, ctx: any):
     description: report.description,
     contentType: "text/html",
     authMode: "authed",
+    // The report ships its own palette, written for the v1 page head.
+    designVersion: 1,
     body: renderCatalogReportPage(report),
   });
   const payload = response?.data ?? response;

package/src/be/seed-scripts/catalog/memory-eval.ts

@@ -522,6 +522,8 @@ export default async function memoryEval(args: any, ctx: any) {
         description: `3-axis memory quality dashboard: carry-forward ${report.axis1.score}%, preferences usefulness ${report.axis2.avgUsefulness}, freshness ${report.axis3.freshScore}%. ${history.length} data points.`,
         contentType: "text/html",
         authMode: "authed",
+        // The dashboard ships its own palette, written for the v1 page head.
+        designVersion: 1,
         body: html,
       });
       const payload = response?.data ?? response;

package/src/be/seed-scripts/catalog/swarm-update-check.ts

@@ -0,0 +1,150 @@
+import { z } from "zod";
+
+export const argsSchema = z.object({
+  dryRun: z
+    .boolean()
+    .optional()
+    .describe("Compute the verdict but do not notify the lead when an update is available"),
+});
+
+const RELEASES_URL = "https://api.github.com/repos/desplega-ai/agent-swarm/releases/latest";
+
+/** Parse `major.minor.patch` (a leading `v` and a pre-release/build suffix are ignored). */
+export function parseVersion(value: unknown): [number, number, number] | null {
+  if (typeof value !== "string") return null;
+  const m = value
+    .trim()
+    .replace(/^v/i, "")
+    .match(/^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/);
+  if (!m) return null;
+  return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+
+/** Numeric compare of two parsed versions: negative, zero or positive. Never a string compare. */
+export function compareVersions(a: [number, number, number], b: [number, number, number]): number {
+  for (let i = 0; i < 3; i++) {
+    const diff = (a[i] as number) - (b[i] as number);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+
+function errorText(error: unknown): string {
+  return String((error as any)?.message ?? error).slice(0, 200);
+}
+
+/** The version the API server is running, from its own unauthenticated `/health` route. */
+async function runningVersion(ctx: any): Promise<string | null> {
+  try {
+    const base = ctx.stdlib.Redacted.value(ctx.swarm.config.mcpBaseUrl).replace(/\/+$/, "");
+    const res: any = await ctx.stdlib.fetch(base + "/health", { retries: 1, timeoutMs: 10_000 });
+    if (!res.ok) return null;
+    const body: any = await res.json();
+    return typeof body?.version === "string" && body.version.trim() ? body.version.trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+async function resolveLeadId(ctx: any): Promise<string | null> {
+  const res: any = await ctx.swarm.swarm_get({});
+  const data = res?.data ?? res;
+  const agents: any[] = Array.isArray(data?.agents) ? data.agents : Array.isArray(data) ? data : [];
+  const lead = agents.find((agent) => agent?.isLead === true || agent?.isLead === 1);
+  return typeof lead?.id === "string" ? lead.id : null;
+}
+
+/**
+ * Compare the running agent-swarm version with the latest published GitHub
+ * release and, only when a newer release exists, hand the lead one task to
+ * tell the operator through its admin delivery channel.
+ */
+export default async function swarmUpdateCheck(args: any, ctx: any) {
+  const parsed = argsSchema.safeParse(args ?? {});
+  if (!parsed.success) return { error: "invalid args: " + parsed.error.message };
+  const dryRun = parsed.data.dryRun === true;
+
+  const running = await runningVersion(ctx);
+  const runningParsed = parseVersion(running);
+  if (!running || !runningParsed) {
+    // Unknown is not "up to date": say so and stop, never guess a version.
+    return {
+      checked: false,
+      status: "unknown",
+      running,
+      message: `Unable to determine running version: ${running ? `unparseable "${running}"` : "not reported by /health"}.`,
+    };
+  }
+
+  let release: any;
+  try {
+    // One attempt: a failed GitHub call is reported, never retried in a loop.
+    const res: any = await ctx.stdlib.fetch(RELEASES_URL, {
+      retries: 1,
+      timeoutMs: 15_000,
+      headers: { Accept: "application/vnd.github+json", "User-Agent": "agent-swarm-update-check" },
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    release = await res.json();
+  } catch (error) {
+    return {
+      checked: false,
+      status: "github-unreachable",
+      running,
+      message: `Could not reach GitHub releases API: ${errorText(error)}`,
+    };
+  }
+
+  const latest = typeof release?.tag_name === "string" ? release.tag_name.replace(/^v/i, "") : null;
+  const latestParsed = parseVersion(latest);
+  if (!latest || !latestParsed) {
+    return {
+      checked: false,
+      status: "github-unreachable",
+      running,
+      message: `Could not read a version from the latest release tag: ${JSON.stringify(release?.tag_name ?? null)}.`,
+    };
+  }
+  const releaseUrl =
+    typeof release?.html_url === "string"
+      ? release.html_url
+      : `https://github.com/desplega-ai/agent-swarm/releases/tag/v${latest}`;
+
+  if (compareVersions(latestParsed, runningParsed) <= 0) {
+    return {
+      checked: true,
+      status: "up-to-date",
+      running,
+      latest,
+      message: `Up to date: running ${running}, latest published ${latest}.`,
+    };
+  }
+
+  const message = `Update available: running ${running}, latest ${latest} (${releaseUrl})`;
+  if (dryRun) {
+    return { checked: true, status: "update-available", running, latest, releaseUrl, notified: false, message };
+  }
+
+  const leadId = await resolveLeadId(ctx);
+  // A detected update that reaches nobody is a failed run, not a quiet success.
+  if (!leadId) throw new Error(`${message}, but the swarm has no lead to notify.`);
+  const sent: any = await ctx.swarm.task_send({
+    agentId: leadId,
+    routingReason: "skill",
+    routingNote: "Lead owns the operator's admin delivery channel for release notices.",
+    tags: ["swarm-update-check"],
+    task: [
+      `A newer agent-swarm release is published: running ${running}, latest ${latest}.`,
+      `Release: ${releaseUrl}`,
+      "",
+      "Post one short message to your configured admin delivery channel (the in-app fallback if none is configured) naming the running version, the new version and the release URL. Then complete with that message as the output.",
+      "Do not attempt the upgrade yourself: this notice only detects and reports.",
+    ].join("\n"),
+  });
+  const taskId = sent?.data?.task?.id ?? null;
+  if (sent?.success === false || sent?.data?.success === false || !taskId) {
+    const reason = sent?.data?.message ?? sent?.data?.error ?? `status ${sent?.status}`;
+    throw new Error(`${message}, but notifying the lead failed: ${errorText(reason)}`);
+  }
+  return { checked: true, status: "update-available", running, latest, releaseUrl, notified: true, leadTaskId: taskId, message };
+}

package/src/be/seed-scripts/index.ts

@@ -60,6 +60,7 @@ import starHistoryRefreshSrc from "./catalog/star-history-refresh.ts" with { typ
 // @ts-expect-error Bun text imports synthesize a default string for this helper.
 import starHistoryRendererSrc from "./catalog/star-history-renderer.ts" with { type: "text" };
 import swarmOverviewSrc from "./catalog/swarm-overview.ts" with { type: "text" };
+import swarmUpdateCheckSrc from "./catalog/swarm-update-check.ts" with { type: "text" };
 import taskContextGatheringSrc from "./catalog/task-context-gathering.ts" with { type: "text" };
 import taskFailureAuditSrc from "./catalog/task-failure-audit.ts" with { type: "text" };
 import textDiffSrc from "./catalog/text-diff.ts" with { type: "text" };
@@ -217,6 +218,14 @@ export const SEED_SCRIPTS: SeedScript[] = [
       "Task onboarding: one call instead of task_get plus multiple memory_search calls. Pass the task description split into 2-4 natural-language queries.",
     source: asText(taskContextGatheringSrc),
   },
+  {
+    name: "swarm-update-check",
+    description:
+      "Compare the running agent-swarm version (API /health) with the latest GitHub release of desplega-ai/agent-swarm as numeric major.minor.patch, and hand the lead one notify task only when a newer release exists.",
+    intent:
+      "Daily zero-config upgrade watchdog behind the daily-swarm-update-check schedule; dryRun reports the verdict without notifying.",
+    source: asText(swarmUpdateCheckSrc),
+  },
   {
     name: "schedule-health",
     description: