@zalom/plastic 2.0.0-alpha.8 → 2.0.1

package/scripts/lib/session_close.rb

@@ -17,8 +17,9 @@ module SessionClose
   NOOP_REASONS = %w[clear resume].freeze
 
   # The default hand-off writer (intent 311, spec D6): renders this session's
-  # share of the pointer day into handoff--<session>.md before the tmp dir
-  # goes. The hook script builds it with the shipped templates dir.
+  # share of its session day (SessionLedger.session_day, graph.md D7) into
+  # handoff--<session>.md before the tmp dir goes. The hook script builds it
+  # with the shipped templates dir.
   def default_handoff(templates)
     lambda do |store, day, session|
       Handoff.write(store: store, day: day, session: session, trigger: "close", templates: templates)
@@ -45,26 +46,33 @@ module SessionClose
     session = SessionLedger.short_session_id(payload.is_a?(Hash) ? payload["session_id"] : nil, nil)
     return report if session.empty?
 
-    pointer_day = safely { read_pointer_day(store, session) } || today
+    days = safely { SessionLedger.session_days(store, session, today: today) } || []
+    days = [today] if days.empty?
+    session_day = days.last
     project = "global"
 
+    # Intent 344 (G11, D13): a session that crossed midnight carries pending
+    # lines on more than one day ledger; every one of them drops, not only
+    # the newest, so a close never leaves an earlier day's lines pending.
     report[:dropped] = safely do
-      checklist = SessionLedger.checklist_path(store, pointer_day)
-      count = SessionLedger.flip_all(checklist, from: :pending, to: :dropped, session: session)
-      if count.positive?
-        SessionLedger.append_line(SessionLedger.savepoint_path(store, pointer_day),
-                                  SessionLedger.savepoint_line("Note", session, project,
-                                                               "dropped #{count} pending lines at close", now: now))
+      days.sum do |day|
+        checklist = SessionLedger.checklist_path(store, day)
+        count = SessionLedger.flip_all(checklist, from: :pending, to: :dropped, session: session)
+        if count.positive?
+          SessionLedger.append_line(SessionLedger.savepoint_path(store, day),
+                                    SessionLedger.savepoint_line("Note", session, project,
+                                                                 "dropped #{count} pending lines at close", now: now))
+        end
+        count
       end
-      count
     end || 0
 
     # The hand-off (intent 311, spec D6) is written after the drop, so it
-    # reflects it, and before the tmp dir goes, since the pointer lives there.
-    # An intent pointer falls back to today, the same as the drop above.
+    # reflects it, and before the tmp dir goes. A session with no line in the
+    # day ledger's window falls back to today, the same as the drop above.
     if handoff
       report[:handoff] = safely do
-        handoff.call(store, pointer_day, session)
+        handoff.call(store, session_day, session)
         true
       end || false
     end
@@ -75,27 +83,21 @@ module SessionClose
       true
     end || false
 
-    if pointer_day < today
+    # One carry spawns per day earlier than today, oldest first; a single
+    # earlier day keeps reporting its own arg array (not a one-element
+    # list) so an existing caller reading report[:spawned] as one array is
+    # unaffected.
+    earlier_days = days.select { |day| day < today }
+    unless earlier_days.empty?
       report[:spawned] = safely do
-        args = ["--day", pointer_day, "--carry-to", today, "--store", store]
-        spawner.call(args)
-        args
+        arg_lists = earlier_days.map { |day| ["--day", day, "--carry-to", today, "--store", store] }
+        arg_lists.each { |args| spawner.call(args) }
+        arg_lists.length == 1 ? arg_lists.first : arg_lists
       end
     end
     report
   end
 
-  # The pointer names the intent this session records into; a day id means
-  # the day ledger. Anything else (an intent id) means an auto team owns the
-  # record and the close touches no day ledger.
-  def read_pointer_day(store, session)
-    path = SessionLedger.pointer_path(store, session)
-    return nil unless File.exist?(path)
-
-    value = File.read(path).strip
-    SessionLedger.valid_day_id?(value) ? value : nil
-  end
-
   def safely
     yield
   rescue StandardError

package/scripts/lib/session_git.rb

@@ -1,10 +1,12 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
+require_relative "store_layout"
 require "yaml"
 require_relative "worktree"
 require_relative "scaffold_intent"
 require_relative "session_ledger"
+require_relative "active_delivery"
 
 # SessionGit - the branch model and per-repo flow settings behind
 # `scripts/session-commit` (intent 300), which is how a checklist item
@@ -159,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
@@ -185,24 +187,29 @@ module SessionGit
     text.to_s.downcase.scan(/[a-z0-9]+/).first(max_words).join("-")
   end
 
-  # The intent id named by the session's pointer file when `ticket_source`
-  # is `intent_id`, else the day id (spec D4). Per intent 298 spec D6, the
-  # pointer at `.tmp/<session>/current` holds exactly one line: either
-  # today's day id (the session records into the day ledger) or an intent
-  # id (an auto team owns the record). A day id in the pointer is therefore
-  # not an intent name, and falls back to the day id here too, which is the
-  # same value either way.
-  def resolve_ticket(day:, store:, session:, ticket_source:)
+  # The delivering intent's id when `ticket_source` is `intent_id`, else the
+  # day id (344 n2, D4-D7, D12). `resolver` is injected so tests need no
+  # real ~/.plastic; it defaults to ActiveDelivery.resolve_by_short_session
+  # against the store's own project roots.
+  def resolve_ticket(day:, store:, session:, ticket_source:, resolver: nil)
     return day.to_s unless ticket_source.to_s == "intent_id"
 
-    pointer = SessionLedger.pointer_path(store, session)
-    return day.to_s unless File.exist?(pointer)
+    resolver ||= lambda { |short_session|
+      ActiveDelivery.resolve_by_short_session(
+        global_store: store,
+        project_roots: ActiveDelivery.project_roots(Plastic::StoreLayout.locate(store).first),
+        short_session: short_session
+      )
+    }
 
-    content = File.read(pointer).to_s.strip
-    return day.to_s if content.empty?
-    return day.to_s if SessionLedger.valid_day_id?(content)
+    dir = begin
+      resolver.call(session)
+    rescue StandardError
+      nil
+    end
+    return day.to_s if dir.to_s.empty?
 
-    content
+    File.basename(dir).split("--", 2).first
   end
 
   # --- commit message ------------------------------------------------------------
@@ -245,7 +252,7 @@ module SessionGit
   # The branch HEAD points to, even on an unborn branch (review R3: a fresh
   # `git init`, zero commits). `git rev-parse --abbrev-ref HEAD` FAILS on an
   # unborn branch (there is no commit for it to resolve yet), which the old
-  # implementation misread as "cannot determine a branch" and folded into
+  # implementation misread as "cannot determine a branch" and merged into
   # the detached-HEAD case. `git symbolic-ref --quiet --short HEAD` succeeds
   # on both a normal AND an unborn branch (HEAD is a symbolic ref to
   # `refs/heads/<name>` in both cases) and only fails when HEAD is
@@ -327,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?
 
@@ -354,7 +361,7 @@ module SessionGit
 
     # An unknown mode/workspace value, or workspace: worktree's degradation
     # to checkout, is itself a degradation (spec D2, BLOCKER 3 ruling), so
-    # it always turns the outcome into a Note, folding both facts into the
+    # it always turns the outcome into a Note, merging both facts into the
     # single savepoint line spec D7 allows.
     Result.new(message: "#{flow_notes.join('; ')}; #{result.message}", event: "Note")
   end

package/scripts/lib/session_ledger.rb

@@ -29,6 +29,10 @@ module SessionLedger
 
   SESSIONS_DIR = ".sessions"
   TMP_DIR = ".tmp"
+  # Named here, not in a CLI, so a caller can reference the key without the
+  # literal harness-branded env var name appearing in its own source (a few
+  # scripts are guarded against naming a harness at all).
+  SESSION_ID_ENV_KEY = "CLAUDE_CODE_SESSION_ID"
   DAY_ID = /\A\d{8}\z/
   EVENTS = %w[Item Done Note]
   STATES = { pending: "~", open: " ", done: "x", moved: ">", dropped: "-", promoted: "^" }.freeze
@@ -150,14 +154,54 @@ module SessionLedger
     File.join(tmp_root(store), session_id)
   end
 
-  def pointer_path(store, session_id)
-    File.join(session_tmp_dir(store, session_id), "current")
-  end
-
   def heartbeat_path(store, session_id)
     File.join(session_tmp_dir(store, session_id), "heartbeat")
   end
 
+  # --- Session day (spec D7 replacement for the retired pointer) ------------
+
+  # Every day, ascending, no later than `today` and no earlier than `today`
+  # minus `window_days`, whose checklist carries at least one line tagged to
+  # `session` (any state). Each day's checklist is read inside its own
+  # rescue, so one unreadable or missing checklist skips that day only and
+  # never gives up on a later one. Returns an empty array when no day in the
+  # window carries the session's line, and on any error reading the store
+  # (never raises).
+  def session_days(store, session, today:, window_days: 7)
+    root = sessions_root(store)
+    return [] unless File.directory?(root)
+
+    today_date = Date.strptime(today, "%Y%m%d")
+    floor_date = today_date - window_days
+
+    days = Dir.children(root).select { |name| valid_day_id?(name) }.select do |name|
+      date = Date.strptime(name, "%Y%m%d")
+      date >= floor_date && date <= today_date
+    end.sort
+
+    days.select do |day|
+      begin
+        read_locked(checklist_path(store, day)).each_line.any? do |line|
+          parsed = parse_checklist_line(line)
+          parsed && parsed[:session] == session
+        end
+      rescue StandardError
+        false
+      end
+    end
+  rescue StandardError
+    []
+  end
+
+  # The newest day in `session_days`, the day this session's close and
+  # hand-off write belong to (intent 344, G11, D13: a session that crosses
+  # midnight carries lines on more than one day, and the newest is the one
+  # still open). Falls back to `today` when no day in the window carries the
+  # session's line.
+  def session_day(store, session, today:, window_days: 7)
+    session_days(store, session, today: today, window_days: window_days).last || today
+  end
+
   # Create `.tmp/` plus a `.gitignore` holding exactly `*`, if that file does
   # not already exist. The store is a local git repo that auto-commits
   # `add -A`, so without this ignore file every heartbeat write would enter

package/scripts/lib/session_usage.rb

@@ -0,0 +1,190 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require "json"
+require "time"
+
+# SessionUsage (intent 355, D10): reads the harness transcripts modified since
+# a cutoff, dedupes assistant records by message id (the harness logs one
+# record per content block), and reports per session the model, the calls in
+# the window, the boot and last context, the median step, the steps over 5k,
+# and the cache read. Context is input plus cache read plus cache write.
+# Broken records are counted and named, never averaged over. The transcripts
+# root and the rate-limit cache path are injected; nothing reads ENV.
+class SessionUsage
+  WINDOW = 5 * 3600
+  BIG_STEP = 5_000
+  LABEL_WIDTH = 70
+  NO_PROMPT = "(no prompt)"
+  SYNTHETIC_MODEL = "<synthetic>"
+  CONTEXT_FIELDS = %w[input_tokens cache_read_input_tokens cache_creation_input_tokens].freeze
+  TRANSCRIPT_GLOBS = [File.join("*", "*.jsonl"), File.join("*", "*", "subagents", "*.jsonl")].freeze
+  HEADERS = ["session", "model", "calls", "boot", "last", "median step", "big steps", "cache read", "broken", "prompt"].freeze
+
+  def initialize(transcripts_root:, rate_limits_path:, now: Time.now)
+    @transcripts_root = transcripts_root
+    @rate_limits_path = rate_limits_path
+    @now = now
+  end
+
+  def cutoff(since: nil)
+    return [since, "since"] if since
+
+    reset = reset_time
+    return [reset - WINDOW, "rate-limit reset"] if reset && reset > @now
+
+    [@now - WINDOW, "last 5 hours"]
+  end
+
+  def report(since: nil)
+    at, source = cutoff(since: since)
+    header = { "status" => "ok", "root" => @transcripts_root, "cutoff" => at.getutc.iso8601, "cutoff_source" => source }
+    return header.merge("status" => "unavailable") unless File.directory?(@transcripts_root)
+
+    broken = []
+    sessions = transcripts(at).filter_map { |path| summarize(path, at, broken) }
+    header.merge("sessions" => sessions.sort_by { |s| -s["cache_read"] }, "broken" => broken)
+  end
+
+  def self.render_text(report)
+    return "Session usage: unavailable (no transcripts directory at #{report['root']})\n" if report["status"] == "unavailable"
+
+    out = +"Session usage since #{report['cutoff']} (#{report['cutoff_source']})\n\n"
+    out << (report["sessions"].empty? ? "(no sessions)\n" : table(report["sessions"]))
+    return out if report["broken"].empty?
+
+    out << "\nBroken records (#{report['broken'].size}):\n"
+    report["broken"].each { |b| out << "  #{b['file']}:#{b['line']}  #{b['error']}\n" }
+    out
+  end
+
+  def self.table(sessions)
+    rows = sessions.map do |s|
+      boot = tokens(s["boot"]) + (s["started_before_cutoff"] ? "*" : "")
+      [s["id"], s["model"].to_s, s["calls"].to_s, boot, tokens(s["last"]), tokens(s["median_step"]),
+       s["big_steps"].to_s, tokens(s["cache_read"]), s["broken"].to_s, s["label"]]
+    end
+    widths = HEADERS.each_index.map { |i| ([HEADERS] + rows).map { |r| r[i].length }.max }
+    lines = ([HEADERS] + rows).map { |r| r.each_with_index.map { |cell, i| cell.ljust(widths[i]) }.join("  ").rstrip }
+    note = sessions.any? { |s| s["started_before_cutoff"] } ? "\n* boot predates the cutoff\n" : ""
+    lines.join("\n") + "\n" + note
+  end
+
+  def self.tokens(count)
+    return "-" if count.nil?
+
+    count.abs >= 1_000 ? format("%.1fk", count / 1_000.0) : count.to_s
+  end
+
+  private_class_method :table, :tokens
+
+  private
+
+  def reset_time
+    return unless File.file?(@rate_limits_path)
+
+    value = JSON.parse(File.read(@rate_limits_path))["resets_at"].to_s
+    return if value.empty?
+
+    value.match?(/\A\d+\z/) ? Time.at(value.to_i).utc : Time.iso8601(value)
+  rescue JSON::ParserError, ArgumentError, TypeError
+    nil
+  end
+
+  def transcripts(cutoff)
+    TRANSCRIPT_GLOBS.flat_map { |glob| Dir.glob(File.join(@transcripts_root, glob)) }
+                    .select { |path| File.mtime(path) >= cutoff }
+                    .sort
+  end
+
+  def summarize(path, cutoff, broken)
+    calls = {}
+    label = nil
+    torn = 0
+    File.foreach(path).with_index(1) do |line, number|
+      next if line.strip.empty?
+
+      record = JSON.parse(line)
+      raise TypeError, "record is not a JSON object" unless record.is_a?(Hash)
+
+      label ||= prompt_line(record)
+      call = call_from(record)
+      next unless call
+
+      calls[call[:id]] = calls.key?(call[:id]) ? call.merge(at: calls[call[:id]][:at]) : call
+    rescue JSON::ParserError
+      torn += 1
+      broken << { "file" => path, "line" => number, "error" => "unparsable JSON" }
+    rescue ArgumentError, TypeError => e
+      torn += 1
+      broken << { "file" => path, "line" => number, "error" => e.message }
+    end
+    row(path, calls.values, cutoff, label, torn)
+  end
+
+  def row(path, calls, cutoff, label, torn)
+    window = calls.each_index.select { |i| calls[i][:at] >= cutoff }
+    return if window.empty? && torn.zero?
+
+    steps = window.filter_map { |i| calls[i][:context] - calls[i - 1][:context] if i.positive? }
+    {
+      "id" => File.basename(path, ".jsonl"),
+      "file" => path,
+      "label" => label || NO_PROMPT,
+      "model" => calls.last && calls.last[:model],
+      "calls" => window.size,
+      "boot" => calls.first && calls.first[:context],
+      "last" => calls.last && calls.last[:context],
+      "median_step" => median(steps),
+      "big_steps" => steps.count { |step| step > BIG_STEP },
+      "cache_read" => window.sum { |i| calls[i][:cache_read] },
+      "broken" => torn,
+      "started_before_cutoff" => !calls.empty? && calls.first[:at] < cutoff,
+    }
+  end
+
+  def call_from(record)
+    return unless record["type"] == "assistant"
+
+    message = record["message"]
+    raise TypeError, "assistant record without a message" unless message.is_a?(Hash)
+    return if message["model"] == SYNTHETIC_MODEL
+
+    usage = message["usage"]
+    raise ArgumentError, "assistant record without message id or usage" unless message["id"] && usage.is_a?(Hash)
+
+    {
+      id: message["id"],
+      model: message["model"],
+      at: Time.iso8601(record["timestamp"].to_s),
+      context: CONTEXT_FIELDS.sum { |field| usage[field].to_i },
+      cache_read: usage["cache_read_input_tokens"].to_i,
+    }
+  end
+
+  def prompt_line(record)
+    return unless record["type"] == "user" && !record["isMeta"]
+
+    text = prompt_text(record["message"].is_a?(Hash) ? record["message"]["content"] : nil)
+    return if text.nil?
+
+    first = text.lines.map(&:strip).find { |line| !line.empty? && !line.start_with?("<") }
+    first && first[0, LABEL_WIDTH]
+  end
+
+  def prompt_text(content)
+    return content if content.is_a?(String)
+    return unless content.is_a?(Array)
+
+    block = content.find { |b| b.is_a?(Hash) && b["type"] == "text" }
+    block && block["text"]
+  end
+
+  def median(values)
+    return if values.empty?
+
+    sorted = values.sort
+    middle = sorted.size / 2
+    sorted.size.odd? ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2
+  end
+end

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/stop_gate.rb

@@ -0,0 +1,95 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require "json"
+require_relative "active_delivery"
+require_relative "lock"
+require_relative "ready_set"
+
+# StopGate (intent 340b, G7c, n4, D5/D7/D8/D9): may this session stop? Blocks
+# only when four conditions hold together: the payload's stop_hook_active is
+# true, runner.stop_hook parses as a real boolean true, this session holds
+# the delivering intent's delivery.lock live and in auto mode, and the last
+# runner step left work a new turn can actually move (some node is ready to
+# dispatch right now - a graph whose only non-terminal node is already
+# running, or that has no ready node at all, permits, because blocking that
+# would trip Claude Code's own eight-block ceiling for nothing).
+#
+# Fail-open is the design, not a fallback: a missing store, a torn lock, an
+# unreadable graph, a raised exception, a payload that is not JSON - every
+# one of those permits. #decide never raises.
+module StopGate
+  module_function
+
+  # decide(payload:, config_stop_hook:, session:, global_store:, project_roots:, ttl:, now:) ->
+  # {block: false} or {block: true, reason: "..."}.
+  #
+  # `payload` is the hook input: already a Hash, or the raw JSON text (row
+  # 4.19 - a payload that is not JSON permits, never raises). `config_stop_hook`
+  # is the raw string read-config returns for runner.stop_hook: parsed as a
+  # boolean here, never trusted as one.
+  def decide(payload:, config_stop_hook:, session:, global_store:, project_roots:,
+             ttl: Lock::TTL_SECONDS, now: Time.now, caps: nil)
+    payload = parse_payload(payload)
+
+    return permit unless payload["stop_hook_active"] == true
+    return permit unless flag_true?(config_stop_hook)
+
+    intent_dir = ActiveDelivery.resolve(global_store: global_store, project_roots: project_roots,
+                                        session: session, ttl: ttl, now: now)
+    return permit unless intent_dir
+
+    lock = Lock.read(intent_dir)
+    return permit unless lock
+    return permit unless lock["run_mode"].to_s == "auto"
+
+    return permit unless work_movable?(intent_dir, caps: caps)
+
+    block(intent_dir)
+  rescue StandardError
+    permit
+  end
+
+  # Accepts a Hash as-is, parses a String as JSON, and falls back to an
+  # empty Hash for anything else or anything that fails to parse - a
+  # malformed payload must never raise (row 4.19).
+  def parse_payload(payload)
+    return payload if payload.is_a?(Hash)
+    return {} unless payload.is_a?(String)
+
+    parsed = JSON.parse(payload)
+    parsed.is_a?(Hash) ? parsed : {}
+  rescue JSON::ParserError
+    {}
+  end
+
+  # A config value counts as on only when it parses as the literal boolean
+  # true (row 4.4): read-config emits strings, and the string "false" is
+  # truthy in Ruby, so testing the raw value would arm the hook on its own
+  # shipped default. Anything else, including an absent key (row 4.5), is off.
+  def flag_true?(value)
+    value.to_s.strip.downcase == "true"
+  end
+
+  # Some node is ready to dispatch right now. Never raises across this
+  # boundary (ReadySet.analyze already never does); an unreadable or absent
+  # graph, or an intent with no declared nodes, reads as ok: false or an
+  # empty ready set either way, and both permit.
+  def work_movable?(intent_dir, caps:)
+    analysis = caps ? ReadySet.analyze(intent_dir, caps: caps) : ReadySet.analyze(intent_dir)
+    analysis[:ok] && analysis[:ranked_ready].any?
+  end
+
+  def permit
+    { block: false }
+  end
+
+  # Names the next instruction (row 4.17): a session that is blocked and
+  # told nothing stops again immediately.
+  def block(intent_dir)
+    intent_id = File.basename(intent_dir.to_s)
+    reason = "Plastic: intent #{intent_id} still has ready work. Run `runner step` for it " \
+             "and dispatch what it prints before stopping."
+    { block: true, reason: reason }
+  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)