@zalom/plastic 2.0.0-alpha.27 → 2.0.0-alpha.29

package/scripts/lib/project_config.rb

@@ -1,6 +1,7 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
+require_relative "store_layout"
 require "yaml"
 
 # ProjectConfig - reads a project's project.yml merged over the shipped defaults
@@ -18,7 +19,7 @@ module ProjectConfig
   }.freeze
 
   def read(slug)
-    path = File.join(Dir.home, ".plastic", "projects", slug, "project.yml")
+    path = File.join(Plastic::StoreLayout.project_root(File.join(Dir.home, ".plastic"), slug), "project.yml")
     config = if File.exist?(path)
                YAML.safe_load(File.read(path)) || {}
              else

package/scripts/lib/project_validator.rb

@@ -1,6 +1,7 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
+require_relative "store_layout"
 require "yaml"
 
 # ProjectValidator - the single source of truth for "is a project spawn
@@ -10,7 +11,7 @@ require "yaml"
 # missing the pieces a real project needs: project.yml, a root AGENTS.md.
 # The intent-26 spawn shipped exactly that shape and was caught only by a
 # much later, pull-only plastic-doctor sweep. This module lets
-# plastic-project-creating verify a spawn BEFORE announcing it as done,
+# `plastic project new` verify a spawn BEFORE announcing it as done,
 # mirroring how scripts/new-intent already runs IntentValidator before
 # announcing a new intent (validate-intent).
 #
@@ -52,7 +53,7 @@ module ProjectValidator
       errors << "registered project directory does not exist: #{project_path}"
     end
 
-    project_dir = File.join(plastic_home, "projects", slug)
+    project_dir = Plastic::StoreLayout.project_root(plastic_home, slug)
 
     # Invariant 3: project.yml exists AND parses as YAML.
     project_yml_path = File.join(project_dir, "project.yml")

package/scripts/lib/qmd_sync.rb

@@ -1,6 +1,7 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
+require_relative "store_layout"
 require "yaml"
 require "json"
 
@@ -50,7 +51,7 @@ module QmdSync
   # to the directory's parent name when no registry match exists.
   def collection_name(store_dir, plastic_home:)
     store_dir = File.expand_path(store_dir)
-    global_store = File.expand_path(File.join(plastic_home, "store"))
+    global_store = File.expand_path(Plastic::StoreLayout.global_store(plastic_home))
     return "plastic-global" if store_dir == global_store
 
     if File.basename(store_dir) == "roadmaps"
@@ -69,7 +70,7 @@ module QmdSync
   def enumerate_stores(plastic_home:)
     stores = [{
       collection: "plastic-global",
-      dir: File.expand_path(File.join(plastic_home, "store")),
+      dir: File.expand_path(Plastic::StoreLayout.global_store(plastic_home)),
     }]
 
     projects = load_projects(plastic_home)
@@ -80,7 +81,7 @@ module QmdSync
       # Project stores live under ~/.plastic/projects/<slug>/store as the mirror;
       # registry `path` is the project code dir, so the tactical store is the
       # plastic_home projects mirror.
-      mirror_store = File.expand_path(File.join(plastic_home, "projects", slug.to_s, "store"))
+      mirror_store = File.expand_path(File.join(Plastic::StoreLayout.project_root(plastic_home, slug.to_s), "store"))
       dir = Dir.exist?(mirror_store) ? mirror_store : project_store
       stores << { collection: "plastic-#{slug}", dir: dir }
     end
@@ -245,13 +246,13 @@ module QmdSync
       path = info.is_a?(Hash) ? info["path"] : nil
       next unless path
       project_root = File.expand_path(path)
-      mirror = File.expand_path(File.join(plastic_home, "projects", slug.to_s, "store"))
+      mirror = File.expand_path(File.join(Plastic::StoreLayout.project_root(plastic_home, slug.to_s), "store"))
       return slug.to_s if store_dir == File.join(project_root, "store") || store_dir == mirror
     end
     # Fallback: <...>/projects/<slug>/store -> slug, else parent dir name.
-    parts = store_dir.split(File::SEPARATOR)
-    idx = parts.rindex("projects")
-    return parts[idx + 1] if idx && parts[idx + 1] && parts[idx + 2] == "store"
+    slug = Plastic::StoreLayout.locate(store_dir).last
+    return slug unless slug == Plastic::StoreLayout::GLOBAL
+
     File.basename(File.dirname(store_dir))
   end
 end

package/scripts/lib/reference_archive.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "digest"
+require_relative "sqlite"
+
+module Plastic
+  module ReferenceArchive
+    NAME = "references.db"
+    SCHEMA = <<~SQL
+      CREATE TABLE IF NOT EXISTS sqlar(name TEXT PRIMARY KEY, mode INT, mtime INT, sz INT, data BLOB, intent_id TEXT, sha256 TEXT);
+    SQL
+    INTENT_ID = %r{/([^/-]+)--[^/]+/}
+    SKIPPED = %r{(\A|/)(\.git|\.tmp)/|\.DS_Store\z|\.lock\z}
+
+    def self.path(home)
+      File.join(home, NAME)
+    end
+
+    def self.files(home)
+      Dir.glob("{store,projects,stores}/**/*", File::FNM_DOTMATCH, base: home)
+        .select { |file| File.file?(File.join(home, file)) && File.extname(file) != ".md" && !file.match?(SKIPPED) }.sort
+    end
+
+    def self.build(home)
+      known = Sqlite.call(path(home), "#{SCHEMA}SELECT name, mtime, sz FROM sqlar;").to_h { |row| [row["name"], row.values_at("mtime", "sz")] }
+      changed = files(home).reject { |file| known[file] == stamp(File.join(home, file)) }
+      Sqlite.call(path(home), ["BEGIN;", *changed.map { |file| insert(home, file) }, "COMMIT;"].join("\n"))
+      changed.size
+    end
+
+    def self.stamp(source)
+      stat = File.stat(source)
+      [stat.mtime.to_i, stat.size]
+    end
+
+    def self.insert(home, file)
+      source = File.join(home, file)
+      stat = File.stat(source)
+      id = file[INTENT_ID, 1]
+      read = "readfile(#{Sqlite.quote(source)})"
+      "INSERT OR REPLACE INTO sqlar VALUES(#{Sqlite.quote(file)}, #{stat.mode}, #{stat.mtime.to_i}, length(#{read}), " \
+        "sqlar_compress(#{read}), #{id ? Sqlite.quote(id) : "NULL"}, #{Sqlite.quote(Digest::SHA256.file(source).hexdigest)});"
+    end
+  end
+end

package/scripts/lib/release_guard.rb

@@ -52,6 +52,8 @@ module ReleaseGuard
   # to the stable channel. Pure function, no ENV reads, shared by
   # scripts/release-check and the test suite so the channel rule has exactly
   # one implementation (intent 347).
+  CHANNELS = {"alpha" => "alpha", "beta" => "beta", "main" => "latest"}.freeze
+
   def self.dist_tag(version)
     suffix = version[/-(.+)\z/, 1]
     return "latest" if suffix.nil?

package/scripts/lib/report_screen.rb

@@ -8,6 +8,7 @@
 # out. Dependency injection for anything reaching outside the fixture: the
 # clock is passed as `now:`, git tag reading as `tag_reader:`, and the ANSI
 # renderer path as `renderer_path:` (D2).
+require_relative "store_layout"
 require "time"
 require "json"
 require "date"
@@ -805,14 +806,14 @@ def self.matching_action_heading(intent_dir, label)
   # (<home>/projects/<slug>/store/<id--slug>); nil otherwise (a global-store
   # intent, a project with no `flow:` key, or malformed YAML). Pure: no git,
   # no shell-out, just the one file this intent's own layout already reads.
-  PROJECT_LAYOUT_RE = %r{\A(.*)/projects/([^/]+)/store/[^/]+\z}.freeze
+  PROJECT_LAYOUT_RE = %r{\A(.*)/(?:projects|stores)/([^/]+)/store/[^/]+\z}.freeze
 
   def self.flow_base(intent_dir)
     m = intent_dir.to_s.match(PROJECT_LAYOUT_RE)
     return nil unless m
 
     home, slug = m[1], m[2]
-    path = File.join(home, "projects", slug, "project.yml")
+    path = File.join(Plastic::StoreLayout.project_root(home, slug), "project.yml")
     return nil unless File.exist?(path)
 
     require "yaml"
@@ -1480,7 +1481,7 @@ def self.matching_action_heading(intent_dir, label)
 
   # D5: "global" is <home> itself; any other slug is <home>/projects/<slug>.
   def self.store_for_slug(home, slug)
-    slug == "global" ? home : File.join(home, "projects", slug)
+    slug == "global" ? home : Plastic::StoreLayout.project_root(home, slug)
   end
 
   # D4: the newest valid day directory that is not in the future, when

package/scripts/lib/rlm/corpus.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RLM
+  class Corpus
+    def initialize(search)
+      @search = search
+    end
+
+    def call(terms, limit)
+      @search.call(terms, limit)
+    end
+  end
+end

package/scripts/lib/rlm/probe.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "corpus"
+
+module RLM
+  class Probe
+    STOP_WORDS = %w[a an and are as at be by do does for from how in is it of on or that the this to was what when where which who why with].freeze
+    DEFAULT_LIMIT = 10
+
+    def initialize(corpus, limit: DEFAULT_LIMIT)
+      @corpus = corpus
+      @limit = limit
+    end
+
+    def call(question)
+      hits = terms(question).flat_map { |term| @corpus.call([term], @limit) }
+      hits.group_by { |row| row["id"] }.values
+        .map { |rows| rows.first.merge("score" => rows.size) }
+        .sort_by.with_index { |row, index| [-row["score"], index] }
+        .first(@limit)
+    end
+
+    private
+
+    def terms(question)
+      question.downcase.scan(/[[:alnum:]]+/).uniq - STOP_WORDS
+    end
+  end
+end

package/scripts/lib/rlm/query.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "probe"
+
+module RLM
+  class Query
+    DEFAULT_LIMIT = 3
+
+    def initialize(probe, judge: nil, limit: DEFAULT_LIMIT)
+      @probe = probe
+      @judge = judge
+      @limit = limit
+    end
+
+    def call(question)
+      rows = @probe.call(question)
+      return rows unless @judge && rows.size > @limit
+
+      @judge.call(question, rows)
+    end
+  end
+end

package/scripts/lib/roadmap_queue.rb

@@ -411,8 +411,8 @@ class RoadmapQueue
   # --- scope + payload -----------------------------------------------------------
 
   def scope_label
-    m = @roadmaps_dir.to_s.match(%r{/projects/([^/]+)/roadmaps/?\z})
-    m ? "project:#{m[1]}" : "global"
+    m = @roadmaps_dir.to_s.match(%r{/(?:projects|stores)/([^/]+)/roadmaps/?\z})
+    (m && m[1] != "global") ? "project:#{m[1]}" : "global"
   end
 
   def payload(mode:, state:, roadmap:, frontier_wave:, dispatchable:, in_flight:, blocked:, tie:, tie_candidates:)

package/scripts/lib/roadmap_savepoint.rb

@@ -224,7 +224,7 @@ module RoadmapSavepoint
 
   # The tier root is the parent of `roadmaps/` (a live roadmap's grandparent, or, for one
   # already moved to `roadmaps/archived/`, its great-grandparent); INDEX.md is that root's
-  # sibling file, matching the layout `plastic-roadmap`'s file-format doc defines.
+  # sibling file, matching the layout docs/help/roadmaps.md defines.
   def index_path_for(roadmap_path)
     dir = File.dirname(roadmap_path)
     dir = File.dirname(dir) if File.basename(dir) == "archived"

package/scripts/lib/runner_absorb.rb

@@ -1,6 +1,7 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
+require_relative "store_layout"
 require "yaml"
 require "date"
 require "time"
@@ -59,7 +60,7 @@ module RunnerAbsorb
   # to plain strings), this cap is purely about line length.
   FINDING_CAP = 200
 
-  PROJECT_LAYOUT_RE = %r{\A(.*)/projects/([^/]+)/store/[^/]+\z}.freeze
+  PROJECT_LAYOUT_RE = %r{\A(.*)/(?:projects|stores)/([^/]+)/store/[^/]+\z}.freeze
 
   # absorb(context, node:, return_path:) -> a result hash describing the one
   # transition it wrote (or attempted to write). Never raises across its own
@@ -675,7 +676,7 @@ module RunnerAbsorb
     return nil unless m
 
     home, slug = m[1], m[2]
-    path = File.join(home, "projects", slug, "project.yml")
+    path = File.join(Plastic::StoreLayout.project_root(home, slug), "project.yml")
     return nil unless File.exist?(path)
 
     data = begin

package/scripts/lib/search_index.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "sqlite"
+
+module Plastic
+  module SearchIndex
+    NAME = "knowledge_graph.db"
+    SCHEMA = <<~SQL
+      CREATE TABLE doc(id INTEGER PRIMARY KEY, path TEXT, sz INT, data BLOB, hash TEXT);
+      CREATE VIEW doc_v AS SELECT id AS rowid, CAST(sqlar_uncompress(data, sz) AS TEXT) AS body FROM doc;
+      CREATE VIRTUAL TABLE ft USING fts5(body, content='doc_v', content_rowid='rowid');
+    SQL
+    FINISH = "INSERT INTO ft(ft) VALUES('rebuild'); INSERT INTO ft(ft) VALUES('optimize'); VACUUM;"
+
+    def self.path(home)
+      File.join(home, NAME)
+    end
+
+    def self.files(home)
+      Dir.glob("{store,projects,stores}/**/*.md", File::FNM_DOTMATCH, base: home).reject { |file| file.include?("/.git/") }.sort
+    end
+
+    def self.build(home)
+      files = files(home)
+      draft = "#{path(home)}.tmp"
+      FileUtils.rm_f(draft)
+      Sqlite.call(draft, [SCHEMA, "BEGIN;", *files.map { |file| insert(home, file) }, "COMMIT;", FINISH].join("\n"))
+      File.rename(draft, path(home))
+      files.size
+    ensure
+      FileUtils.rm_f(draft.to_s)
+    end
+
+    def self.insert(home, file)
+      source = quote(File.join(home, file))
+      "INSERT INTO doc(path, sz, data, hash) VALUES(#{quote(file)}, length(readfile(#{source})), " \
+        "sqlar_compress(readfile(#{source})), lower(hex(sha3(readfile(#{source}), 256))));"
+    end
+
+    def self.search(home, terms, limit:, prefix: "")
+      phrases = terms.map { |term| %("#{term.delete('"')}") }.join(" ")
+      Sqlite.call(path(home), <<~SQL, readonly: true)
+        SELECT doc.id AS id, doc.path AS path, snippet(ft, 0, '[', ']', ' ... ', 12) AS excerpt
+        FROM ft JOIN doc ON doc.id = ft.rowid
+        WHERE ft MATCH #{quote(phrases)} AND doc.path LIKE #{quote("#{prefix}%")}
+        ORDER BY rank LIMIT #{Integer(limit)};
+      SQL
+    end
+
+    def self.quote(text)
+      Sqlite.quote(text)
+    end
+  end
+end

package/scripts/lib/session_git.rb

@@ -1,6 +1,7 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
+require_relative "store_layout"
 require "yaml"
 require_relative "worktree"
 require_relative "scaffold_intent"
@@ -160,7 +161,7 @@ module SessionGit
   def read_project_flow(slug, plastic_home)
     return nil if slug == "global"
 
-    project_yml = File.join(plastic_home, "projects", slug, "project.yml")
+    project_yml = File.join(Plastic::StoreLayout.project_root(plastic_home, slug), "project.yml")
     return nil unless File.exist?(project_yml)
 
     data = begin
@@ -196,7 +197,7 @@ module SessionGit
     resolver ||= lambda { |short_session|
       ActiveDelivery.resolve_by_short_session(
         global_store: store,
-        project_roots: ActiveDelivery.project_roots(File.dirname(store)),
+        project_roots: ActiveDelivery.project_roots(Plastic::StoreLayout.locate(store).first),
         short_session: short_session
       )
     }
@@ -333,7 +334,7 @@ module SessionGit
   # a detached HEAD. Both modes now share exactly one check of each.
   def commit!(cwd:, summary:, day:, session:, plastic_home:, store: nil,
               runner: Worktree::ShellRunner.new, gh_runner: GhRunner.new)
-    effective_store = store || File.join(plastic_home, "store")
+    effective_store = store || Plastic::StoreLayout.global_store(plastic_home)
     repo = resolve_repo(cwd, runner: runner)
     return note("no repo") if repo.nil?
 

package/scripts/lib/sqlite.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+
+module Plastic
+  module Sqlite
+    Error = Class.new(StandardError)
+
+    def self.quote(text)
+      "'#{text.gsub("'", "''")}'"
+    end
+
+    def self.call(path, sql, readonly: false)
+      flags = readonly ? ["-readonly"] : []
+      out, err, status = Open3.capture3("sqlite3", "-json", *flags, path, stdin_data: sql)
+      raise Error, err.strip unless status.success?
+
+      out.strip.empty? ? [] : JSON.parse(out)
+    end
+  end
+end

package/scripts/lib/store_discovery.rb

@@ -1,6 +1,7 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
+require_relative "store_layout"
 require_relative "store_provisioning"
 
 # StoreDiscovery: the single source of truth for "what stores exist" (intent 189).
@@ -39,20 +40,20 @@ module StoreDiscovery
     stores = []
     missing = []
 
-    global_store = File.join(plastic_home, "store")
+    global_store = Plastic::StoreLayout.global_store(plastic_home)
     if File.directory?(global_store)
-      stores << { key: "global", slug: "global", root: plastic_home,
-                  store: global_store, index: File.join(plastic_home, "INDEX.md") }
+      global_root = Plastic::StoreLayout.global_root(plastic_home)
+      stores << { key: "global", slug: "global", root: global_root,
+                  store: global_store, index: File.join(global_root, "INDEX.md") }
     end
 
     registered = StoreProvisioning.load_projects(plastic_home) # { slug => info }, {} on error/absence
-    projects_root = File.join(plastic_home, "projects")
-    on_disk = File.directory?(projects_root) ? Dir.children(projects_root).reject { |e| e.start_with?(".") } : []
+    on_disk = Plastic::StoreLayout.project_slugs(plastic_home)
 
     all_slugs = (registered.keys + on_disk).uniq.sort
 
     all_slugs.each do |slug|
-      root = File.join(projects_root, slug)
+      root = Plastic::StoreLayout.project_root(plastic_home, slug)
       store_dir = File.join(root, "store")
       if File.directory?(store_dir)
         stores << { key: "project:#{slug}", slug: slug, root: root,

package/scripts/lib/store_layout.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Plastic
+  module StoreLayout
+    GLOBAL = "global"
+    PARENTS = %w[stores projects].freeze
+
+    module_function
+
+    def moved?(home)
+      File.directory?(File.join(home, "stores"))
+    end
+
+    def global_root(home)
+      moved?(home) ? File.join(home, "stores", GLOBAL) : home
+    end
+
+    def global_store(home)
+      File.join(global_root(home), "store")
+    end
+
+    def projects_root(home)
+      File.join(home, moved?(home) ? "stores" : "projects")
+    end
+
+    def project_root(home, slug)
+      File.join(projects_root(home), slug)
+    end
+
+    def root(home, slug)
+      (slug == GLOBAL) ? global_root(home) : project_root(home, slug)
+    end
+
+    def project_slugs(home)
+      parent = projects_root(home)
+      return [] unless File.directory?(parent)
+
+      Dir.children(parent).reject { |entry| entry.start_with?(".") || entry == GLOBAL }.sort
+    end
+
+    def locate(store)
+      root = File.dirname(File.expand_path(store))
+      parent = File.dirname(root)
+      return [root, GLOBAL] unless PARENTS.include?(File.basename(parent))
+
+      [File.dirname(parent), File.basename(root)]
+    end
+
+    def home_and_scope(store)
+      home, slug = locate(store)
+      [home, (slug == GLOBAL) ? GLOBAL : "project:#{slug}"]
+    end
+  end
+end

package/scripts/lib/store_provisioning.rb

@@ -1,6 +1,7 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
+require_relative "store_layout"
 require "fileutils"
 require "yaml"
 
@@ -63,7 +64,7 @@ module StoreProvisioning
       }
     end
 
-    project_dir = File.join(plastic_home, "projects", slug)
+    project_dir = Plastic::StoreLayout.project_root(plastic_home, slug)
     store_dir = File.join(project_dir, "store")
     FileUtils.mkdir_p(store_dir)
 

package/scripts/lib/store_sync.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "open3"
+require "tempfile"
+require_relative "search_index"
+require_relative "reference_archive"
+require_relative "work_graph"
+
+module Plastic
+  module StoreSync
+    INTENT_PATH = %r{\A(?:(?:projects|stores)/([^/]+)/)?store/([^/]+?)--}
+    ROW_HASH = "lower(hex(sha3(sqlar_uncompress(data, sz), 256)))"
+
+    def self.action(state)
+      file, row, recorded = state.values_at("file", "row", "hash")
+      return "write" if file.nil?
+      return if file == row
+      return "read" if row == recorded
+      return "write" if file == recorded
+
+      "conflict"
+    end
+
+    def self.plan(home)
+      known = states(home)
+      fresh = SearchIndex.files(home) - known.map { |state| state["path"] }
+      plan = known.map { |state| [action(state), state["path"]] } + fresh.map { |file| ["read", file] }
+      plan.select(&:first).sort_by(&:last)
+    end
+
+    def self.states(home)
+      Sqlite.call(SearchIndex.path(home), <<~SQL, readonly: true)
+        SELECT path, lower(hex(sha3(readfile(#{Sqlite.quote(home)} || '/' || path), 256))) AS file, #{ROW_HASH} AS row, hash
+        FROM doc;
+      SQL
+    end
+
+    def self.apply(home, plan)
+      statements = plan.map { |action, path| send(action, home, path) }
+      statements << "INSERT INTO ft(ft) VALUES('rebuild');" if plan.any? { |action, _path| action == "read" }
+      Sqlite.call(SearchIndex.path(home), ["BEGIN;", *statements, "COMMIT;"].join("\n"))
+    end
+
+    def self.read(home, path)
+      "DELETE FROM doc WHERE path = #{Sqlite.quote(path)};\n#{SearchIndex.insert(home, path)}"
+    end
+
+    def self.write(home, path)
+      where = "WHERE path = #{Sqlite.quote(path)}"
+      "#{restore(home, "doc", "path")} #{where};\nUPDATE doc SET hash = #{ROW_HASH} #{where};"
+    end
+
+    def self.restore(home, table, column)
+      "SELECT writefile(#{Sqlite.quote(home)} || '/' || #{column}, sqlar_uncompress(data, sz)) FROM #{table}"
+    end
+
+    def self.diff(home, path)
+      body = Sqlite.call(SearchIndex.path(home), <<~SQL, readonly: true).first["body"]
+        SELECT CAST(sqlar_uncompress(data, sz) AS TEXT) AS body FROM doc WHERE path = #{Sqlite.quote(path)};
+      SQL
+      Tempfile.create("plastic-row") do |row|
+        row.write(body)
+        row.flush
+        Open3.capture2("diff", "-u", "-L", "row", "-L", "file", row.path, File.join(home, path)).first
+      end
+    end
+
+    def self.orphans(home)
+      paths = Sqlite.call(SearchIndex.path(home), "SELECT path FROM doc;", readonly: true) +
+        Sqlite.call(ReferenceArchive.path(home), "SELECT name AS path FROM sqlar;", readonly: true)
+      keys = paths.filter_map { |row| row["path"].match(INTENT_PATH) }.map { |found| "#{found[1] || "global"}:#{found[2]}" }
+      (keys.uniq - WorkGraph.known(home)).sort
+    end
+
+    def self.checkout(home)
+      {SearchIndex.path(home) => %w[doc path], ReferenceArchive.path(home) => %w[sqlar name]}.flat_map do |database, (table, column)|
+        missing = Sqlite.call(database, "SELECT #{column} AS path FROM #{table};", readonly: true)
+          .map { |row| row["path"] }.reject { |path| File.exist?(File.join(home, path)) }
+        names = missing.map { |path| Sqlite.quote(path) }.join(", ")
+        Sqlite.call(database, "#{restore(home, table, column)} WHERE #{column} IN (#{names});", readonly: true)
+        missing
+      end
+    end
+  end
+end