ucode 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2bf2b84f7b6350471c31bd58b724534f5bde2a0c1e2bf44cfe41cd36a8ab6165
-  data.tar.gz: 7506b44a00233009e01dd5668d375082ec42f9ab2c6e3d0d319722949599496a
+  metadata.gz: d9d5a29a388017c0338a8d2723f97dfd4ac8985324b6ab7fc9b8921a5f4b0b82
+  data.tar.gz: f6988cf20f74efc1b94ebfedbd7b9507680de1c0880ffd28ac9a4a00851195a8
 SHA512:
-  metadata.gz: 217b105ac13f10fcdaa51b39dbb23f8db3ba2b2026a0c9db4533df4ffc0434a06b1cbe89f078b6be2faa7603e0b8bf06b9a2e1ea5c775480cb213822ec8456e7
-  data.tar.gz: 1a0866921d181bb0b1cb8aa5113ea887a5a33eb1e0661d4d40eeec00e341d4b07cfb98f5ba9127b7bbcf834d79394c713a1f44a414b2759ba4bc08e96ef491db
+  metadata.gz: 890fec1b40ed6016b269982d32d28b15eb2683dfa7d4e9fc32e5a6633c46fb6f8a94b0d004d1bbd4381fb5bbe629faf00984729036005c12e1558c65d70afe4f
+  data.tar.gz: 792b58d5eb3434b05008740457b1c432f5810bd45b2d0d80936bd0c539445098b835c1d242093487cf0a4a4754efba2fe725c500b2d3f1a23f4906b4a17809dc

data/lib/ucode/audit/reference_factory.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Ucode
+  module Audit
+    # Translates CLI flags into a {Ucode::Audit::CoverageReference}.
+    #
+    # The audit CLI exposes the universal-set reference via a
+    # `--reference-universal-set=<path>` flag (and a default lookup
+    # at `output/universal_glyph_set/manifest.json`). This factory
+    # resolves the flag value into a concrete reference instance
+    # backed by a freshly-opened {Ucode::Database}, so the command
+    # classes don't repeat the same branching.
+    #
+    # Behavior:
+    #
+    # - flag = "none"          → nil (force UCD-only even if a default manifest exists)
+    # - flag = path to .json   → {Ucode::Audit::UniversalSetReference}
+    # - flag = nil             → look at DEFAULT_MANIFEST_PATH; use it if present,
+    #                             else nil (UCD-only)
+    #
+    # Lives in the {Ucode::Audit} namespace (not {Ucode::Commands::Audit})
+    # so the Audit module owns its own entry point — programmatic callers
+    # don't need to round-trip through the CLI to obtain a reference.
+    module ReferenceFactory
+      DEFAULT_MANIFEST_PATH = Pathname.new("output/universal_glyph_set/manifest.json")
+
+      module_function
+
+      # @param flag [String, nil] value of the
+      #   `--reference-universal-set` CLI option.
+      # @param version [String, nil] UCD version for the database
+      #   that backs the reference. When nil, the default UCD
+      #   version is resolved.
+      # @return [Ucode::Audit::CoverageReference, nil]
+      def build_from_cli(flag:, version: nil)
+        return nil if flag == "none"
+
+        path = resolve_manifest_path(flag)
+        return nil unless path && File.exist?(path)
+
+        database = open_database(version)
+        return nil unless database
+
+        Ucode::Audit::UniversalSetReference.new(
+          manifest: path, database: database,
+        )
+      end
+
+      def resolve_manifest_path(flag)
+        return Pathname.new(flag) if flag && flag != "none"
+        return DEFAULT_MANIFEST_PATH if DEFAULT_MANIFEST_PATH.exist?
+
+        nil
+      end
+
+      def open_database(version)
+        resolved = version || Ucode::VersionResolver.resolve(nil)
+        Ucode::Database.open(resolved)
+      rescue Ucode::UnknownVersionError, Ucode::DatabaseMissingError
+        nil
+      end
+    end
+  end
+end

data/lib/ucode/audit.rb

@@ -32,6 +32,7 @@ module Ucode
     autoload :CoverageReference, "ucode/audit/coverage_reference"
     autoload :UcdOnlyReference, "ucode/audit/ucd_only_reference"
     autoload :UniversalSetReference, "ucode/audit/universal_set_reference"
+    autoload :ReferenceFactory, "ucode/audit/reference_factory"
 
     # Per-face orchestrator (TODO 11) — shared by LibraryAuditor and
     # the future CLI AuditCommand.

data/lib/ucode/cli.rb

@@ -3,6 +3,7 @@
 require "thor"
 
 require "ucode/commands"
+require "ucode/version_resolver"
 
 module Ucode
   # Top-level CLI entry.
@@ -10,6 +11,12 @@ module Ucode
   # **Thin Thor**: every method delegates to a `Commands::*Command`
   # class and only formats the result. The Command classes are pure
   # and testable in-process — Thor never holds business logic.
+  #
+  # **Version resolution lives here** — each top-level command resolves
+  # the user-supplied intent (nil / :default / :latest / explicit string)
+  # exactly once via `VersionResolver.resolve` and threads the resolved
+  # string into the dispatched Command. Sub-commands never re-resolve.
+  # See Candidate 4 of the 2026-06-29 architecture review.
   class Cli < Thor
     package_name "ucode"
 
@@ -28,13 +35,17 @@ module Ucode
       desc "ucd [VERSION]", "Download UCD.zip"
       option :force, type: :boolean, default: false, desc: "Re-download even if cached"
       def ucd(version = nil)
-        puts format_result Commands::FetchCommand.new.fetch_ucd(version, force: options[:force])
+        puts format_result Commands::FetchCommand.new.fetch_ucd(
+          VersionResolver.resolve(version), force: options[:force],
+        )
       end
 
       desc "unihan [VERSION]", "Download Unihan.zip"
       option :force, type: :boolean, default: false
       def unihan(version = nil)
-        puts format_result Commands::FetchCommand.new.fetch_unihan(version, force: options[:force])
+        puts format_result Commands::FetchCommand.new.fetch_unihan(
+          VersionResolver.resolve(version), force: options[:force],
+        )
       end
 
       desc "charts [VERSION]", "Download per-block Code Charts PDFs"
@@ -43,7 +54,8 @@ module Ucode
       def charts(version = nil)
         cps = options[:block]&.map { |id| block_id_to_first_cp(id) }&.compact
         puts format_result Commands::FetchCommand.new
-          .fetch_charts(version, block_first_cps: cps, force: options[:force])
+          .fetch_charts(VersionResolver.resolve(version),
+                        block_first_cps: cps, force: options[:force])
       end
 
       desc "fonts", "Download specialist Tier 1 fonts (config/specialist_fonts.yml)"
@@ -90,7 +102,9 @@ module Ucode
     desc "parse [VERSION]", "Stream UCD → output/"
     option :to, type: :string, default: "./output", desc: "Output directory"
     def parse(version = nil)
-      result = Commands::ParseCommand.new.call(version, output_root: options[:to])
+      result = Commands::ParseCommand.new.call(
+        VersionResolver.resolve(version), output_root: options[:to],
+      )
       puts JSON.pretty_generate(result)
     end
 
@@ -111,7 +125,7 @@ module Ucode
                             desc: "Opt into the experimental v0.1 pipeline"
     def glyphs(version = nil)
       result = Commands::GlyphsCommand.new.call(
-        version,
+        VersionResolver.resolve(version),
         output_root: options[:to],
         block_filter: options[:block],
         force: options[:force],
@@ -150,7 +164,9 @@ module Ucode
       def block(codepoint)
         cp = parse_cp(codepoint)
         with_db_handling do
-          result = Commands::LookupCommand.new.lookup_block(options[:version], codepoint: cp)
+          result = Commands::LookupCommand.new.lookup_block(
+            VersionResolver.resolve(options[:version]), codepoint: cp,
+          )
           puts "#{format("U+%04X", cp)} → #{result.block || "(unassigned)"}"
         end
       end
@@ -160,7 +176,9 @@ module Ucode
       def script(codepoint)
         cp = parse_cp(codepoint)
         with_db_handling do
-          result = Commands::LookupCommand.new.lookup_script(options[:version], codepoint: cp)
+          result = Commands::LookupCommand.new.lookup_script(
+            VersionResolver.resolve(options[:version]), codepoint: cp,
+          )
           puts "#{format("U+%04X", cp)} → #{result.script || "(none)"}"
         end
       end
@@ -172,7 +190,8 @@ module Ucode
         cp = parse_cp(codepoint)
         with_db_handling do
           result = Commands::LookupCommand.new
-            .lookup_char(options[:version], codepoint: cp, output_root: options[:from])
+            .lookup_char(VersionResolver.resolve(options[:version]),
+                         codepoint: cp, output_root: options[:from])
           puts "#{format("U+%04X", cp)} block=#{result.block_id} glyph=#{result.glyph_path}"
         end
       end
@@ -274,7 +293,7 @@ module Ucode
                                         desc: "Emit per-block missing-glyph galleries " \
                                               "(requires --browse + --universal-set-root)"
       def font(path)
-        reference = Commands::Audit::ReferenceBuilder.build(
+        reference = Ucode::Audit::ReferenceFactory.build_from_cli(
           flag: options[:reference_universal_set],
           version: options[:unicode_version],
         )
@@ -312,7 +331,7 @@ module Ucode
       option :with_missing_glyph_pages, type: :boolean, default: false,
                                         desc: "Emit per-block missing-glyph galleries"
       def collection(path)
-        reference = Commands::Audit::ReferenceBuilder.build(
+        reference = Ucode::Audit::ReferenceFactory.build_from_cli(
           flag: options[:reference_universal_set],
           version: options[:unicode_version],
         )
@@ -349,7 +368,7 @@ module Ucode
       option :with_missing_glyph_pages, type: :boolean, default: false,
                                         desc: "Emit per-block missing-glyph galleries"
       def library(dir)
-        reference = Commands::Audit::ReferenceBuilder.build(
+        reference = Ucode::Audit::ReferenceFactory.build_from_cli(
           flag: options[:reference_universal_set],
           version: options[:unicode_version],
         )
@@ -430,7 +449,7 @@ module Ucode
                         desc: "Worker pool size (default: Ucode.configuration.parallel_workers)"
       def build(version = nil)
         result = Commands::UniversalSet::BuildCommand.new.call(
-          version,
+          VersionResolver.resolve(version),
           output_root: options[:to],
           source_config_path: options[:source_config],
           block_filter: options[:block],
@@ -448,7 +467,7 @@ module Ucode
                              desc: "Path to a Tier 1 source config YAML"
       def pre_check(version = nil)
         report = Commands::UniversalSet::PreCheckCommand.new.call(
-          version,
+          VersionResolver.resolve(version),
           source_config_path: options[:source_config],
         )
         puts JSON.pretty_generate(report.to_h)
@@ -463,7 +482,7 @@ module Ucode
                     desc: "Output directory holding manifest.json"
       def report(version = nil)
         result = Commands::UniversalSet::ReportCommand.new.call(
-          version,
+          VersionResolver.resolve(version),
           output_root: options[:from],
         )
         puts JSON.pretty_generate(result)
@@ -475,7 +494,7 @@ module Ucode
       def validate(output_root = "./output/universal_glyph_set")
         result = Commands::UniversalSet::ValidateCommand.new.call(
           output_root,
-          version_intent: options[:version],
+          version: options[:version] && VersionResolver.resolve(options[:version]),
         )
         puts JSON.pretty_generate(result)
         exit 1 unless result[:passed]
@@ -518,7 +537,7 @@ module Ucode
                                      desc: "Path to universal-set manifest (or 'none') " \
                                            "for the per-face coverage reference"
     def release
-      reference = Commands::Audit::ReferenceBuilder.build(
+      reference = Ucode::Audit::ReferenceFactory.build_from_cli(
         flag: options[:reference_universal_set],
         version: options[:unicode_version],
       )

data/lib/ucode/commands/audit.rb

@@ -14,7 +14,6 @@ module Ucode
       autoload :LibraryCommand,    "ucode/commands/audit/library_command"
       autoload :CompareCommand,    "ucode/commands/audit/compare_command"
       autoload :BrowserCommand,    "ucode/commands/audit/browser_command"
-      autoload :ReferenceBuilder,  "ucode/commands/audit/reference_builder"
     end
   end
 end

data/lib/ucode/commands/build.rb

@@ -11,6 +11,10 @@ module Ucode
     # parse → (optional) glyphs → (optional) site. Resumable: each step
     # is idempotent and safe to re-run.
     #
+    # Resolves the version intent once at the top and threads the
+    # resolved string through every sub-command. See Candidate 4 of the
+    # 2026-06-29 architecture review.
+    #
     # **Glyph step is opt-in as of v0.1** because the SVG cell extractor
     # is still experimental. Pass `include_glyphs: true` to enable it;
     # otherwise the glyphs step is recorded as skipped.

data/lib/ucode/commands/canonical_build.rb

@@ -39,7 +39,7 @@ module Ucode
     # Missing pre-conditions cause silent fallthrough to lower tiers;
     # the build report's `by_tier` totals surface what ran.
     class CanonicalBuildCommand
-      # @param version_intent [nil, :default, :latest, String]
+      # @param version [String] resolved UCD version
       # @param output_root [String, Pathname]
       # @param source_config_path [String, Pathname, nil] override the
       #   Tier 1 font config YAML; nil uses the default
@@ -54,9 +54,8 @@ module Ucode
       #   true. nil skips the block_coverage check.
       # @return [Hash] { version:, codepoint_count:, report_path:,
       #   validation_report_path:, validation_passed: }
-      def call(version_intent, output_root:, source_config_path: nil,
+      def call(version, output_root:, source_config_path: nil,
                resolver: nil, validate: true, baseline: nil)
-        version = VersionResolver.resolve(version_intent)
         root = Pathname.new(output_root)
 
         resolved_resolver = resolver || build_resolver(version, source_config_path)

data/lib/ucode/commands/fetch.rb

@@ -5,7 +5,7 @@ require "pathname"
 require "ucode/cache"
 require "ucode/fetch"
 require "ucode/glyphs/source_config"
-require "ucode/version_resolver"
+require "ucode/parsers"
 
 module Ucode
   module Commands
@@ -13,40 +13,38 @@ module Ucode
     # per-version cache, plus the specialist Tier 1 fonts referenced by
     # the curated source config.
     #
-    # Thin shell over `Ucode::Fetch::*`. The command layer's job is to
-    # resolve the version intent and format the result; the fetcher does
-    # the network I/O.
+    # Thin shell over `Ucode::Fetch::*`. The command takes a resolved
+    # version string; CLI callers resolve via {VersionResolver.resolve}
+    # once and thread it through. See Candidate 4 of the 2026-06-29
+    # architecture review.
     class FetchCommand
       DEFAULT_SPECIALIST_FONTS_MANIFEST =
         Ucode::Glyphs::SourceConfig::DEFAULT_PATH.dirname.join("specialist_fonts.yml")
       private_constant :DEFAULT_SPECIALIST_FONTS_MANIFEST
 
-      # @param version_intent [nil, :default, :latest, String]
+      # @param version [String] resolved UCD version
       # @param force [Boolean]
       # @return [Hash] { version:, ucd_dir: }
-      def fetch_ucd(version_intent, force: false)
-        version = VersionResolver.resolve(version_intent)
+      def fetch_ucd(version, force: false)
         Cache.ensure_version_dir!(version)
         path = Fetch::UcdZip.call(version, force: force)
         { version: version, ucd_dir: path }
       end
 
-      # @param version_intent [nil, :default, :latest, String]
+      # @param version [String] resolved UCD version
       # @param force [Boolean]
       # @return [Hash] { version:, unihan_dir: }
-      def fetch_unihan(version_intent, force: false)
-        version = VersionResolver.resolve(version_intent)
+      def fetch_unihan(version, force: false)
         Cache.ensure_version_dir!(version)
         path = Fetch::UnihanZip.call(version, force: force)
         { version: version, unihan_dir: path }
       end
 
-      # @param version_intent [nil, :default, :latest, String]
+      # @param version [String] resolved UCD version
       # @param block_first_cps [Array<Integer>, nil] nil = all known blocks
       # @param force [Boolean]
       # @return [Hash] { version:, downloaded: }
-      def fetch_charts(version_intent, block_first_cps: nil, force: false)
-        version = VersionResolver.resolve(version_intent)
+      def fetch_charts(version, block_first_cps: nil, force: false)
         Cache.ensure_version_dir!(version)
 
         cps = block_first_cps || default_block_first_cps(version)
@@ -95,4 +93,4 @@ module Ucode
       end
     end
   end
-end
+end

data/lib/ucode/commands/glyphs.rb

@@ -1,19 +1,16 @@
 # frozen_string_literal: true
 
 require "pathname"
-require "set"
 
-require "ucode/cache"
 require "ucode/glyphs"
-require "ucode/parsers"
-require "ucode/version_resolver"
 
 module Ucode
   module Commands
     # `ucode glyphs` — extract per-codepoint SVGs from Code Charts PDFs.
-    # Builds block specs from the cached Blocks.txt + per-block PDFs (or
-    # monolith fallback), then drains them through the Glyphs::Writer
-    # worker pool.
+    # Thin Thor-facing wrapper around {Ucode::Glyphs::Pipeline}:
+    # opt-in gate + experimental warning live here; the pipeline
+    # assembly (block loading, fetcher, per-block specs) lives in
+    # {Ucode::Glyphs::Pipeline}.
     #
     # **Status (v0.1): EXPERIMENTAL.** The cell-extraction pipeline
     # currently includes cell-border decorations alongside the actual
@@ -23,16 +20,16 @@ module Ucode
     # pipeline can be iterated on without churning the CLI surface, but
     # callers MUST opt in via `include_glyphs: true` (CLI: `--include-glyphs`)
     # and will receive a printed warning. Tracked for v0.2.
+    #
+    # Takes a resolved version string; CLI callers resolve via
+    # {VersionResolver.resolve} once and thread it through. See
+    # Candidate 4 of the 2026-06-29 architecture review.
     class GlyphsCommand
       ExperimentalWarning = "ucode glyphs is experimental in v0.1: " \
                             "extracted SVGs include cell-border decorations " \
                             "alongside the character outline."
       private_constant :ExperimentalWarning
 
-      MonolithPath = "CodeCharts.pdf"
-      PageMapCache = "data/codecharts_page_map.json"
-      private_constant :MonolithPath, :PageMapCache
-
       class << self
         # @return [String] the experimental-status banner. Exposed so the
         #   CLI and BuildCommand surface the same message verbatim.
@@ -41,7 +38,7 @@ module Ucode
         end
       end
 
-      # @param version_intent [nil, :default, :latest, String]
+      # @param version [String] resolved UCD version
       # @param output_root [String, Pathname]
       # @param block_filter [Array<String>, nil] block ids to limit to;
       #   nil = every block
@@ -55,75 +52,36 @@ module Ucode
       #   written here exactly once before work begins.
       # @return [Hash] aggregated Writer tally + version, or a `skipped`
       #   payload when opt-in is false.
-      def call(version_intent, output_root:,
-               block_filter: nil, force: false, monolith_path: MonolithPath,
+      def call(version, output_root:,
+               block_filter: nil, force: false,
+               monolith_path: Glyphs::Pipeline::DEFAULT_MONOLITH_PATH,
                include_glyphs: false, warn: nil)
-        return skipped(version_intent) unless include_glyphs
+        return skipped(version) unless include_glyphs
 
         warn&.puts(ExperimentalWarning)
-        version = VersionResolver.resolve(version_intent)
-        root = Pathname.new(output_root)
 
-        blocks = load_blocks(version, block_filter)
-        fetcher = build_fetcher(version, monolith_path, blocks)
-        specs = blocks.map { |block| spec_for(block, fetcher, force) }.compact
+        pipeline = Glyphs::Pipeline.new(
+          version: version,
+          block_filter: block_filter,
+          monolith_path: monolith_path,
+        )
+        specs = pipeline.build_specs(force: force)
 
-        writer = Glyphs::Writer.new(output_root: root,
-                                     parallel_workers: workers)
+        writer = Glyphs::Writer.new(
+          output_root: Pathname.new(output_root),
+          parallel_workers: workers,
+        )
         tally = writer.write_all(specs)
         tally.merge(version: version, block_count: specs.size)
       end
 
       private
 
-      def load_blocks(version, block_filter)
-        ucd_dir = Cache.ucd_dir(version)
-        path = ucd_dir.join("Blocks.txt")
-        return [] unless path.exist?
-
-        all = Parsers::Blocks.each_record(path).to_a
-        return all unless block_filter && !block_filter.empty?
-
-        filter_set = block_filter.to_set
-        all.select { |block| filter_set.include?(block.id) }
-      end
-
-      def build_fetcher(version, monolith_path, blocks)
-        monolith = Pathname.new(monolith_path)
-        monolith = monolith.exist? ? monolith : nil
-        Glyphs::PdfFetcher.new(
-          version,
-          monolith_path: monolith,
-          blocks: blocks,
-          page_map_cache: PageMapCache,
-        )
-      end
-
-      def spec_for(block, fetcher, force)
-        pdf_path = fetcher.fetch(block_first_cp: block.range_first, force: force)
-        return nil unless pdf_path
-
-        { block: block, pdf_path: pdf_path, page_map: page_map_for(block) }
-      end
-
-      # Heuristic page map: per-block PDFs are page 1 = title, page 2 =
-      # first chart page starting at the block's first codepoint. True for
-      # most BMP blocks; multi-page blocks (CJK) need a richer resolver.
-      # Mismatches yield placeholder SVGs only — never wrong glyphs.
-      def page_map_for(block)
-        { 2 => block.range_first }
-      end
-
       def workers
         Ucode.configuration.parallel_workers
       end
 
-      def skipped(version_intent)
-        version = begin
-          VersionResolver.resolve(version_intent)
-        rescue UnknownVersionError
-          version_intent
-        end
+      def skipped(version)
         {
           version: version,
           skipped: true,
@@ -133,4 +91,4 @@ module Ucode
       end
     end
   end
-end
+end

data/lib/ucode/commands/lookup.rb

@@ -5,42 +5,42 @@ require "pathname"
 require "ucode/cache"
 require "ucode/database"
 require "ucode/repo"
-require "ucode/version_resolver"
 
 module Ucode
   module Commands
     # `ucode lookup` — read-only lookups against the SQLite cache and
     # the output JSON tree. Three subactions: block, script, char.
+    #
+    # Takes a resolved version string; CLI callers resolve via
+    # {VersionResolver.resolve} once and thread it through. See
+    # Candidate 4 of the 2026-06-29 architecture review.
     class LookupCommand
       BlockResult = Struct.new(:codepoint, :block, keyword_init: true)
       ScriptResult = Struct.new(:codepoint, :script, keyword_init: true)
       CharResult = Struct.new(:codepoint, :block_id, :glyph_path, keyword_init: true)
       private_constant :BlockResult, :ScriptResult, :CharResult
 
-      # @param version_intent [nil, :default, :latest, String]
+      # @param version [String] resolved UCD version
       # @param codepoint [Integer]
       # @return [BlockResult]
-      def lookup_block(version_intent, codepoint:)
-        version = VersionResolver.resolve(version_intent)
+      def lookup_block(version, codepoint:)
         with_db(version) { |db| db.lookup_block(codepoint) }
           .then { |block| BlockResult.new(codepoint: codepoint, block: block) }
       end
 
-      # @param version_intent [nil, :default, :latest, String]
+      # @param version [String] resolved UCD version
       # @param codepoint [Integer]
       # @return [ScriptResult]
-      def lookup_script(version_intent, codepoint:)
-        version = VersionResolver.resolve(version_intent)
+      def lookup_script(version, codepoint:)
         with_db(version) { |db| db.lookup_script(codepoint) }
           .then { |script| ScriptResult.new(codepoint: codepoint, script: script) }
       end
 
-      # @param version_intent [nil, :default, :latest, String]
+      # @param version [String] resolved UCD version
       # @param codepoint [Integer]
       # @param output_root [String, Pathname]
       # @return [CharResult]
-      def lookup_char(version_intent, codepoint:, output_root:)
-        version = VersionResolver.resolve(version_intent)
+      def lookup_char(version, codepoint:, output_root:)
         block_id = with_db(version) { |db| db.lookup_block(codepoint) }
         glyph = block_id ? glyph_path(output_root, block_id, codepoint) : nil
         CharResult.new(codepoint: codepoint, block_id: block_id, glyph_path: glyph)
@@ -62,4 +62,4 @@ module Ucode
       end
     end
   end
-end
+end

data/lib/ucode/commands/parse.rb

@@ -6,19 +6,21 @@ require "ucode/cache"
 require "ucode/coordinator"
 require "ucode/parsers"
 require "ucode/repo"
-require "ucode/version_resolver"
 
 module Ucode
   module Commands
     # `ucode parse` — streams the Coordinator output into the on-disk
     # JSON tree at `output/`. Single pass: enrich + write per-cp JSON +
     # accumulate aggregates + final flush.
+    #
+    # Takes a resolved version string; CLI callers resolve via
+    # {VersionResolver.resolve} once and thread it through. See
+    # Candidate 4 of the 2026-06-29 architecture review.
     class ParseCommand
-      # @param version_intent [nil, :default, :latest, String]
+      # @param version [String] resolved UCD version
       # @param output_root [String, Pathname]
       # @return [Hash] { version:, codepoint_count: }
-      def call(version_intent, output_root:)
-        version = VersionResolver.resolve(version_intent)
+      def call(version, output_root:)
         root = Pathname.new(output_root)
         ucd_dir = Cache.ucd_dir(version)
         unihan_dir = Cache.unihan_dir(version)
@@ -59,4 +61,4 @@ module Ucode
       end
     end
   end
-end
+end

data/lib/ucode/commands/release.rb

@@ -7,7 +7,6 @@ require "ucode/audit"
 require "ucode/audit/library_auditor"
 require "ucode/audit/release"
 require "ucode/audit/emitter/paths"
-require "ucode/commands/audit/reference_builder"
 
 module Ucode
   module Commands