docks-kit 0.15.5 → 0.16.1

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

@@ -0,0 +1,421 @@
+/**
+ * EngineNative `sync omp` pipeline. config.yml merges through mergeOmpConfig
+ * because omp serialises that file itself. Paths come from ompPaths because
+ * profiles, PI_CONFIG_DIR, 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.
+ */
+import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs"
+import { isAbsolute, resolve } from "node:path"
+
+import { payloadDisplayPath, payloadText, type PayloadPath } from "../payload"
+import { bunBootstrap } from "./bun"
+import { commandExists, p, spawnProcess, type AsyncProcessResult } from "./exec"
+import type { Ctx } from "./index"
+import { isObject, parseJson } from "./jq"
+import { ompPaths } from "./ompPaths"
+import { mergeOmpConfig } 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}`>
+
+export interface OmpState {
+  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)
+
+  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")
+  syncConfig(ctx, p(agentDir, "config.yml"))
+
+  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 syncConfig(ctx: Ctx, target: string): void {
+  const { change, echo, verbose } = ctx.services.logger
+  const source = payloadDisplayPath("SoT/.omp/config.yml")
+  const sotText = payloadText("SoT/.omp/config.yml")
+
+  if (!existsSync(target)) {
+    if (ctx.dryRun) {
+      echo(`[dry-run] cp ${source} -> ${target}`)
+      return
+    }
+    writePrivateFile(target, sotText)
+    change("omp config.yml installed")
+    ctx.nextStepTriggers.ompRestart = true
+    return
+  }
+
+  const deployedText = readFileSync(target, "utf8")
+  const merged = mergeOmpConfig(sotText, deployedText)
+  if (merged === deployedText) {
+    verbose("omp config.yml 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 config.yml merged (backup at config.yml.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, warn } = 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
+  }
+
+  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 {
+      warn(
+        `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 {
+      warn(
+        `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 {
+    warn(
+      `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, warn } = 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
+
+  warn(
+    `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(ctx, "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(ctx, "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++
+      }
+    }
+  }
+
+  if (operationsSucceeded > 0) {
+    change(`omp plugins synced (plugins: ~${operationsSucceeded})`)
+    ctx.nextStepTriggers.ompRestart = true
+  } else {
+    verbose("omp plugins already in sync")
+  }
+  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`)
+}
+
+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

@@ -0,0 +1,107 @@
+/**
+ * YAML merge for omp config.yml. omp serialises this file itself, so the kit
+ * uses the yaml package rather than a line-based merge. Deployed-only keys are
+ * retained except for slash-bearing keys directly under retry.fallbackChains:
+ * omp treats those as model or provider wildcards ahead of role chains, so a
+ * stale wildcard would silently override the kit-managed role chains.
+ */
+import { isMap, isScalar, parseDocument, type YAMLMap } from "yaml"
+
+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
+}
+
+function isFallbackChains(path: ReadonlyArray<string>): boolean {
+  return (
+    path.length === fallbackChainsPath.length &&
+    path[0] === fallbackChainsPath[0] &&
+    path[1] === fallbackChainsPath[1]
+  )
+}
+
+function pruneFallbackWildcards(mapping: YAMLMap, path: ReadonlyArray<string>): void {
+  const underFallbackChains = isFallbackChains(path)
+  for (let index = mapping.items.length - 1; index >= 0; index--) {
+    const pair = mapping.items[index]
+    if (pair === undefined) continue
+
+    const keyName = isScalar(pair.key) ? String(pair.key.value) : String(pair.key)
+    if (underFallbackChains && keyName.includes("/")) {
+      mapping.items.splice(index, 1)
+      continue
+    }
+
+    const key = stringKey(pair.key)
+    if (key !== undefined && isMap(pair.value)) {
+      pruneFallbackWildcards(pair.value, [...path, key])
+    }
+  }
+}
+
+function mergeMappings(
+  sotMapping: YAMLMap,
+  deployedMapping: YAMLMap,
+  path: ReadonlyArray<string>
+): void {
+  for (const sotPair of sotMapping.items) {
+    const key = stringKey(sotPair.key)
+    if (key === undefined) continue
+
+    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])
+    }
+  }
+
+  for (const deployedPair of deployedMapping.items) {
+    const key = stringKey(deployedPair.key)
+    const isManaged =
+      key !== undefined && sotMapping.items.some((candidate) => stringKey(candidate.key) === key)
+    if (isManaged) continue
+
+    const keyName = isScalar(deployedPair.key)
+      ? String(deployedPair.key.value)
+      : String(deployedPair.key)
+    if (isFallbackChains(path) && keyName.includes("/")) continue
+    if (key !== undefined && isMap(deployedPair.value)) {
+      pruneFallbackWildcards(deployedPair.value, [...path, key])
+    }
+    sotMapping.items.push(deployedPair)
+  }
+}
+
+export function mergeOmpConfig(sotText: string, deployedText: string): string {
+  const deployedDoc = parseDocument(deployedText)
+  const deployedError = deployedDoc.errors[0]
+  if (deployedError !== undefined) {
+    throw new Error(`Invalid deployed omp config YAML: ${deployedError.message}`)
+  }
+
+  const deployedContents = deployedDoc.contents
+  if (
+    deployedContents === null ||
+    deployedContents === undefined ||
+    (isScalar(deployedContents) && deployedContents.value === null)
+  ) {
+    return sotText
+  }
+  if (!isMap(deployedContents)) {
+    throw new Error("Deployed omp config YAML root must be a mapping")
+  }
+
+  const sotDoc = parseDocument(sotText)
+  const sotError = sotDoc.errors[0]
+  if (sotError !== undefined) {
+    throw new Error(`Invalid SoT omp config YAML: ${sotError.message}`)
+  }
+  if (!isMap(sotDoc.contents)) {
+    throw new Error("SoT omp config YAML root must be a mapping")
+  }
+
+  mergeMappings(sotDoc.contents, deployedContents, [])
+  return sotDoc.toString()
+}

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

@@ -5,6 +5,7 @@
  */
 
 import type { Ctx, ModifierFlag } from "./index"
+import { LEGACY_SELECTION, readHarnessSelection, type Harness } from "./harnesses"
 import {
   CLAUDE_ADVISOR_STATES,
   advisorCatalog,
@@ -118,12 +119,13 @@ const SCALAR_MODIFIER_FLAGS: Record<ScalarModifierFlag, true> = {
 function usage(ctx: Ctx): void {
   const { echo } = ctx.services.logger
   const argv0 = "docks-kit sync"
-  echo(`Usage: ${argv0} [claude] [codex] [agents] [flags]`)
+  echo(`Usage: ${argv0} [claude] [codex] [agents] [omp] [flags]`)
   echo("")
-  echo("Targets (positional; default: all three)")
+  echo("Targets (positional; default: this machine's harness selection)")
   echo("  claude            sync the Claude Code SoT")
   echo("  codex             sync the Codex SoT")
   echo("  agents            sync universal agent skills")
+  echo("  omp               sync the Oh My Pi SoT")
   echo("")
   echo("Global flags")
   echo("  --dry-run         preview without applying")
@@ -197,13 +199,38 @@ function addClaudePlugin(ctx: Ctx, name: string): void {
   markModifier(ctx, "--claude-plugin")
 }
 
-function selectTarget(ctx: Ctx, target: string): void {
-  if (target === "claude") ctx.syncClaude = true
-  else if (target === "codex") ctx.syncCodex = true
-  else ctx.syncAgents = true
+type TargetFlag = "syncClaude" | "syncCodex" | "syncAgents" | "syncOmp"
+
+const TARGET_FLAGS = {
+  claude: "syncClaude",
+  codex: "syncCodex",
+  agents: "syncAgents",
+  omp: "syncOmp"
+} satisfies Record<Harness, TargetFlag>
+
+function selectTarget(ctx: Ctx, target: Harness): void {
+  ctx[TARGET_FLAGS[target]] = true
   ctx.targetFilterSet = true
 }
 
+function applySelection(ctx: Ctx, selection: ReadonlyArray<Harness>): void {
+  ctx.syncClaude = selection.includes("claude")
+  ctx.syncCodex = selection.includes("codex")
+  ctx.syncAgents = selection.includes("agents")
+  ctx.syncOmp = selection.includes("omp")
+}
+
+function applyDefaultSelection(ctx: Ctx): void {
+  if (ctx.targetFilterSet) return
+
+  const storedSelection = readHarnessSelection(ctx.home)
+  applySelection(ctx, storedSelection ?? LEGACY_SELECTION)
+  if (storedSelection !== undefined || !ctx.interactive) return
+
+  ctx.services.logger.echo("No harness selection stored; syncing claude, codex, agents")
+  ctx.services.logger.echo("Choose harnesses with: docks-kit harnesses")
+}
+
 function setModifier(ctx: Ctx, flag: ScalarModifierFlag, value: string): void {
   switch (flag) {
     case "--claude-model":
@@ -243,6 +270,7 @@ export function parseArgs(ctx: Ctx, args: ReadonlyArray<string>): void {
       case "claude":
       case "codex":
       case "agents":
+      case "omp":
         selectTarget(ctx, arg)
         continue
       case "--dry-run":
@@ -296,6 +324,7 @@ export function parseArgs(ctx: Ctx, args: ReadonlyArray<string>): void {
       case "--claude":
       case "--codex":
       case "--agents":
+      case "--omp":
         err(`${arg} was renamed: pass the target as a word, e.g. 'sync ${arg.slice(2)}'`)
         throw new ExitError(2)
       case "--force":
@@ -355,11 +384,7 @@ export function parseArgs(ctx: Ctx, args: ReadonlyArray<string>): void {
     }
   }
 
-  if (!ctx.targetFilterSet) {
-    ctx.syncClaude = true
-    ctx.syncCodex = true
-    ctx.syncAgents = true
-  }
+  applyDefaultSelection(ctx)
 }
 
 function printCatalog(ctx: Ctx, catalog: string): void {

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

@@ -60,6 +60,7 @@ export async function installedVersion(ctx: Ctx, tool: ToolId): Promise<string>
     case "tsc":
       return firstLineField(await version(), 1)
     case "bun":
+    case "omp":
     case "npm":
       return await version()
     case "bwrap":
@@ -92,7 +93,8 @@ export async function report(ctx: Ctx): Promise<void> {
     const verified = field(ctx, tool, "verified")
     const dash = (v: string): string => (v !== "" ? v : "-")
     if (kind === "pin") {
-      echo(row([tool, kind, "(npx)", dash(floor), dash(verified), "pinned"]))
+      const via = field(ctx, tool, "via")
+      echo(row([tool, kind, `(${via !== "" ? via : "npx"})`, dash(floor), dash(verified), "pinned"]))
       continue
     }
     let installed: string