ace-design 0.2.0

data/lib/ace/design/molecules/design_source.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+require "uri"
+module Ace
+  module Design
+    module Molecules
+      # Resolves provenance without fetching during dry-run; captures once before preparation.
+      class DesignSource
+        attr_reader :info
+        def initialize(reference, config: Design.config)
+          @config = config
+          @info = if reference.nil?
+            nil
+          elsif reference.start_with?("session:")
+            match = /\Asession:([0-9a-z]+)\/([a-z][a-z0-9_-]{0,31})\z/.match(reference)
+            raise Error, "Expected session:TOKEN/VARIANT" unless match
+            root = File.expand_path(File.join(config.fetch("run_root"), match[1]))
+            session = Session.new(root)
+            raise Error, "Source variant is not available" unless session.variants.include?(match[2])
+            %w[fixtures.json design.md brief.md].each do |name|
+              unless File.file?(File.join(root, name)) && File.readable?(File.join(root, name))
+                raise Error, "Source session #{match[1]} is missing readable #{name}; create a new session with complete shared inputs"
+              end
+            end
+            Artifacts.files(File.join(root, "variants", match[2]))
+            {"type" => "session", "reference" => reference, "root" => root, "variant" => match[2],
+             "surface" => session.metadata.fetch("surface"), "kind" => session.metadata.fetch("kind")}
+          elsif reference.match?(/\Ahttps?:\/\//)
+            uri = URI.parse(reference)
+            raise Error, "Source URL requires a host and no credentials" if !uri.host || uri.userinfo
+            {"type" => "url", "reference" => reference}
+          else
+            file = File.realpath(reference)
+            raise Error, "Source must be a PNG, JPEG, WebP or GIF file" unless File.file?(file) && file.match?(/\.(png|jpe?g|webp|gif)\z/i)
+            {"type" => "image", "reference" => file}
+          end
+        rescue SystemCallError, URI::InvalidURIError => e
+          raise Error, "Invalid design source: #{e.message}"
+        end
+        def self.scope(surface:, kind:, profile: nil, source: nil)
+          expected = profile ? profile.split("/").first(2) : [source&.dig("surface"), source&.dig("kind")]
+          expected[1] = nil unless %w[view component].include?(expected[1])
+          [[surface, expected[0], "surface"], [kind, expected[1], "kind"]].each do |explicit, inherited, field|
+            raise Error, "Conflicting #{field}: #{explicit} versus #{inherited}" if explicit && inherited && explicit != inherited
+          end
+          result = [surface || expected[0], kind || expected[1] || "view"]
+          Atoms::Contracts.surface(result[0])
+          Atoms::Contracts.kind(result[1])
+          if source && source["surface"] && result != source.values_at("surface", "kind")
+            raise Error, "Source session scope conflicts with the selected profile/task"
+          end
+          result
+        end
+        def capture_url(url, target)
+          runtime = Runtime.new(@config)
+          result = runtime.capture(runtime.node, runtime.script("source.mjs"), runtime.directory, url, target, timeout: 90)
+          raise Error, "Source capture failed: #{result['stderr']}" unless result["exit_code"] == 0
+        end
+        def requirements
+          remote = info && (info["type"] == "url" || (info["type"] == "session" &&
+            Artifacts.descriptor(File.join(info.fetch("root"), "variants", info.fetch("variant")))["type"] == "url"))
+          return [] unless remote
+          [{"name" => "Source capture: configured Node, Playwright and Chromium", "status" => "agent_check",
+            "check" => "ace-design doctor", "node" => @config.fetch("node"), "runtime_dir" => @config.fetch("runtime_dir")}]
+        end
+        def snapshot(root)
+          return unless info
+          target = File.join(root, "source")
+          FileUtils.mkdir_p(target)
+          case info.fetch("type")
+          when "image"
+            FileUtils.cp(info.fetch("reference"), File.join(target, "mockup#{File.extname(info.fetch('reference')).downcase}"))
+          when "url"
+            capture_url(info.fetch("reference"), target)
+          when "session"
+            source = File.join(info.fetch("root"), "variants", info.fetch("variant"))
+            Artifacts.files(source)
+            FileUtils.cp_r(source, File.join(target, "variant"))
+            artifact = Artifacts.descriptor(source)
+            capture_url(artifact.fetch("entry"), target) if artifact["type"] == "url"
+            %w[fixtures.json design.md brief.md].each do |name|
+              FileUtils.cp(File.join(info.fetch("root"), name), File.join(target, name))
+            end
+          end
+          Artifacts.json(File.join(target, "source.json"), info)
+        end
+      end
+    end
+  end
+end

data/lib/ace/design/molecules/preset.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+module Ace
+  module Design
+    module Molecules
+      class Preset
+        ID = /\A[a-z][a-z0-9_-]{0,31}\z/
+        def self.integer(value, label)
+          unless value.is_a?(Integer) || (value.is_a?(String) && /\A[+-]?\d+\z/.match?(value))
+            raise Error, "#{label} must be an integer"
+          end
+          Integer(value)
+        end
+        def self.definition(name)
+          if File.file?(name)
+            data = YAML.safe_load_file(name)
+            raise Error, "Preset file must be an object" unless data.is_a?(Hash)
+            data
+          else
+            raise Error, "Invalid preset name" unless ID.match?(name)
+            data = Ace::Support::Config.create(gem_path: Design.gem_root)
+              .resolve_namespace("design", filename: "presets/#{name}").to_h
+            raise Error, "Unknown preset: #{name}" if data.empty?
+            data
+          end
+        end
+        def self.compatibility!(data, intent, surface, kind)
+          {"intents" => intent, "surfaces" => surface, "kinds" => kind}.each do |key, value|
+            next unless data[key]
+            allowed = {"intents" => %w[explore recreate reimagine], "surfaces" => %w[site app], "kinds" => %w[view component]}.fetch(key)
+            unless data[key].is_a?(Array) && !data[key].empty? && (data[key] - allowed).empty?
+              raise Error, "Preset #{key} must be a nonempty list drawn from #{allowed.join(', ')}"
+            end
+            raise Error, "Preset does not support #{key}: #{value}" unless data.fetch(key).include?(value)
+          end
+        end
+        def self.list
+          paths = Ace::Support::Config::Molecules::ConfigFinder.new(gem_path: Design.gem_root,
+            file_patterns: ["design/presets/*.yml", "design/presets/*.yaml"]).find_all
+          paths.map { |entry| File.basename(entry.path).sub(/\.ya?ml\z/, "") }
+            .uniq.sort.map { |name| definition(name).merge("name" => name) }
+        end
+        def self.load(name:, surface:, config: Design.config, model: nil, prompts: [], prompt_files: [], kind: "view", intent: "explore")
+          raise Error, "Invalid preset name" unless name.is_a?(String) && (ID.match?(name) || File.file?(name))
+          Atoms::Contracts.surface(surface)
+          Atoms::Contracts.kind(kind)
+          data = definition(name)
+          raise Error, "Unknown or empty design preset: #{name}" if data.empty?
+          raise Error, "Unsupported intent: #{intent}" unless %w[explore recreate reimagine].include?(intent)
+          compatibility!(data, intent, surface, kind)
+          slots = data["variants"] || Array.new(intent == "recreate" ? 1 : 3) { |i| {"id" => (97 + i).chr} }
+          unless slots.is_a?(Array) && !slots.empty? && slots.all? { |slot| slot.is_a?(Hash) }
+            raise Error, "Preset variants must be a nonempty list of objects"
+          end
+          slots = slots.map do |slot|
+            base = slot["preset"] ? definition(slot["preset"]) : data
+            raise Error, "A variant must reference a single-process preset, not a comparison" if slot["preset"] && base.key?("variants")
+            compatibility!(base, intent, surface, kind)
+            JSON.parse(JSON.generate(base.reject { |key, _| %w[variants concurrency].include?(key) }.merge(slot)))
+          end
+          unless slots.is_a?(Array) && !slots.empty? && slots.all? { |s| s.is_a?(Hash) && ID.match?(s["id"].to_s) }
+            raise Error, "Preset variants must be a nonempty list with safe lowercase IDs"
+          end
+          ids = slots.map { |s| s["id"] }
+          raise Error, "Variant IDs must be unique" unless ids.uniq == ids
+          extras = ids.to_h { |id| [id, []] }
+          [[prompts, false], [prompt_files, true]].each do |entries, file|
+            entries.each do |entry|
+              id, value = entry.split("=", 2)
+              raise Error, "Expected declared variant ID=VALUE: #{entry}" unless extras.key?(id) && value && !value.empty?
+              begin
+                extras[id] << (file ? File.read(value) : value)
+              rescue SystemCallError => e
+                raise Error, "Variant prompt file #{id}=#{value}: #{e.message}"
+              end
+            end
+          end
+          slots = slots.map do |slot|
+            focus = slot["focus"] || Array(data["directions"])[ids.index(slot["id"])]
+            focus = (kind == "component" && focus["component"]) || focus[surface] if focus.is_a?(Hash)
+            resolved = slot.merge("focus" => focus.to_s,
+              "model" => model || slot["model"] || data["model"] || config.fetch("model"),
+              "role" => slot.fetch("role", "Design a distinct, useful #{surface} mockup."),
+              "prompt" => ([slot["prompt"]] + extras.fetch(slot["id"])).compact.join("\n\n"))
+            %w[model role prompt focus].each do |key|
+              raise Error, "Variant #{slot['id']} #{key} must be text" unless resolved[key].is_a?(String)
+            end
+            Atoms::Contracts.text(resolved["model"], "variant model")
+            if resolved.key?("execution_preset")
+              Atoms::Contracts.text(resolved["execution_preset"], "execution preset")
+              raise Error, "Use model@preset or execution_preset, not both" if resolved["model"].include?("@")
+            end
+            resolved.delete("directions")
+            process = resolved.fetch("process", "ace")
+            raise Error, "Unknown preset process: #{process}" unless %w[ace external].include?(process)
+            if process == "external"
+              skills = resolved["skills"]
+              unless skills.is_a?(Array) && !skills.empty? && skills.all? { |skill| skill.is_a?(Hash) && skill["source"].is_a?(String) && skill["entry"].is_a?(String) && /\A[0-9a-f]{40}\z/.match?(skill["revision"].to_s) }
+                raise Error, "External preset requires pinned skill sources, entries and full revisions"
+              end
+              raise Error, "External preset needs exactly one lead skill" unless skills.count { |skill| skill.fetch("role", "lead") == "lead" } == 1
+            end
+            types = resolved.fetch("artifact_types", ["html"])
+            raise Error, "Invalid artifact_types" unless types.is_a?(Array) && !types.empty? && (types - %w[html image url]).empty?
+            resolved
+          end
+          concurrency = integer(data.fetch("concurrency", 3), "concurrency")
+          timeout = integer(data.fetch("timeout", config.fetch("agent_timeout")), "agent timeout")
+          raise Error, "concurrency must be positive" unless concurrency.positive?
+          raise Error, "agent timeout must be 1..3600 seconds" unless (1..3600).cover?(timeout)
+          {"name" => name, "variants" => slots, "concurrency" => [concurrency, slots.size].min,
+           "timeout" => timeout, "preparation_model" => model || data["preparation_model"] || data["model"] || config.fetch("model"),
+           "input" => Array(config["input"]) + Array(data["input"]), "intent" => intent,
+           "model_override" => model, "description" => data["description"]}
+        rescue SystemCallError, ArgumentError, TypeError => e
+          raise Error, "Invalid design preset: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/ace/design/molecules/runtime.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+require "open3"
+require "ace/core/atoms/process_terminator"
+module Ace
+  module Design
+    module Molecules
+      class Runtime
+        attr_reader :node, :directory
+        def initialize(config = Design.config)
+          @node = config.fetch("node")
+          @directory = File.expand_path(config.fetch("runtime_dir"))
+        end
+        def script(name)
+          File.join(Design.gem_root, "browser", name)
+        end
+        def capture(*argv, timeout:)
+          output = [String.new, String.new]
+          status = nil
+          Open3.popen3(*argv, pgroup: true) do |stdin, stdout, stderr, waiter|
+            stdin.close
+            readers = [stdout, stderr].each_with_index.map do |stream, i|
+              Thread.new do
+                loop do
+                  chunk = stream.readpartial(16_384)
+                  remaining = 262_144 - output[i].bytesize
+                  output[i] << chunk.byteslice(0, remaining) if remaining.positive?
+                end
+              rescue EOFError, IOError
+                nil
+              end
+            end
+            begin
+              unless waiter.join(timeout)
+                raise Error, "Command #{argv.first.inspect} timed out after #{timeout}s"
+              end
+              status = waiter.value
+            ensure
+              # A completed command can leave descendants holding its pipes. Their
+              # lifetime belongs to this capture, not to the caller's next command.
+              Thread.handle_interrupt(Interrupt => :never) do
+                Ace::Core::Atoms::ProcessTerminator.terminate(-waiter.pid)
+                deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 1
+                readers.each do |reader|
+                  remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+                  reader.join([remaining, 0].max)
+                end
+                [stdout, stderr].each { |io| io.close unless io.closed? }
+                readers.each { |reader| reader.kill if reader.alive? }
+                readers.each { |reader| reader.join(0.1) }
+              end
+            end
+          end
+          {"stdout" => output[0], "stderr" => output[1], "exit_code" => status.exitstatus}
+        rescue Errno::ENOENT
+          raise Error, "Command executable unavailable: #{argv.first}"
+        end
+        def doctor
+          result = capture(node, script("doctor.mjs"), directory, timeout: 15)
+          data = JSON.parse(result["stdout"])
+          data["runtime_dir"] = directory
+          data["manifest_dir"] = File.join(Design.gem_root, "browser")
+          data
+        rescue Error, JSON::ParserError => e
+          {"ready" => false, "error" => e.message, "runtime_dir" => directory,
+           "manifest_dir" => File.join(Design.gem_root, "browser")}
+        end
+        def preview(session, port: 0)
+          Kernel.exec(node, script("preview.mjs"), session.root, port.to_s)
+        rescue Errno::ENOENT
+          raise Error, "Preview requires Node 22+; configured executable: #{node}"
+        end
+      end
+    end
+  end
+end

data/lib/ace/design/molecules/session.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+require "digest"
+require "cgi"
+require "pathname"
+module Ace
+  module Design
+    module Molecules
+      class Session
+        attr_reader :root, :metadata, :fixtures
+        def initialize(path)
+          @root = File.realpath(path)
+          raise Error, "session must be a directory" unless File.directory?(root)
+          @metadata = read_json("session.json")
+          Atoms::Contracts.surface(metadata["surface"])
+          Atoms::Contracts.text(metadata["title"], "session title")
+          Atoms::Contracts.text(metadata["language"], "session language")
+          ids = metadata["variants"]
+          unless ids.is_a?(Array) && !ids.empty? && ids.uniq == ids &&
+              ids.all? { |id| id.is_a?(String) && Preset::ID.match?(id) }
+            raise Error, "session variants must be a nonempty list of unique safe IDs"
+          end
+          @fixtures = read_json("fixtures.json")
+          safe_file("brief.md")
+        rescue Errno::ENOENT, Errno::ENOTDIR => e
+          raise Error, "Session missing or incomplete: #{e.message}"
+        end
+        def safe_file(relative)
+          path = File.realpath(File.join(root, relative))
+          unless path.start_with?(root + File::SEPARATOR) && File.file?(path)
+            raise Error, "Session file escapes session root: #{relative}"
+          end
+          path
+        rescue Errno::ENOENT, Errno::ENOTDIR, Errno::ELOOP
+          raise Error, "Session file missing or broken symlink: #{relative}"
+        end
+        def read_json(relative)
+          Atoms::Contracts.object(JSON.parse(File.read(safe_file(relative))), relative)
+        rescue JSON::ParserError => e
+          raise Error, "Invalid #{relative}: #{e.message}"
+        end
+        def variants
+          metadata.fetch("variants").select do |id|
+            directory = File.join(root, "variants", id)
+            next false unless File.directory?(directory)
+            next false unless File.file?(File.join(directory, "direction.md"))
+            Artifacts.files(directory)
+            artifact = Artifacts.descriptor(directory)
+            safe_file("variants/#{id}/#{artifact.fetch('entry')}") unless artifact["type"] == "url"
+            safe_file("variants/#{id}/direction.md")
+            true
+          end
+        end
+        def validate(allow_empty: false)
+          available = variants
+          raise Error, "No ready variants: add variants/#{metadata.fetch("variants").first}/index.html and direction.md" if available.empty? && !allow_empty
+          selection = File.join(root, "selection.json")
+          validate_selection if File.exist?(selection) || File.symlink?(selection)
+          {"surface" => metadata["surface"], "variants" => available,
+           "missing_variants" => metadata.fetch("variants") - available, "selected" => File.exist?(selection)}
+        end
+        def validate_selection
+          chosen = read_json("selection.json")
+          unless chosen["surface"] == metadata["surface"] && variants.include?(chosen["variant"])
+            raise Error, "Selection must name an available variant and the session surface"
+          end
+          expected = Digest::SHA256.file(safe_file("fixtures.json")).hexdigest
+          raise Error, "Selection is stale: fixtures changed; confirm the direction again" unless chosen["fixtures_sha256"] == expected
+          if chosen["variant_sha256"] != Artifacts.digest(File.join(root, "variants", chosen["variant"]))
+            raise Error, "Selection is stale: variant changed; confirm the direction again"
+          end
+          decisions = chosen["decisions"]
+          unless decisions.is_a?(Array) && !decisions.empty? && decisions.all? { |s| s.is_a?(String) && !s.strip.empty? }
+            raise Error, "Selection decisions must be a nonempty list of text"
+          end
+          chosen
+        end
+        def write_gallery
+          result = validate(allow_empty: true)
+          path = File.join(root, "gallery.html")
+          raise Error, "Refusing symlink gallery.html" if File.symlink?(path)
+          cards = result["variants"].map do |id|
+            direction = CGI.escapeHTML(File.read(safe_file("variants/#{id}/direction.md")))
+            artifact = Artifacts.descriptor(File.join(root, "variants", id))
+            entry = artifact.fetch("entry")
+            url = CGI.escapeHTML(artifact["type"] == "url" ? entry : "variants/#{id}/#{entry}")
+            visual = case artifact["type"]
+            when "html" then %(<div class="frame"><iframe title="Direction #{id.upcase}" src="#{url}" sandbox="allow-scripts"></iframe></div>)
+            when "image" then %(<img src="#{url}" alt="Direction #{id.upcase}" style="max-width:100%">)
+            else %(<p>External result — open the provider preview. Remote content may change independently.</p>)
+            end
+            %(<section><h2>#{id.upcase} <a href="#{url}" target="_blank" rel="noopener noreferrer">Open #{id.upcase}</a></h2><p>#{artifact.fetch('type')}</p>#{visual}<details><summary>Direction notes</summary><p class="direction">#{direction}</p></details></section>)
+          end.join("\n")
+          title = CGI.escapeHTML(metadata["title"])
+          run = File.file?(File.join(root, "run.json")) ? read_json("run.json") : nil
+          missing = result["missing_variants"].empty? ? "" : "Still preparing: #{result['missing_variants'].join(', ')}"
+          if run && !result["missing_variants"].empty?
+            labels = result["missing_variants"].map { |id| "#{id} (#{run.dig('workers', id, 'status') || 'pending'})" }
+            missing = CGI.escapeHTML("Not ready: #{labels.join(', ')}")
+          end
+          refresh = run && run["status"] == "running" ? '<meta http-equiv="refresh" content="3">' : ""
+          html = <<~HTML
+            <!doctype html><html lang="en"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+            <title>#{title} — directions</title>#{refresh}<style>
+            *{box-sizing:border-box}body{margin:0;padding:24px;background:#f5f5f5;color:#171717;font:16px system-ui}
+            main{display:grid;grid-template-columns:repeat(auto-fit,minmax(min(100%,420px),1fr));gap:24px}
+            section{min-width:0}h2 a{font-size:16px;font-weight:normal;margin-left:12px}.frame{overflow:hidden;border:1px solid #ccc;background:white}iframe{display:block;width:1200px;height:900px;border:0;transform-origin:top left}details{margin-top:12px}
+            .direction{white-space:pre-wrap}a{color:#174dad}header{max-width:85ch;margin-bottom:24px}
+            </style><header><h1>#{title}</h1><p>Compare directions. Give feedback in chat or with ace-design revise using a variant ID. These are mockups.</p><p>#{missing}</p><label>Preview width <select id="width"><option value="1200">Desktop</option><option value="768">Tablet</option><option value="390">Mobile</option></select></label></header><main>#{cards}</main>
+            <script>
+            const select=document.getElementById('width');
+            function size(frame){const width=Number(select.value),scale=frame.clientWidth/width,iframe=frame.querySelector('iframe');iframe.style.width=width+'px';iframe.style.transform='scale('+scale+')';frame.style.height=(900*scale)+'px';}
+            const frames=[...document.querySelectorAll('.frame')];
+            const observer=new ResizeObserver(entries=>entries.forEach(entry=>size(entry.target)));
+            frames.forEach(frame=>observer.observe(frame));select.addEventListener('change',()=>frames.forEach(size));
+            </script></html>
+          HTML
+          File.write(path, html)
+          path
+        end
+      end
+    end
+  end
+end

data/lib/ace/design/molecules/skill_sources.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+require "tmpdir"
+module Ace
+  module Design
+    module Molecules
+      class SkillSources
+        def initialize(config = Design.config)
+          @config = config
+        end
+        def requirements(preset)
+          preset.fetch("variants").flat_map do |slot|
+            Array(slot["requirements"]).map do |requirement|
+              raise Error, "Requirements must be objects with a name" unless requirement.is_a?(Hash) && requirement["name"]
+              executable = requirement["executable"]
+              available = executable && ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).any? do |path|
+                file = File.join(path, executable)
+                File.file?(file) && File.executable?(file)
+              end
+              requirement.merge("variant" => slot.fetch("id"), "status" => executable ? (available ? "available" : "missing") : "agent_check")
+            end
+          end
+        end
+        def copy_tree(source, target, boundary, ancestors)
+          actual = File.realpath(source)
+          unless actual == boundary || actual.start_with?(boundary + "/")
+            raise Error, "Skill resource link escapes pinned repository: #{source}"
+          end
+          if File.directory?(actual)
+            raise Error, "Cyclic skill resource link: #{source}" if ancestors.include?(actual)
+            FileUtils.mkdir_p(target)
+            Dir.children(actual).each { |name| copy_tree(File.join(actual, name), File.join(target, name), boundary, ancestors + [actual]) }
+          elsif File.file?(actual)
+            FileUtils.cp(actual, target, preserve: true)
+          else
+            raise Error, "Unsupported skill resource: #{source}"
+          end
+        end
+        def snapshot(root, preset)
+          preset.fetch("variants").each do |slot|
+            Array(slot["skills"]).each_with_index do |spec, index|
+              revision = spec.fetch("revision")
+              raise Error, "Skill revision must be a full commit SHA" unless /\A[0-9a-f]{40}\z/.match?(revision)
+              target = File.join(root, "skills", slot.fetch("id"), index.to_s)
+              FileUtils.mkdir_p(target)
+              Dir.mktmpdir("ace-design-skill") do |checkout|
+                runtime = Runtime.new(@config)
+                commands = [["git", "init", "--quiet", checkout],
+                  ["git", "-C", checkout, "fetch", "--quiet", "--depth=1", spec.fetch("source"), revision],
+                  ["git", "-C", checkout, "checkout", "--quiet", "--detach", "FETCH_HEAD"]]
+                commands.each do |command|
+                  result = runtime.capture(*command, timeout: 120)
+                  raise Error, "Skill fetch failed: #{result['stderr']}" unless result["exit_code"] == 0
+                end
+                result = runtime.capture("git", "-C", checkout, "rev-parse", "HEAD", timeout: 10)
+                raise Error, "Skill revision mismatch" unless result["stdout"].strip == revision
+                FileUtils.rm_rf(File.join(checkout, ".git"))
+                copy_tree(checkout, target, File.realpath(checkout), [])
+              end
+              entry = spec.fetch("entry")
+              resolved = File.expand_path(entry, target)
+              unless resolved.start_with?(target + "/") && File.file?(resolved)
+                raise Error, "Missing skill entry: #{entry}"
+              end
+              spec["snapshot"] = "skills/#{slot.fetch('id')}/#{index}/#{entry}"
+            end
+          end
+        end
+      end
+    end
+  end
+end