docks-kit 0.17.1 → 0.17.2

package/cli/src/engine-native/ompSync.ts

@@ -5,437 +5,93 @@
  * PI_CODING_AGENT_DIR, and XDG roots each move them.
  * Resolution stays within the environment and filesystem probes so no omp
  * subcommand runs under ctx.dryRun.
+ *
+ * Split: file deploy lives in `ompFileDeploy.ts`, the marketplace pass in
+ * `ompMarketplace.ts`, and the plugin pass in `ompPlugins.ts`. This module
+ * keeps the orchestration plus the summary surface.
  */
-import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs"
-import { basename, isAbsolute, resolve } from "node:path"
+import { isAbsolute, resolve } from "node:path";
 
-import { payloadDisplayPath, payloadText, type PayloadPath } from "../payload"
-import { bunBootstrap } from "./bun"
-import { p, spawnProcess, type AsyncProcessResult } from "./exec"
-import { recordFailure } from "./failures"
-import type { Ctx } from "./index"
-import { isObject, parseJson } from "./jq"
-import { ompPaths } from "./ompPaths"
-import { mergeOmpConfig, mergeOmpModels } from "./ompYaml"
-import { field } from "./toolchain"
-
-const MARKETPLACE_NAME = "docks"
-const MARKETPLACE_SOURCE = "https://github.com/DocksDocks/docks.git"
-const MARKETPLACE_PLUGIN_IDS = ["docks@docks", "plan-lifecycle@docks"] as const
-type OmpTextPayloadPath = Extract<PayloadPath, `SoT/.omp/${string}`>
+import { bunBootstrap } from "./bun";
+import { p } from "./exec";
+import type { Ctx } from "./index";
+import { ompPaths } from "./ompPaths";
+import { mergeOmpConfig, mergeOmpModels } from "./ompYaml";
+import { ensureDirectory, syncMergedYaml, syncWholeFile } from "./ompFileDeploy";
+import { syncMarketplace } from "./ompMarketplace";
+import { syncPlugins } from "./ompPlugins";
 
 export interface OmpState {
-  readonly pluginsInstalled: number
+  readonly pluginsInstalled: number;
 }
 
 export async function ompSync(ctx: Ctx): Promise<OmpState> {
-  await bunBootstrap(ctx, ctx.services)
-
-  const paths = ompPaths({ home: ctx.home, env: process.env, platform: ctx.services.platform.raw() })
-  const agentDir = paths.agentDir
-  if (!ctx.dryRun) ensureDirectory(agentDir)
+  await bunBootstrap(ctx, ctx.services);
 
-  syncWholeFile(ctx, "SoT/.omp/AGENTS.md", p(agentDir, "AGENTS.md"), "omp AGENTS.md already in sync", "omp AGENTS.md synced")
-  syncWholeFile(ctx, "SoT/.omp/mcp.json", p(agentDir, "mcp.json"), "omp mcp.json already in sync", "omp mcp.json synced")
-  syncMergedYaml(ctx, "SoT/.omp/config.yml", p(agentDir, "config.yml"), mergeOmpConfig)
-  syncMergedYaml(ctx, "SoT/.omp/models.yml", p(agentDir, "models.yml"), mergeOmpModels)
+  const paths = ompPaths({
+    home: ctx.home,
+    env: process.env,
+    platform: ctx.services.platform.raw(),
+  });
+  const agentDir = paths.agentDir;
+  if (!ctx.dryRun) ensureDirectory(agentDir);
 
-  const intercomRootSetting = process.env["PI_CODING_AGENT_DIR"]
-  const intercomRoot = intercomRootSetting !== undefined && intercomRootSetting !== ""
-    ? isAbsolute(intercomRootSetting)
-      ? intercomRootSetting
-      : resolve(process.cwd(), intercomRootSetting)
-    : p(ctx.home, ".pi", "agent")
-  const intercomDir = p(intercomRoot, "intercom")
-  if (!ctx.dryRun) ensureDirectory(intercomDir)
+  syncWholeFile(
+    ctx,
+    "SoT/.omp/AGENTS.md",
+    p(agentDir, "AGENTS.md"),
+    "omp AGENTS.md already in sync",
+    "omp AGENTS.md synced",
+  );
+  syncWholeFile(
+    ctx,
+    "SoT/.omp/mcp.json",
+    p(agentDir, "mcp.json"),
+    "omp mcp.json already in sync",
+    "omp mcp.json synced",
+  );
+  syncMergedYaml(ctx, "SoT/.omp/config.yml", p(agentDir, "config.yml"), mergeOmpConfig);
+  syncMergedYaml(ctx, "SoT/.omp/models.yml", p(agentDir, "models.yml"), mergeOmpModels);
+
+  const intercomRootSetting = process.env["PI_CODING_AGENT_DIR"];
+  const intercomRoot =
+    intercomRootSetting !== undefined && intercomRootSetting !== ""
+      ? isAbsolute(intercomRootSetting)
+        ? intercomRootSetting
+        : resolve(process.cwd(), intercomRootSetting)
+      : p(ctx.home, ".pi", "agent");
+  const intercomDir = p(intercomRoot, "intercom");
+  if (!ctx.dryRun) ensureDirectory(intercomDir);
   syncWholeFile(
     ctx,
     "SoT/.omp/intercom.json",
     p(intercomDir, "config.json"),
     "omp intercom configuration already in sync",
-    "omp intercom configuration synced"
-  )
-
-  const legacyRegistryFile = paths.dataRoot === paths.configRoot
-    ? undefined
-    : p(paths.configRoot, "marketplaces.json")
-  await syncMarketplace(ctx, p(paths.dataRoot, "marketplaces.json"), legacyRegistryFile)
-  const pluginsInstalled = await syncPlugins(ctx)
-  return { pluginsInstalled }
-}
-
-// ------------------------------------------------------------ file modes ----
-
-/**
- * `mkdirSync` and `writeFileSync` apply their `mode` only when they create the
- * path, so an existing world-readable directory or file would keep its mode.
- * The explicit chmod reproduces `install -d -m 0700` / `install -m 0600`.
- */
-function ensureDirectory(directory: string): void {
-  mkdirSync(directory, { recursive: true, mode: 0o700 })
-  chmodSync(directory, 0o700)
-}
-
-function writePrivateFile(target: string, content: string): void {
-  writeFileSync(target, content, { mode: 0o600 })
-  chmodSync(target, 0o600)
-}
-
-function backupPrivateFile(target: string): void {
-  copyFileSync(target, `${target}.bak`)
-  chmodSync(`${target}.bak`, 0o600)
-}
-
-// --------------------------------------------------------------- config ----
-
-function syncWholeFile(
-  ctx: Ctx,
-  sourcePath: OmpTextPayloadPath,
-  target: string,
-  alreadyMessage: string,
-  syncedMessage: string
-): void {
-  const { change, echo, verbose } = ctx.services.logger
-  const source = payloadDisplayPath(sourcePath)
-  const content = payloadText(sourcePath)
-
-  if (ctx.dryRun) {
-    echo(`[dry-run] cp ${source} -> ${target}`)
-    return
-  }
-
-  if (existsSync(target) && readFileSync(target, "utf8") === content) {
-    verbose(alreadyMessage)
-    return
-  }
-  if (existsSync(target)) backupPrivateFile(target)
-  writePrivateFile(target, content)
-  change(syncedMessage)
-  ctx.nextStepTriggers.ompRestart = true
-}
-
-function syncMergedYaml(
-  ctx: Ctx,
-  sourcePath: OmpTextPayloadPath,
-  target: string,
-  merge: (sotText: string, deployedText: string) => string
-): void {
-  const { change, echo, verbose } = ctx.services.logger
-  const source = payloadDisplayPath(sourcePath)
-  const sotText = payloadText(sourcePath)
-  const name = basename(sourcePath)
-
-  if (!existsSync(target)) {
-    if (ctx.dryRun) {
-      echo(`[dry-run] cp ${source} -> ${target}`)
-      return
-    }
-    writePrivateFile(target, sotText)
-    change(`omp ${name} installed`)
-    ctx.nextStepTriggers.ompRestart = true
-    return
-  }
-
-  const deployedText = readFileSync(target, "utf8")
-  const merged = merge(sotText, deployedText)
-  if (merged === deployedText) {
-    verbose(`omp ${name} already in sync`)
-    return
-  }
-  if (ctx.dryRun) {
-    echo(`[dry-run] merge ${source} -> ${target} (backup at ${target}.bak)`)
-    return
-  }
-
-  backupPrivateFile(target)
-  writePrivateFile(`${target}.tmp`, merged)
-  renameSync(`${target}.tmp`, target)
-  chmodSync(target, 0o600)
-  change(`omp ${name} merged (backup at ${name}.bak)`)
-  ctx.nextStepTriggers.ompRestart = true
-}
-
-// ---------------------------------------------------------- marketplace ----
-
-function registryHasDocks(registryFile: string): boolean {
-  if (!existsSync(registryFile)) return false
-
-  let registryText: string
-  try {
-    registryText = readFileSync(registryFile, "utf8")
-  } catch {
-    return false
-  }
-  const registry = parseJson(registryText)
-  if (registry === undefined) return false
-  if (isObject(registry) && Object.hasOwn(registry, MARKETPLACE_NAME)) return true
-
-  const entries = Array.isArray(registry)
-    ? registry
-    : isObject(registry) && Array.isArray(registry["marketplaces"])
-      ? registry["marketplaces"]
-      : []
-  return entries.some((entry) => isObject(entry) && entry["name"] === MARKETPLACE_NAME)
-}
-
-function firstOutputLine(result: AsyncProcessResult): string {
-  const output = `${result.stdout}${result.stderr}`
-  return output.split("\n")[0] || "unknown error"
-}
-
-/**
- * Three states, because upstream `getMarketplacesRegistryPath` copies a legacy
- * `configRoot` registry forward the first time it resolves an XDG data root:
- * the active registry lists docks, only the legacy registry lists it, or
- * neither does. In the middle state the kit never copies user data itself; it
- * takes the refresh path, whose own resolution inside omp performs that
- * adoption and leaves the active registry present.
- */
-async function syncMarketplace(ctx: Ctx, registryFile: string, legacyRegistryFile?: string): Promise<void> {
-  const { change, clearProgress, echo, progress, verbose } = ctx.services.logger
-  const registered = registryHasDocks(registryFile)
-  const adoptable = !registered && legacyRegistryFile !== undefined && registryHasDocks(legacyRegistryFile)
-
-  if (ctx.dryRun) {
-    if (adoptable) {
-      echo(
-        ctx.skipPluginRefresh === true
-          ? "[dry-run] omp plugin marketplace list"
-          : `[dry-run] omp plugin marketplace update ${MARKETPLACE_NAME}`
-      )
-    } else if (registered) verbose("omp docks marketplace already registered")
-    else echo(`[dry-run] omp plugin marketplace add ${MARKETPLACE_SOURCE}`)
-    return
-  }
-
-  // syncPlugins owns the single skip message for both missing CLIs, and it runs
-  // right after this pass. Without omp no marketplace command can run at all,
-  // and without git a marketplace clone cannot resolve, so both are deliberate
-  // skips: return silently instead of spawning and recording a failure.
-  if (ctx.services.deps.probe("omp").state === "missing") return
-  if (ctx.services.deps.probe("git").state === "missing") return
-
-  if (!registered && !adoptable) {
-    progress("Registering omp docks marketplace...")
-    const result = await spawnProcess("omp", ["plugin", "marketplace", "add", MARKETPLACE_SOURCE], {
-      stdio: ["ignore", "pipe", "pipe"]
-    })
-    clearProgress()
-    if (result.error === undefined && result.exitCode === 0) {
-      change("omp docks marketplace registered")
-    } else {
-      recordFailure(
-        ctx,
-        `omp docks marketplace registration failed: ${firstOutputLine(result)}; run manually: omp plugin marketplace add ${MARKETPLACE_SOURCE}`
-      )
-    }
-    return
-  }
-
-  if (ctx.skipPluginRefresh === true) {
-    if (!adoptable) {
-      verbose("omp docks marketplace already registered; refresh-only update skipped")
-      return
-    }
-
-    // Adoption only needs omp to resolve the registry path. `marketplace list`
-    // does that and fetches nothing, so it stays inside the flag's contract
-    // while leaving the active registry present.
-    progress("Adopting omp docks marketplace registry...")
-    const listed = await spawnProcess("omp", ["plugin", "marketplace", "list"], {
-      stdio: ["ignore", "ignore", "pipe"]
-    })
-    clearProgress()
-    if (listed.error === undefined && listed.exitCode === 0) {
-      change("omp docks marketplace registry adopted; refresh-only update skipped")
-    } else {
-      recordFailure(
-        ctx,
-        `omp docks marketplace adoption failed: ${firstOutputLine(listed)}; run manually: omp plugin marketplace list`
-      )
-    }
-    return
-  }
-
-  progress("Updating omp docks marketplace...")
-  const result = await spawnProcess("omp", ["plugin", "marketplace", "update", MARKETPLACE_NAME], {
-    stdio: ["ignore", "pipe", "pipe"]
-  })
-  clearProgress()
-  if (result.error === undefined && result.exitCode === 0) {
-    verbose("omp docks marketplace refreshed")
-  } else {
-    recordFailure(
-      ctx,
-      `omp docks marketplace update failed: ${firstOutputLine(result)}; run manually: omp plugin marketplace update ${MARKETPLACE_NAME}`
-    )
-  }
-}
-
-// -------------------------------------------------------------- plugins ----
-
-interface InstalledPlugins {
-  readonly marketplace: Set<string>
-  readonly npm: Map<string, string>
-}
-
-async function installedPluginIdsFromCli(): Promise<InstalledPlugins | undefined> {
-  const result = await spawnProcess("omp", ["plugin", "list", "--json"], {
-    stdio: ["ignore", "pipe", "ignore"]
-  })
-  if (result.error !== undefined || result.exitCode !== 0) return undefined
-
-  const value = parseJson(result.stdout)
-  if (
-    value === undefined ||
-    !isObject(value) ||
-    !Array.isArray(value["marketplace"]) ||
-    !Array.isArray(value["npm"])
-  ) {
-    return undefined
-  }
-
-  // `omp plugin list --json` reports marketplace rows as
-  // `{ id: "<plugin>@<marketplace>", scope, entries: [...] }` - the composite id
-  // is already the token `omp plugin install/upgrade` takes. omp emits one row
-  // per scope holding the plugin, so a match found only in a `project` row
-  // means the user scope is empty and `upgrade --scope user` would fail; only a
-  // `user` row counts as installed for this pipeline.
-  const marketplace = new Set<string>()
-  for (const row of value["marketplace"]) {
-    if (!isObject(row) || typeof row["id"] !== "string" || row["scope"] !== "user") continue
-    marketplace.add(row["id"])
-  }
-
-  const npm = new Map<string, string>()
-  for (const row of value["npm"]) {
-    if (!isObject(row) || typeof row["name"] !== "string" || typeof row["version"] !== "string") continue
-    npm.set(row["name"], row["version"])
-  }
-  return { marketplace, npm }
-}
-
-async function runPluginCommand(
-  ctx: Ctx,
-  plugin: string,
-  args: ReadonlyArray<string>
-): Promise<boolean> {
-  const { clearProgress, progress } = ctx.services.logger
-  progress(`Updating omp plugin ${plugin}...`)
-  const result = await spawnProcess("omp", args, { stdio: ["ignore", "pipe", "pipe"] })
-  clearProgress()
-  if (result.error === undefined && result.exitCode === 0) return true
-
-  recordFailure(
-    ctx,
-    `omp plugin operation failed for ${plugin}: ${firstOutputLine(result)}; run manually: omp ${args.join(" ")}`
-  )
-  return false
-}
-
-async function syncPlugins(ctx: Ctx): Promise<number> {
-  const { change, clearProgress, echo, progress, verbose, warn } = ctx.services.logger
-
-  if (ctx.dryRun) {
-    const piIntercomPin = field("pi-intercom", "verified")
-    for (const pluginId of MARKETPLACE_PLUGIN_IDS) {
-      echo(`[dry-run] omp plugin install --scope user ${pluginId}`)
-    }
-    if (piIntercomPin === "") {
-      warn("pi-intercom install skipped because SoT/toolchain.json has no verified pi-intercom pin")
-    } else {
-      echo(`[dry-run] omp install pi-intercom@${piIntercomPin}`)
-    }
-    return 0
-  }
-
-  if (ctx.services.deps.probe("omp").state === "missing") {
-    ctx.services.deps.warnMissing(
-      "omp",
-      ctx.services.logger,
-      "deployed omp config only — marketplace and plugin passes skipped; re-run sync after installing"
-    )
-    return 0
-  }
-  if (ctx.services.deps.probe("git").state === "missing") {
-    ctx.services.deps.warnMissing(
-      "git",
-      ctx.services.logger,
-      "plugin marketplaces are git repos — omp plugin refresh skipped; re-run sync after installing"
-    )
-    return 0
-  }
-  const piIntercomPin = field("pi-intercom", "verified")
-
-  progress("Checking installed omp plugins...")
-  const installed = await installedPluginIdsFromCli()
-  clearProgress()
-  if (installed === undefined) {
-    warn("omp plugin inventory unavailable — falling back to the full refresh path")
-  }
-
-  let pluginsInstalled = installed === undefined
-    ? 0
-    : MARKETPLACE_PLUGIN_IDS.filter((pluginId) => installed.marketplace.has(pluginId)).length +
-      (piIntercomPin !== "" && installed.npm.has("pi-intercom") ? 1 : 0)
-  let operationsSucceeded = 0
-
-  for (const pluginId of MARKETPLACE_PLUGIN_IDS) {
-    const present = installed?.marketplace.has(pluginId) === true
-    if (present && ctx.skipPluginRefresh === true) {
-      verbose(`omp plugin ${pluginId} already installed; refresh-only update skipped`)
-      continue
-    }
-
-    const args = present
-      ? ["plugin", "upgrade", "--scope", "user", pluginId]
-      : ["plugin", "install", "--scope", "user", pluginId]
-    if (await runPluginCommand(ctx, pluginId, args)) {
-      operationsSucceeded++
-      if (!present) pluginsInstalled++
-    }
-  }
-
-  if (piIntercomPin === "") {
-    warn("pi-intercom install skipped because SoT/toolchain.json has no verified pi-intercom pin")
-  } else {
-    const installedVersion = installed?.npm.get("pi-intercom")
-    const present = installedVersion !== undefined
-    if (installedVersion === piIntercomPin) {
-      verbose(`omp npm plugin pi-intercom already installed at ${piIntercomPin}`)
-    } else if (present && ctx.skipPluginRefresh === true) {
-      verbose("omp npm plugin pi-intercom already installed; refresh-only update skipped")
-    } else {
-      const args = present
-        ? ["install", "--force", `pi-intercom@${piIntercomPin}`]
-        : ["install", `pi-intercom@${piIntercomPin}`]
-      if (await runPluginCommand(ctx, "pi-intercom", args)) {
-        operationsSucceeded++
-        if (!present) pluginsInstalled++
-      }
-    }
-  }
+    "omp intercom configuration synced",
+  );
 
-  if (operationsSucceeded > 0) {
-    change(`omp plugins synced (plugins: ~${operationsSucceeded})`)
-    ctx.nextStepTriggers.ompRestart = true
-  } else {
-    verbose("omp plugins already in sync")
-  }
-  return pluginsInstalled
+  const legacyRegistryFile =
+    paths.dataRoot === paths.configRoot ? undefined : p(paths.configRoot, "marketplaces.json");
+  await syncMarketplace(ctx, p(paths.dataRoot, "marketplaces.json"), legacyRegistryFile);
+  const pluginsInstalled = await syncPlugins(ctx);
+  return { pluginsInstalled };
 }
 
 // -------------------------------------------------------------- summary ----
 
 export function ompSummary(ctx: Ctx, state: OmpState): void {
-  const { echo } = ctx.services.logger
-  const agentDir = ompPaths({ home: ctx.home, env: process.env, platform: ctx.services.platform.raw() }).agentDir
-  echo(`omp:      ${agentDir}`)
-  if (!ctx.dryRun) echo(`omp plugins: ${state.pluginsInstalled} installed`)
+  const { echo } = ctx.services.logger;
+  const agentDir = ompPaths({
+    home: ctx.home,
+    env: process.env,
+    platform: ctx.services.platform.raw(),
+  }).agentDir;
+  echo(`omp:      ${agentDir}`);
+  if (!ctx.dryRun) echo(`omp plugins: ${state.pluginsInstalled} installed`);
 }
 
 export function ompNextSteps(ctx: Ctx): Array<string> {
   return ctx.verbose || ctx.nextStepTriggers.ompRestart
     ? ["Restart omp to load any refreshed plugins, skills, or tools."]
-    : []
+    : [];
 }

package/cli/src/engine-native/ompYaml.ts

@@ -8,44 +8,44 @@
  * the kit-managed role chains. models.yml drops nothing; a user file may carry
  * provider credentials and custom models the kit never declares.
  */
-import { isMap, isScalar, parseDocument, type YAMLMap } from "yaml"
+import { isMap, isScalar, parseDocument, type YAMLMap } from "yaml";
 
 /** Decides whether a deployed-only key at `path` is dropped instead of kept. */
-type DropDeployedKey = (path: ReadonlyArray<string>, key: string) => boolean
+type DropDeployedKey = (path: ReadonlyArray<string>, key: string) => boolean;
 
-const fallbackChainsPath = ["retry", "fallbackChains"] as const
+const fallbackChainsPath = ["retry", "fallbackChains"] as const;
 
 function stringKey(key: unknown): string | undefined {
-  if (typeof key === "string") return key
-  if (isScalar(key) && typeof key.value === "string") return key.value
-  return undefined
+  if (typeof key === "string") return key;
+  if (isScalar(key) && typeof key.value === "string") return key.value;
+  return undefined;
 }
 
 function keyName(key: unknown): string {
-  return isScalar(key) ? String(key.value) : String(key)
+  return isScalar(key) ? String(key.value) : String(key);
 }
 
 const dropFallbackWildcard: DropDeployedKey = (path, key) =>
   path.length === fallbackChainsPath.length &&
   path[0] === fallbackChainsPath[0] &&
   path[1] === fallbackChainsPath[1] &&
-  key.includes("/")
+  key.includes("/");
 
-const keepEveryKey: DropDeployedKey = () => false
+const keepEveryKey: DropDeployedKey = () => false;
 
 function pruneMapping(mapping: YAMLMap, path: ReadonlyArray<string>, drop: DropDeployedKey): void {
   for (let index = mapping.items.length - 1; index >= 0; index--) {
-    const pair = mapping.items[index]
-    if (pair === undefined) continue
+    const pair = mapping.items[index];
+    if (pair === undefined) continue;
 
     if (drop(path, keyName(pair.key))) {
-      mapping.items.splice(index, 1)
-      continue
+      mapping.items.splice(index, 1);
+      continue;
     }
 
-    const key = stringKey(pair.key)
+    const key = stringKey(pair.key);
     if (key !== undefined && isMap(pair.value)) {
-      pruneMapping(pair.value, [...path, key], drop)
+      pruneMapping(pair.value, [...path, key], drop);
     }
   }
 }
@@ -54,29 +54,31 @@ function mergeMappings(
   sotMapping: YAMLMap,
   deployedMapping: YAMLMap,
   path: ReadonlyArray<string>,
-  drop: DropDeployedKey
+  drop: DropDeployedKey,
 ): void {
   for (const sotPair of sotMapping.items) {
-    const key = stringKey(sotPair.key)
-    if (key === undefined) continue
+    const key = stringKey(sotPair.key);
+    if (key === undefined) continue;
 
-    const deployedPair = deployedMapping.items.find((candidate) => stringKey(candidate.key) === key)
+    const deployedPair = deployedMapping.items.find(
+      (candidate) => stringKey(candidate.key) === key,
+    );
     if (deployedPair !== undefined && isMap(sotPair.value) && isMap(deployedPair.value)) {
-      mergeMappings(sotPair.value, deployedPair.value, [...path, key], drop)
+      mergeMappings(sotPair.value, deployedPair.value, [...path, key], drop);
     }
   }
 
   for (const deployedPair of deployedMapping.items) {
-    const key = stringKey(deployedPair.key)
+    const key = stringKey(deployedPair.key);
     const isManaged =
-      key !== undefined && sotMapping.items.some((candidate) => stringKey(candidate.key) === key)
-    if (isManaged) continue
+      key !== undefined && sotMapping.items.some((candidate) => stringKey(candidate.key) === key);
+    if (isManaged) continue;
 
-    if (drop(path, keyName(deployedPair.key))) continue
+    if (drop(path, keyName(deployedPair.key))) continue;
     if (key !== undefined && isMap(deployedPair.value)) {
-      pruneMapping(deployedPair.value, [...path, key], drop)
+      pruneMapping(deployedPair.value, [...path, key], drop);
     }
-    sotMapping.items.push(deployedPair)
+    sotMapping.items.push(deployedPair);
   }
 }
 
@@ -84,45 +86,45 @@ function mergeYamlDocuments(
   sotText: string,
   deployedText: string,
   name: string,
-  drop: DropDeployedKey
+  drop: DropDeployedKey,
 ): string {
-  const deployedDoc = parseDocument(deployedText)
-  const deployedError = deployedDoc.errors[0]
+  const deployedDoc = parseDocument(deployedText);
+  const deployedError = deployedDoc.errors[0];
   if (deployedError !== undefined) {
-    throw new Error(`Invalid deployed omp ${name} YAML: ${deployedError.message}`)
+    throw new Error(`Invalid deployed omp ${name} YAML: ${deployedError.message}`);
   }
 
-  const deployedContents = deployedDoc.contents
+  const deployedContents = deployedDoc.contents;
   if (
     deployedContents === null ||
     deployedContents === undefined ||
     (isScalar(deployedContents) && deployedContents.value === null)
   ) {
-    return sotText
+    return sotText;
   }
   if (!isMap(deployedContents)) {
-    throw new Error(`Deployed omp ${name} YAML root must be a mapping`)
+    throw new Error(`Deployed omp ${name} YAML root must be a mapping`);
   }
 
-  const sotDoc = parseDocument(sotText)
-  const sotError = sotDoc.errors[0]
+  const sotDoc = parseDocument(sotText);
+  const sotError = sotDoc.errors[0];
   if (sotError !== undefined) {
-    throw new Error(`Invalid SoT omp ${name} YAML: ${sotError.message}`)
+    throw new Error(`Invalid SoT omp ${name} YAML: ${sotError.message}`);
   }
   if (!isMap(sotDoc.contents)) {
-    throw new Error(`SoT omp ${name} YAML root must be a mapping`)
+    throw new Error(`SoT omp ${name} YAML root must be a mapping`);
   }
 
-  mergeMappings(sotDoc.contents, deployedContents, [], drop)
-  return sotDoc.toString()
+  mergeMappings(sotDoc.contents, deployedContents, [], drop);
+  return sotDoc.toString();
 }
 
 /** config.yml merge: keeps user-only keys, drops stale fallback-chain wildcards. */
 export function mergeOmpConfig(sotText: string, deployedText: string): string {
-  return mergeYamlDocuments(sotText, deployedText, "config.yml", dropFallbackWildcard)
+  return mergeYamlDocuments(sotText, deployedText, "config.yml", dropFallbackWildcard);
 }
 
 /** models.yml merge: keeps every user-only key, including credentials and custom models. */
 export function mergeOmpModels(sotText: string, deployedText: string): string {
-  return mergeYamlDocuments(sotText, deployedText, "models.yml", keepEveryKey)
+  return mergeYamlDocuments(sotText, deployedText, "models.yml", keepEveryKey);
 }

package/cli/src/engine-native/os/darwin.ts

@@ -1,5 +1,5 @@
-import { posixHost } from "./posix"
-import type { HostOs } from "./types"
+import { posixHost } from "./posix";
+import type { HostOs } from "./types";
 
 export const darwin: HostOs = posixHost({
   id: "darwin",
@@ -9,6 +9,6 @@ export const darwin: HostOs = posixHost({
     git: "brew install git",
     jq: "brew install jq",
     curl: "brew install curl",
-    ffplay: "brew install ffmpeg"
-  }
-})
+    ffplay: "brew install ffmpeg",
+  },
+});