docks-kit 0.17.1 → 0.17.3

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

@@ -0,0 +1,159 @@
+/**
+ * EngineNative `sync omp` retired-key pruning. `ompYaml.ts mergeOmpConfig` is
+ * additive: its `mergeMappings, deployed-key retention loop` returns every
+ * deployed key absent from the SoT to the merged result. Removing a key from
+ * `SoT/.omp/config.yml` therefore never removes it from an existing
+ * `~/.omp/agent/config.yml`. This pass force-prunes an inventory of retired
+ * kit-owned keys on every sync, without `--reconcile`. Message strings and
+ * prune semantics are part of the contract.
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { isMap, isScalar, parseDocument, type YAMLMap } from "yaml";
+import type { Ctx } from "./index";
+
+type RetiredScalar = string | number | boolean;
+
+/**
+ * Keys the kit used to deploy, each paired with the exact value it deployed. A
+ * key is pruned only while the deployed value still equals that value, so a
+ * user who changed the setting keeps it. Every recorded value also equals omp's
+ * current default, so pruning changes no behavior today and lets a later
+ * upstream default change take effect.
+ */
+const OMP_RETIRED_VALUES: ReadonlyArray<readonly [string, RetiredScalar]> = [
+  ["symbolPreset", "unicode"],
+  ["theme.dark", "titanium"],
+  ["statusLine.preset", "default"],
+  ["statusLine.showHookStatus", true],
+  ["statusLine.sessionAccent", true],
+  ["statusLine.transparent", false],
+  ["terminal.showProgress", false],
+  ["tui.textSizing", false],
+  ["tui.tight", false],
+  ["display.shimmer", "classic"],
+  ["omitThinking", false],
+  ["hideThinkingBlock", false],
+  ["autocompleteMaxVisible", 10],
+  ["emojiAutocomplete", true],
+  ["readLineNumbers", false],
+  ["interruptMode", "immediate"],
+  ["autoResume", false],
+  ["startup.changelogMode", "summary"],
+];
+
+/**
+ * Keys retired outright and pruned at any value, because the key itself no
+ * longer means anything. omp migrates `providers.webSearchOrder` in memory into
+ * `modelRoles.web` plus `retry.fallbackChains.web` and then drops it, but never
+ * writes that expansion back to the file.
+ */
+const OMP_RETIRED_KEYS: ReadonlyArray<string> = ["providers.webSearchOrder"];
+
+function indexOfKey(mapping: YAMLMap, key: string): number {
+  return mapping.items.findIndex((pair) => {
+    const name: unknown = pair.key;
+    if (typeof name === "string") return name === key;
+    return isScalar(name) && name.value === key;
+  });
+}
+
+/**
+ * Deletes `segments` when `matches` accepts the leaf value, then removes every
+ * ancestor mapping the deletion left empty. An ancestor holding another key
+ * survives, so `statusLine` keeps `compactThinkingLevel` while `tui` disappears
+ * once both of its keys are gone.
+ */
+function deletePath(
+  root: YAMLMap,
+  segments: ReadonlyArray<string>,
+  matches: (value: unknown) => boolean,
+): boolean {
+  const owners: Array<YAMLMap> = [root];
+  let cursor: YAMLMap = root;
+  for (const segment of segments.slice(0, -1)) {
+    const index = indexOfKey(cursor, segment);
+    const pair = index < 0 ? undefined : cursor.items[index];
+    if (pair === undefined || !isMap(pair.value)) return false;
+    cursor = pair.value;
+    owners.push(cursor);
+  }
+
+  const leaf = segments[segments.length - 1];
+  if (leaf === undefined) return false;
+  const leafIndex = indexOfKey(cursor, leaf);
+  if (leafIndex < 0) return false;
+  const leafPair = cursor.items[leafIndex];
+  if (leafPair === undefined || !matches(leafPair.value)) return false;
+
+  // `commentBefore` can hold several blocks separated by a blank line. Only the
+  // final block sits against this key; anything above it is a file or section
+  // header that happens to precede the key, so it survives the removal instead
+  // of leaving with it.
+  const leafKey: unknown = leafPair.key;
+  const priorComment =
+    isScalar(leafKey) && typeof leafKey.commentBefore === "string"
+      ? leafKey.commentBefore.slice(0, Math.max(0, leafKey.commentBefore.lastIndexOf("\n\n")))
+      : "";
+  cursor.items.splice(leafIndex, 1);
+  if (priorComment !== "") {
+    const heir: unknown = cursor.items[leafIndex]?.key;
+    if (isScalar(heir)) {
+      heir.commentBefore =
+        typeof heir.commentBefore === "string"
+          ? `${priorComment}\n\n${heir.commentBefore}`
+          : priorComment;
+    } else {
+      // The key was last in its mapping, so there is no later key to carry the
+      // header. A trailing mapping comment keeps the text in the file.
+      cursor.comment =
+        typeof cursor.comment === "string" ? `${cursor.comment}\n${priorComment}` : priorComment;
+    }
+  }
+
+  for (let depth = owners.length - 1; depth >= 1; depth--) {
+    const mapping = owners[depth];
+    if (mapping === undefined || mapping.items.length > 0) break;
+    const owner = owners[depth - 1];
+    const segment = segments[depth - 1];
+    if (owner === undefined || segment === undefined) break;
+    const index = indexOfKey(owner, segment);
+    if (index >= 0) owner.items.splice(index, 1);
+  }
+  return true;
+}
+
+/** Prunes retired kit-owned keys from a deployed omp config.yml. */
+export function syncOmpRemovals(ctx: Ctx, configFile: string): number {
+  const { change, echo, verbose, warn } = ctx.services.logger;
+  if (!existsSync(configFile)) return 0;
+
+  const doc = parseDocument(readFileSync(configFile, "utf8"));
+  const parseError = doc.errors[0];
+  if (parseError !== undefined) {
+    warn(`omp config.yml unreadable, retired keys not pruned: ${parseError.message}`);
+    return 0;
+  }
+  const contents = doc.contents;
+  if (!isMap(contents)) return 0;
+
+  const pruned: Array<string> = [];
+  for (const [path, value] of OMP_RETIRED_VALUES) {
+    const matches = (node: unknown): boolean => isScalar(node) && node.value === value;
+    if (deletePath(contents, path.split("."), matches)) pruned.push(path);
+  }
+  for (const path of OMP_RETIRED_KEYS) {
+    if (deletePath(contents, path.split("."), () => true)) pruned.push(path);
+  }
+
+  if (pruned.length === 0) {
+    verbose("omp config.yml carries no retired keys");
+    return 0;
+  }
+  if (ctx.dryRun) {
+    echo(`[dry-run] prune ${configFile}: ${pruned.join(", ")}`);
+    return pruned.length;
+  }
+  writeFileSync(configFile, String(doc));
+  change(`omp config.yml pruned ${pruned.length} retired key(s): ${pruned.join(", ")}`);
+  return pruned.length;
+}

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

@@ -5,437 +5,97 @@
  * 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`, the plugin pass in `ompPlugins.ts`, and the retired-key
+ * prune in `ompRemovals.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 { 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 { isAbsolute, resolve } from "node:path";
+
+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";
+import { syncOmpRemovals } from "./ompRemovals";
 
 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);
+  // mergeOmpConfig is additive, so the prune must run on the merged result.
+  syncOmpRemovals(ctx, p(agentDir, "config.yml"));
+  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."]
-    : []
+    : [];
 }