ace-design 0.2.0

data/lib/ace/design/organisms/adjuster.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+require "time"
+module Ace
+  module Design
+    module Organisms
+      class Adjuster
+        A = Molecules::Artifacts
+        C = Molecules::DesignContext
+        D = Molecules::ContextDocument
+        def initialize(config: Design.config, executor: Molecules::AgentExecutor.new, contexts: C.new)
+          @config, @executor, @contexts = config, executor, contexts
+        end
+        def adjust(surface: nil, kind: nil, profile: nil, prompt: nil, refresh: false, dry_run: false, propose: false, model: nil)
+          raise Error, "refresh does not accept --prompt" if prompt && refresh
+          raise Error, "Use --dry-run or --propose, not both" if dry_run && propose
+          surface, kind = Molecules::DesignSource.scope(surface: surface, kind: kind, profile: profile)
+          Atoms::Contracts.text(prompt, "adjust prompt") if prompt
+          timeout = Integer(@config.fetch("agent_timeout"))
+          raise Error, "agent timeout must be 1..3600 seconds" unless (1..3600).cover?(timeout)
+          original = @contexts.repository.read(readonly: dry_run)
+          targets = @contexts.targets(original, surface: surface, kind: kind, context: profile)
+          # Detect hand edits before any model call, including edits to stale generated documents.
+          targets.each { |id| @contexts.read_generated(original, id) if original.key?(C.file(id, "design.md")) }
+          proposed = original.dup
+          targets.each do |id|
+            key = C.file(id, "defaults.md")
+            proposed[key] = @contexts.default(id) if refresh || !proposed.key?(key)
+            proposed[C.file(id, "user.md")] ||= ""
+          end
+          target = profile || surface
+          if prompt
+            key = C.file(target, "user.md")
+            proposed[key] += "\n\n## Decision update #{Time.now.utc.iso8601}\n\n#{prompt}\n"
+          end
+          if dry_run
+            return {"status" => "planned", "contexts" => targets, "refresh" => refresh,
+              "requested_model" => model || @config.fetch("model"),
+              "next" => "Run without --dry-run, or use --propose for an unpublished model composition"}
+          end
+          run = allocate_run
+          warn "Design adjustment: #{run}"
+          report = {"status" => "preparing", "report_dir" => run, "contexts" => targets,
+            "refresh" => refresh, "propose" => propose, "requested_model" => model || @config.fetch("model")}
+          dirty = []
+          targets.each do |id|
+            parent = id.empty? ? nil : C.chain(id)[-2]
+            if parent && dirty.include?(parent)
+              dirty << id
+              next
+            end
+            begin
+              @contexts.resolve(proposed, id)
+            rescue Error
+              dirty << id
+            end
+          end
+          report["changed_contexts"] = dirty
+          inputs = dirty.map do |id|
+            parent_id = id.empty? ? nil : C.chain(id)[-2]
+            {"id" => id, "parent" => parent_id, "old_defaults" => original[C.file(id, "defaults.md")],
+              "parent_design" => parent_id && !dirty.include?(parent_id) ? proposed.fetch(C.file(parent_id, "design.md")) : nil,
+              "new_defaults" => proposed.fetch(C.file(id, "defaults.md")),
+              "user" => proposed.fetch(C.file(id, "user.md")), "previous_design" => original[C.file(id, "design.md")]}
+          end
+          A.json(File.join(run, "request.json"), {"contexts" => inputs})
+          if dirty.empty?
+            report["status"] = "unchanged"
+            return save_report(run, report)
+          end
+          workspace = File.join(run, "worker")
+          FileUtils.mkdir_p(workspace)
+          FileUtils.cp(File.join(run, "request.json"), workspace)
+          File.write(File.join(workspace, "system.md"), Molecules::AdjustPrompts::SYSTEM)
+          File.write(File.join(workspace, "prompt.md"), Molecules::AdjustPrompts::PROMPT)
+          @executor.validate_model(report.fetch("requested_model"))
+          started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          result = @executor.call(model: report.fetch("requested_model"), prompt: Molecules::AdjustPrompts::PROMPT,
+            system: Molecules::AdjustPrompts::SYSTEM, workspace: workspace, timeout: timeout)
+          report.merge!(result.slice("execution", "model", "provider", "usage", "metadata"))
+          A.json(File.join(workspace, "execution.json"), result)
+          raise Error, "Adjustment agent did not complete successfully" unless result.dig("execution", "status") == "succeeded"
+          unless !File.symlink?(File.join(workspace, "request.json")) && File.binread(File.join(workspace, "request.json")) == File.binread(File.join(run, "request.json"))
+            raise Error, "Adjustment agent modified its inputs"
+          end
+          output_path = File.join(workspace, "result.json")
+          raise Error, "Adjustment result missing or symlink" unless File.file?(output_path) && !File.symlink?(output_path)
+          output = validate_output(A.object(output_path), dirty)
+          report["conflicts"] = output.fetch("conflicts")
+          report["summary"] = output.fetch("contexts").transform_values { |node| node.reject { |key, _| key == "design" } }
+          if report["conflicts"].empty?
+            dirty.each do |id|
+              parent = id.empty? ? nil : proposed.fetch(C.file(C.chain(id)[-2], "design.md"))
+              decisions = C.chain(id).to_h { |ancestor| [ancestor, proposed.fetch(C.file(ancestor, "user.md"))] }
+              proposed[C.file(id, "design.md")] = D.effective(id: id, defaults: proposed.fetch(C.file(id, "defaults.md")),
+                user: proposed.fetch(C.file(id, "user.md")), parent: parent,
+                body: output.fetch("contexts").fetch(id).fetch("design"), decisions: decisions)
+            end
+            targets.each { |id| @contexts.resolve(proposed, id) }
+            candidate = write_candidate(run, proposed)
+            write_diff(run, original, proposed)
+            report["stale_contexts"] = @contexts.ids(proposed).reject do |id|
+              @contexts.resolve(proposed, id)
+              true
+            rescue Error
+              false
+            end
+            if propose
+              report["status"] = "proposed"
+            else
+              report["status"] = "proposed"
+              save_report(run, report)
+              @contexts.repository.publish(candidate: candidate, original: original, run: run)
+              report["status"] = "published"
+              begin
+                return save_report(run, report)
+              rescue StandardError => error
+                warn "Contexts published, but report update failed: #{error.message}"
+                return report
+              end
+            end
+          else
+            report["status"] = "conflict"
+          end
+          save_report(run, report)
+        rescue StandardError, Interrupt => error
+          if report && run
+            report["status"] = error.is_a?(Interrupt) ? "interrupted" : "failed"
+            report["error"] = error.message
+            begin
+              save_report(run, report)
+            rescue StandardError
+              # Keep the original failure authoritative when diagnostics cannot be saved.
+              nil
+            end
+          end
+          raise
+        ensure
+          if report && started
+            report["duration"] = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started).round(3)
+            begin
+              A.json(File.join(run, "report.json"), report)
+            rescue StandardError => error
+              warn "Could not persist adjustment timing: #{error.message}"
+            end
+          end
+        end
+        private
+        def allocate_run
+          base = @contexts.repository.runs
+          @contexts.repository.safe_path!(base)
+          FileUtils.mkdir_p(base)
+          100.times do
+            directory = File.join(base, Ace::B36ts.encode(Time.now, format: :ms))
+            begin
+              Dir.mkdir(directory)
+              return directory
+            rescue Errno::EEXIST
+              sleep 0.002
+            end
+          end
+          raise Error, "Could not allocate adjustment report"
+        end
+        def validate_output(output, targets)
+          nodes = output["contexts"]
+          conflicts = output["conflicts"]
+          unless output.keys.sort == %w[conflicts contexts] && nodes.is_a?(Hash) && nodes.keys.sort == targets.sort &&
+              conflicts.is_a?(Array) && conflicts.all? { |item| item.is_a?(String) && !item.strip.empty? }
+            raise Error, "Adjustment result must contain every context and a conflicts array"
+          end
+          nodes.each do |id, node|
+            unless node.is_a?(Hash) && node.keys.sort == %w[added_rules design omitted_defaults preserved_exceptions]
+              raise Error, "Invalid adjustment result for #{id}"
+            end
+            Atoms::Contracts.text(node["design"], "design for #{id}")
+            %w[added_rules preserved_exceptions omitted_defaults].each do |field|
+              unless node[field].is_a?(Array) && node[field].all? { |item| item.is_a?(String) }
+                raise Error, "Adjustment #{field} must be a text array"
+              end
+            end
+          end
+          output
+        end
+        def write_candidate(run, files)
+          candidate = File.join(run, "candidate")
+          files.each do |name, content|
+            target = File.join(candidate, name)
+            FileUtils.mkdir_p(File.dirname(target))
+            File.binwrite(target, content)
+          end
+          candidate
+        end
+        def write_diff(run, before, after)
+          text = (before.keys | after.keys).sort.filter_map do |name|
+            next if before[name] == after[name]
+            old = before.fetch(name, "").lines
+            new = after.fetch(name, "").lines
+            "--- #{name}\n+++ #{name}\n@@ -1,#{old.size} +1,#{new.size} @@\n" +
+              old.map { |line| "-#{line.chomp}\n" }.join + new.map { |line| "+#{line.chomp}\n" }.join
+          end.join("\n")
+          File.write(File.join(run, "changes.diff"), text)
+        end
+        def save_report(run, report)
+          A.json(File.join(run, "report.json"), report)
+          File.write(File.join(run, "report.md"), "# Design adjustment: #{report.fetch('status')}\n\n" +
+            "```json\n#{JSON.pretty_generate(report)}\n```\n\nSee changes.diff and worker/result.json when present.\n")
+          report
+        end
+      end
+    end
+  end
+end

data/lib/ace/design/organisms/design_run.rb

@@ -0,0 +1,394 @@
+# frozen_string_literal: true
+require "fileutils"
+require "securerandom"
+require "digest"
+require "time"
+module Ace
+  module Design
+    module Organisms
+      class DesignRun
+        A = Molecules::Artifacts
+        def initialize(root, executor: Molecules::AgentExecutor.new)
+          @root = File.realpath(root)
+          @executor = executor
+          @mutex = Mutex.new
+          reload
+        end
+        def status
+          state = A.object(path("run.json"))
+          state.merge("id" => File.basename(@root), "next" => "ace-design preview #{@root}", "session" => @root, "gallery" => File.file?(path("gallery.html")) ? path("gallery.html") : nil)
+        end
+        def resume
+          locked do
+            verify_inputs!
+            verify_published!
+            unless @state.fetch("preparation")["status"] == "succeeded"
+              prepare
+            end
+            if @state.fetch("preparation")["status"] == "succeeded"
+              pending = @preset.fetch("variants").reject { |s| @state.fetch("workers").fetch(s.fetch("id"))["status"] == "succeeded" }
+              Molecules::Session.new(@root).write_gallery
+              execute_slots(pending)
+            end
+            finish
+          end
+        end
+        def revise(variant:, prompt:)
+          Atoms::Contracts.text(prompt, "feedback")
+          locked do
+            verify_inputs!
+            verify_published!
+            slot = @preset.fetch("variants").find { |s| s.fetch("id") == variant }
+            raise Error, "Unknown variant: #{variant}" unless slot
+            raise Error, "Variant #{variant} has no published mockup" unless File.directory?(path("variants/#{variant}"))
+            @state["status"] = "running"
+            save
+            execute_slot(slot, feedback: prompt)
+            finish
+          end
+        end
+        def select(variant:, decisions:)
+          locked do
+            verify_inputs!
+            verify_published!
+            session = Molecules::Session.new(@root)
+            raise Error, "Select an available variant" unless session.variants.include?(variant)
+            unless decisions.is_a?(Array) && !decisions.empty? && decisions.all? { |d| d.is_a?(String) && !d.strip.empty? }
+              raise Error, "Provide at least one nonempty --decision"
+            end
+            selection = {"surface" => @metadata.fetch("surface"), "variant" => variant,
+              "fixtures_sha256" => Digest::SHA256.file(path("fixtures.json")).hexdigest,
+              "variant_sha256" => A.digest(path("variants/#{variant}")), "decisions" => decisions}
+            A.json(path("selection.json"), selection)
+            session.validate_selection
+            selection
+          end
+        end
+        private
+        def path(relative)
+          File.join(@root, relative)
+        end
+        def reload
+          @metadata = A.object(path("session.json"))
+          @preset = A.object(path("resolved.json"))
+          @state = A.object(path("run.json"))
+          unless %w[view component].include?(@metadata["kind"]) && @state.dig("inputs", "design.md")
+            raise Error, "Session lacks task kind or frozen design assumptions; create a new session"
+          end
+        end
+        def locked
+          raise Error, "Refusing symlink lock" if File.symlink?(path(".run.lock"))
+          File.open(path(".run.lock"), File::RDWR | File::CREAT, 0o600) do |lock|
+            raise Error, "Session already has an active operation" unless lock.flock(File::LOCK_EX | File::LOCK_NB)
+            reload
+            Thread.handle_interrupt(Interrupt => :never) do
+              recover_publication
+              yield
+            end
+          rescue Interrupt => error
+            @state["status"] = "interrupted"
+            save_preserving_failure(error)
+            raise
+          ensure
+            lock.flock(File::LOCK_UN)
+          end
+        end
+        def save
+          A.json(path("run.json"), @state)
+        end
+        # A diagnostic write must not replace the error that triggered it.
+        def save_preserving_failure(failure)
+          save
+        rescue StandardError => persistence_error
+          raise unless failure
+          warn "Could not persist design state: #{persistence_error.message}"
+          raise failure
+        end
+        def verify_inputs!
+          @state.fetch("inputs").each do |file, digest|
+            target = path(file)
+            unless File.file?(target) && !File.symlink?(target) && Digest::SHA256.file(target).hexdigest == digest
+              raise Error, "Shared input changed: #{file}; create a new session"
+            end
+          end
+        end
+        def verify_published!
+          @state.fetch("workers").each do |id, worker|
+            next unless worker["published_sha256"]
+            unless A.digest(path("variants/#{id}")) == worker["published_sha256"]
+              raise Error, "Published variant #{id} changed outside the runner; create a new session"
+            end
+          end
+        end
+        def workspace(id)
+          directory = path("work/#{id}/#{SecureRandom.hex(8)}")
+          FileUtils.mkdir_p(directory)
+          %w[brief.md context.md design.md fixtures.json].each do |name|
+            FileUtils.cp(path(name), File.join(directory, name)) if File.file?(path(name))
+          end
+          %w[source skills].each do |name|
+            FileUtils.cp_r(path(name), File.join(directory, name)) if File.directory?(path(name))
+          end
+          FileUtils.cp(path("source-analysis.md"), directory) if File.file?(path("source-analysis.md"))
+          directory
+        end
+        def invoke(directory, prompt, model:, execution_preset: nil, system: Molecules::DesignPrompts::SYSTEM)
+          same_project = begin
+            File.realpath(Dir.pwd) == File.realpath(@state.fetch("project_root"))
+          rescue SystemCallError
+            false
+          end
+          unless same_project
+            raise Error, "Run model operations from #{@state.fetch('project_root')} to retain the project's ace-llm policies"
+          end
+          File.write(File.join(directory, "system.md"), system)
+          File.write(File.join(directory, "prompt.md"), prompt)
+          @executor.validate_model(model, execution_preset: execution_preset)
+          result = Thread.handle_interrupt(Interrupt => :immediate) do
+            @executor.call(model: model, prompt: prompt, system: system,
+              workspace: directory, timeout: @preset.fetch("timeout"), execution_preset: execution_preset)
+          end
+          A.json(File.join(directory, "result.json"), result)
+          unless result.dig("execution", "status") == "succeeded"
+            raise Error, "Coding agent did not complete successfully; see #{directory}/result.json"
+          end
+          result
+        end
+        def check_copies(directory, names)
+          names += @state.fetch("inputs").keys.select { |name| name.start_with?("source/", "skills/") || name == "source-analysis.md" }
+          names.each do |name|
+            target = File.join(directory, name)
+            unless File.file?(target) && !File.symlink?(target) && File.binread(target) == File.binread(path(name))
+              raise Error, "Worker modified shared input #{name}"
+            end
+          end
+        end
+        def prepare
+          started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          directory = workspace("preparation")
+          attempt = {"status" => "running", "workspace" => directory, "requested_model" => @preset.fetch("preparation_model")}
+          @state["preparation_attempts"] ||= []
+          @state["preparation_attempts"] << attempt
+          @state["preparation"] = attempt
+          @state["status"] = "running"
+          save
+          prompt = Molecules::DesignPrompts.preparation(@metadata, @preset, supplied: @state["supplied_fixtures"])
+          A.write(path("prompts/preparation.md"), prompt)
+          result = invoke(directory, prompt, model: @preset.fetch("preparation_model"))
+          attempt.merge!(evidence(result))
+          check_copies(directory, %w[brief.md context.md design.md] + (@state["supplied_fixtures"] ? ["fixtures.json"] : []))
+          fixture = File.join(directory, "fixtures.json")
+          directions_path = File.join(directory, "directions.json")
+          [fixture, directions_path].each { |f| raise Error, "Preparation output missing or symlink: #{f}" unless File.file?(f) && !File.symlink?(f) }
+          A.object(fixture)
+          directions = A.object(directions_path)
+          ids = @metadata.fetch("variants")
+          unless directions.keys.sort == ids.sort && directions.values.all? { |v| v.is_a?(String) && !v.strip.empty? }
+            raise Error, "directions.json must map every declared variant ID to a nonempty brief"
+          end
+          if @metadata["source"]
+            analysis = File.join(directory, "source-analysis.md")
+            raise Error, "Preparation must write source-analysis.md" unless File.file?(analysis) && !File.symlink?(analysis) && !File.read(analysis).strip.empty?
+            A.write(path("source-analysis.md"), File.binread(analysis))
+            @state["inputs"]["source-analysis.md"] = Digest::SHA256.file(analysis).hexdigest
+          end
+          verify_inputs!
+          A.write(path("fixtures.json"), File.binread(fixture)) unless @state["supplied_fixtures"]
+          A.json(path("directions.json"), directions)
+          %w[fixtures.json directions.json].each { |f| @state["inputs"][f] = Digest::SHA256.file(path(f)).hexdigest }
+          attempt["status"] = "succeeded"
+          @preset.fetch("variants").each do |slot|
+            File.write(path("prompts/#{slot.fetch('id')}.md"), Molecules::DesignPrompts.variant(@metadata, slot, direction: directions.fetch(slot.fetch("id"))))
+          end
+        rescue StandardError => e
+          failure = e
+          raise unless attempt
+          attempt.merge!("status" => "failed", "error" => e.message)
+        rescue Interrupt => error
+          failure = error
+          attempt["status"] = "interrupted" if attempt
+          raise
+        ensure
+          if attempt && started
+            attempt["duration"] = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started).round(3)
+            save_preserving_failure(failure)
+          end
+        end
+        def execute_slots(slots)
+          failure = nil
+          threads = []
+          begin
+            @state["status"] = "running"
+            save
+            queue = Queue.new
+            slots.each { |slot| queue << slot }
+            [@preset.fetch("concurrency"), slots.size].min.times do
+              threads << Thread.new do
+                Thread.current.report_on_exception = false
+                loop do
+                  slot = begin
+                    queue.pop(true)
+                  rescue ThreadError
+                    break
+                  end
+                  execute_slot(slot)
+                end
+              end
+            end
+            Thread.handle_interrupt(Interrupt => :immediate) { threads.each(&:value) }
+          rescue Interrupt, StandardError => error
+            failure = error
+          ensure
+            # Interrupt the provider capture boundary, which owns descendant cleanup.
+            threads.each { |t| t.raise(Interrupt) if t.alive? }
+            threads.each do |thread|
+              begin
+                thread.join
+              rescue Interrupt, StandardError => error
+                # Join every sibling even if recording a failure also failed.
+                failure ||= error
+              end
+            end
+          end
+          raise failure if failure
+        end
+        def execute_slot(slot, feedback: nil)
+          # Cancellation is delivered at the provider boundary. File publication
+          # and its journal must finish atomically with respect to Ruby interrupts.
+          Thread.handle_interrupt(Interrupt => :never) { execute_slot_work(slot, feedback: feedback) }
+        end
+        def execute_slot_work(slot, feedback: nil)
+          id = slot.fetch("id")
+          worker = @state.fetch("workers").fetch(id)
+          # A failed/interrupted revision is resumed with the same feedback, not a fresh generation.
+          feedback ||= worker["pending_feedback"]
+          directory = workspace(id)
+          output = File.join(directory, "variants", id)
+          FileUtils.mkdir_p(File.dirname(output))
+          FileUtils.cp_r(path("variants/#{id}"), output) if feedback
+          FileUtils.mkdir_p(output)
+          directions = A.object(path("directions.json"))
+          prompt = Molecules::DesignPrompts.variant(@metadata, slot, direction: directions.fetch(id), feedback: feedback)
+          attempt = {"status" => "running", "workspace" => directory, "requested_model" => slot.fetch("model"),
+            "feedback" => feedback, "started_at" => Time.now.utc.iso8601}
+          started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          @mutex.synchronize do
+            worker["status"] = "running"
+            worker["pending_feedback"] = feedback
+            worker.fetch("attempts") << attempt
+            save
+          end
+          warn "#{id}: generating with #{slot.fetch('model')}"
+          result = invoke(directory, prompt, model: slot.fetch("model"), execution_preset: slot["execution_preset"],
+            system: slot.fetch("process", "ace") == "ace" ? Molecules::DesignPrompts::SYSTEM : Molecules::DesignPrompts::EXTERNAL_SYSTEM)
+          @mutex.synchronize { attempt.merge!(evidence(result)); save }
+          check_copies(directory, %w[brief.md context.md design.md fixtures.json])
+          digest = A.validate_variant(output, types: slot.fetch("artifact_types", ["html"]), shared_reference: slot.fetch("process", "ace") == "ace")
+          @mutex.synchronize do
+            verify_inputs!
+            publish(id, output, digest)
+            worker.merge!("status" => "succeeded", "published_sha256" => digest)
+            worker.delete("pending_feedback")
+            attempt.merge!(evidence(result)).merge!("status" => "succeeded")
+            if feedback
+              File.open(path("feedback.md"), "a") do |file|
+                file.puts "\n## #{Time.now.utc.iso8601} — #{id}\n\n#{feedback}\n\nPublished: #{digest}\nAttempt: #{directory}\n"
+              end
+            end
+            save
+            @state.delete("publication")
+            save
+            Molecules::Session.new(@root).write_gallery
+          end
+          warn "#{id}: ready"
+        rescue StandardError => e
+          failure = e
+          warn "#{id}: failed — #{e.message}"
+          @mutex.synchronize do
+            recover_publication
+            worker["status"] = "failed"
+            attempt&.merge!("status" => "failed", "error" => e.message)
+            save_preserving_failure(e)
+          end
+        rescue Interrupt => error
+          failure = error
+          @mutex.synchronize do
+            worker["status"] = "interrupted"
+            attempt&.merge!("status" => "interrupted")
+            save_preserving_failure(error)
+          end
+          raise
+        ensure
+          if attempt
+            @mutex.synchronize do
+              attempt["duration"] = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started).round(3)
+              save_preserving_failure(failure)
+            end
+          end
+        end
+        def publish(id, output, digest)
+          target = path("variants/#{id}")
+          backup = path("history/#{id}/#{SecureRandom.hex(8)}")
+          FileUtils.mkdir_p(File.dirname(target))
+          FileUtils.mkdir_p(File.dirname(backup))
+          previous = @state.fetch("workers").fetch(id)["published_sha256"]
+          selection = path("selection.json")
+          selection_backup = if File.exist?(selection) && A.object(selection)["variant"] == id
+            path("history/selections/#{SecureRandom.hex(8)}.json")
+          end
+          @state["publication"] = {"id" => id, "backup" => backup, "previous" => previous,
+            "digest" => digest, "selection_backup" => selection_backup}
+          save
+          File.rename(target, backup) if File.exist?(target)
+          File.rename(output, target)
+          if selection_backup
+            FileUtils.mkdir_p(File.dirname(selection_backup))
+            File.rename(selection, selection_backup)
+          end
+        end
+        def recover_publication
+          publication = @state["publication"]
+          return unless publication
+          id = publication.fetch("id")
+          target = path("variants/#{id}")
+          worker = @state.fetch("workers").fetch(id)
+          # A saved success is committed even if the process stopped before clearing the journal.
+          if worker["status"] == "succeeded" && worker["published_sha256"] == publication["digest"] &&
+              File.directory?(target) && A.digest(target) == publication["digest"]
+            @state.delete("publication")
+            save
+            return
+          end
+          if File.directory?(publication.fetch("backup"))
+            FileUtils.rm_rf(target)
+            File.rename(publication.fetch("backup"), target)
+          elsif !publication["previous"]
+            FileUtils.rm_rf(target)
+          end
+          if publication["selection_backup"] && File.file?(publication["selection_backup"])
+            File.rename(publication["selection_backup"], path("selection.json"))
+          end
+          worker["status"] = "interrupted"
+          worker["published_sha256"] = publication["previous"]
+          @state.delete("publication")
+          save
+        end
+        def evidence(result)
+          result.slice("execution", "model", "provider", "usage", "metadata")
+        end
+        def finish
+          @state["status"] = if @state["preparation"]["status"] != "succeeded"
+            "failed"
+          elsif @state.fetch("workers").values.all? { |w| w["status"] == "succeeded" }
+            "succeeded"
+          else
+            "incomplete"
+          end
+          save
+          Molecules::Session.new(@root).write_gallery if File.file?(path("directions.json"))
+          status
+        end
+      end
+    end
+  end
+end