lux-hammer 0.3.20 → 0.3.22

data/recipes/lib/llm/wrap.rb

@@ -3,6 +3,7 @@
 require 'fileutils'
 require 'io/console'
 require 'pty'
+require 'shellwords'
 
 # Run a command in a PTY with the last prompts you typed pinned to the bottom
 # rows of the screen, under a "prompt history" rule.
@@ -36,6 +37,20 @@ module LlmWrap
   MAX_DEFER ||= 0.15
   CHUNK     ||= 65_536
 
+  # A pty master hands back at most a kilobyte per read whatever CHUNK says, so
+  # one redraw arrives as dozens of pieces. DRAIN_MAX caps how much of it we
+  # take in a single go, so a child that never stops talking cannot starve the
+  # keyboard. MAX_BLOCK is how long a paint will wait for a safe moment before
+  # giving up and taking one - see Session#paint.
+  DRAIN_MAX ||= 262_144
+  MAX_BLOCK ||= 1.5
+
+  # Introducers of the escape sequences that carry a string payload:
+  # OSC ], DCS P, SOS X, PM ^, APC _. They run to BEL or ST rather than to a
+  # final byte, so both stream parsers here - KeyBuffer on the way in, OutScan
+  # on the way out - have to know them to find the end of one.
+  STRING_INTRO ||= [0x5d, 0x50, 0x58, 0x5e, 0x5f].freeze
+
   # `origin` is how this wrapper was asked for, in the words that would ask for
   # it again - only the caller knows that, since taking the child's name throws
   # our own command line away. It is what Handoff writes down; the child's argv
@@ -137,15 +152,78 @@ module LlmWrap
     end
   end
 
+  # The commands `llm wrap` offers when asked for no particular one. Plain
+  # text, one command per line - nothing to learn, editable with anything.
+  #
+  # A # comment is dropped, so a command can be parked without being deleted.
+  # A line with no letter in it is kept but not runnable: blanks and ---- rules
+  # stay visible in the picker to group the list, the cursor just steps over
+  # them. No executable name is spelled without a letter, so nothing real is
+  # caught by that.
+  module Config
+    DEFAULTS ||= [
+      'claude --dangerously-skip-permissions --continue',
+      'codex resume --last --dangerously-bypass-approvals-and-sandbox',
+      'grok --always-approve --continue'
+    ].freeze
+
+    # A method rather than a constant for the same reason as Handoff.dir: the
+    # tests need somewhere else to write.
+    def self.path
+      ENV['LLM_WRAP_CONFIG'] || File.expand_path('~/.config/hammer/llm-wrap.txt')
+    end
+
+    def self.lines
+      return [] unless File.file?(path)
+
+      # Decide what to keep first, then tidy what survived - lstrip inside the
+      # test so an indented # is still a comment.
+      File.readlines(path, chomp: true)
+          .reject { |line| line.lstrip.start_with?('#') }
+          .map(&:strip)
+    rescue SystemCallError, IOError
+      []
+    end
+
+    # A row the picker shows but will not run. Nothing without a letter in it
+    # can name a program, which makes ---- and a blank line free to use as
+    # dividers without needing a syntax for them.
+    def self.runnable?(line)
+      line.match?(/[a-z]/i)
+    end
+
+    # Split rather than hand the line over whole: PTY.spawn passes a
+    # one-element argv to /bin/sh, and a command out of this file should reach
+    # the wrapper the same way `llm wrap claude --foo` already does - as argv,
+    # no shell in between.
+    def self.argv(line)
+      Shellwords.split(line)
+    end
+
+    # Writes DEFAULTS when there is nothing there yet - no file, or one that is
+    # only whitespace. A file holding just commented-out lines is left alone;
+    # those are someone's notes, not an empty file.
+    def self.seed
+      return false if File.file?(path) && !File.read(path).strip.empty?
+
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, "#{DEFAULTS.join("\n")}\n")
+      true
+    end
+  end
+
   class Session
     def initialize(argv, keep, origin = argv)
       @argv     = argv
       @origin   = origin
       @bar_rows = keep + 1     # the prompts, plus the rule above them
       @keys     = KeyBuffer.new(keep)
+      @out      = OutScan.new
       @winch    = false
       @dirty    = true
       @drawn_at = 0.0
+      @blocked  = nil
+      @skipped  = nil
       @started  = now
       @trace    = (File.open(ENV['LLM_WRAP_DEBUG'], 'a') if ENV['LLM_WRAP_DEBUG'].to_s != '')
     rescue SystemCallError
@@ -281,7 +359,7 @@ module LlmWrap
         ready = IO.select([$stdin, @pty_out], nil, nil, IDLE_TICK)
 
         unless ready
-          draw_bar if @dirty        # output settled
+          paint if @dirty   # output settled
           next
         end
 
@@ -293,8 +371,9 @@ module LlmWrap
             @dirty = true if taking && @keys.feed(data)
             trace_in(data, taking)
           else
-            data = slurp(@pty_out) or return
+            data = drain(@pty_out) or return
             $stdout.write(data)
+            @out.feed(data)
             trace_out(data)
             # The child cannot address the bar rows, but it can switch to the
             # alt screen (which starts blank) or scroll a region it set itself.
@@ -304,7 +383,7 @@ module LlmWrap
         end
 
         # Keep the bar honest while output streams without ever settling.
-        draw_bar if @dirty && now - @drawn_at > MAX_DEFER
+        paint if @dirty && now - @drawn_at > MAX_DEFER
       end
     rescue Errno::EIO, Errno::EPIPE, EOFError
       nil
@@ -316,6 +395,49 @@ module LlmWrap
       nil
     end
 
+    # Take everything the child has queued, not just the kilobyte a pty master
+    # gives back per read. One redraw then lands in a single write and the paint
+    # that follows it falls on a frame boundary instead of inside the frame.
+    def drain(io)
+      data = slurp(io) or return nil
+
+      while data.bytesize < DRAIN_MAX && IO.select([io], nil, nil, 0)
+        more = slurp(io) or break
+        data << more
+      end
+
+      data
+    end
+
+    # Paint only where the terminal's parser is at rest - see OutScan for what
+    # goes wrong otherwise. The bar is cosmetic, so waiting is nearly always
+    # right; the exception is a child that leaves a sequence open for good (an
+    # unterminated OSC, a DECSC it never restores), where a bar frozen on the
+    # wrong prompts is worse than one glitched frame.
+    def paint
+      return released if @out.safe?
+
+      @blocked ||= now
+
+      if now - @blocked < MAX_BLOCK
+        # Once per state rather than once per tick, or the log is nothing else.
+        reason   = @out.to_s
+        trace('SKIP', reason) if reason != @skipped
+        @skipped = reason
+        return
+      end
+
+      trace('FORCE', @out.to_s)
+      @out.reset!
+      released
+    end
+
+    def released
+      @blocked = nil
+      @skipped = nil
+      draw_bar
+    end
+
     # Terminals disagree wildly about how they report keys, and the encoding
     # depends on modes the child turns on and off as it runs. LLM_WRAP_DEBUG=<file>
     # records both sides raw so the two can be lined up. Off unless asked for -
@@ -368,6 +490,139 @@ module LlmWrap
     end
   end
 
+  # Follows the child's output on its way to the screen and answers one
+  # question: is the terminal's parser at rest right now?
+  #
+  # Painting the bar means writing our own escapes into that stream, and a pty
+  # master hands back at most a kilobyte per read - so a full redraw arrives as
+  # dozens of pieces split at arbitrary bytes, and a paint dropped into one of
+  # the seams breaks whatever it landed in the middle of:
+  #
+  #   * a sequence, leaving the introducer stranded and its tail printed as
+  #     text - the literal "[22m" on screen
+  #   * a UTF-8 character, which comes out as a replacement glyph
+  #   * a DECSC the child opened and has not closed yet. The terminal has one
+  #     save slot; we take it, and the child's own ESC8 then puts its cursor on
+  #     our bar and it draws the rest of the frame over the top. Claude Code
+  #     wraps every repaint in ESC7 ... ESC8, so this one is not theoretical.
+  #
+  # This is only ever asked about the *end* of what we have written so far, so
+  # there is no need to understand the sequences - just to know where they stop.
+  class OutScan
+    ESC = 0x1b
+    BEL = 0x07
+
+    # Escapes whose second byte is followed by exactly one more: SS3 (ESC O),
+    # the charset designators (ESC ( ) * +), and ESC # / ESC %.
+    ONE_MORE ||= [0x4f, 0x28, 0x29, 0x2a, 0x2b, 0x23, 0x25].freeze
+
+    # Runaway guards. A CSI this long, or a string payload this long, is a
+    # stream we have lost the thread of rather than a sequence still coming.
+    MAX_CSI ||= 128
+    MAX_STR ||= 8192
+
+    # Nothing outside these bytes can start a sequence or a multi-byte
+    # character, so a plain-text burst needs no walking at all.
+    INTERESTING ||= /[\e\x80-\xff]/n
+
+    def initialize
+      reset!
+    end
+
+    def reset!
+      @state = :text
+      @need  = 0     # UTF-8 continuation bytes still owed
+      @saved = 0     # ESC7 seen without its ESC8
+      @len   = 0
+    end
+
+    # True when the last byte written ended a sequence and a character, and the
+    # child is not holding a saved cursor.
+    def safe?
+      @state == :text && @need.zero? && @saved.zero?
+    end
+
+    def feed(bytes)
+      return if @state == :text && @need.zero? && !bytes.match?(INTERESTING)
+
+      bytes.each_byte { |b| step(b) }
+    end
+
+    # What is holding a paint back, for the debug trace.
+    def to_s
+      "#{@state} utf8=#{@need} saved=#{@saved}"
+    end
+
+    private
+
+    def step(byte)
+      case @state
+      when :text then text(byte)
+      when :esc  then escape(byte)
+      when :csi  then csi(byte)
+      when :one  then @state = :text
+      when :str  then string(byte)
+      when :st   then terminator(byte)
+      end
+    end
+
+    def text(byte)
+      return @state = :esc if byte == ESC
+      return @need = 0 if byte < 0x80
+
+      # A continuation byte only counts while one is owed; anything else is a
+      # lead byte, and a stray one just resets the count.
+      return @need -= 1 if @need.positive? && (byte & 0xc0) == 0x80
+
+      @need = case byte
+              when 0xc0..0xdf then 1
+              when 0xe0..0xef then 2
+              when 0xf0..0xf7 then 3
+              else 0
+              end
+    end
+
+    # The second byte says how the rest of the sequence ends. ESC7/ESC8 are the
+    # pair we care about beyond that - see the class comment.
+    def escape(byte)
+      @len = 0
+
+      case byte
+      when 0x5b          then @state = :csi
+      when *STRING_INTRO then @state = :str
+      when *ONE_MORE     then @state = :one
+      when ESC           then nil                     # ESC ESC: still :esc
+      else
+        # ESC7 saves the cursor and ESC8 restores it. Everything else that gets
+        # here is a two-byte escape, and is over.
+        @saved += 1 if byte == 0x37
+        @saved -= 1 if byte == 0x38 && @saved.positive?
+        @state = :text
+      end
+    end
+
+    def csi(byte)
+      @len += 1
+      return @state = :esc if byte == ESC       # aborted, a new one starting
+      return @state = :text if @len > MAX_CSI
+
+      @state = :text if byte >= 0x40 && byte <= 0x7e
+    end
+
+    # String payloads run to BEL or ST (ESC \).
+    def string(byte)
+      @len += 1
+      return @state = :st   if byte == ESC
+      return @state = :text if byte == BEL || @len > MAX_STR
+    end
+
+    def terminator(byte)
+      return if byte == ESC
+
+      @state = byte == 0x5c ? :text : :str
+    end
+  end
+
   # Rebuilds the line you are typing from the raw byte stream on its way to the
   # child, and keeps the last `keep` submitted lines.
   #
@@ -387,9 +642,6 @@ module LlmWrap
     BEL   = 0x07
     DEL   = 0x7f
 
-    # Introducers of the escape sequences that carry a string payload:
-    # OSC ], DCS P, SOS X, PM ^, APC _.
-    STRING_INTRO ||= [0x5d, 0x50, 0x58, 0x5e, 0x5f].freeze
     CTRL_C = 0x03
     CTRL_U = 0x15
     CTRL_W = 0x17

data/recipes/llm.rb

@@ -7,6 +7,7 @@ desc <<~TXT
 
   Namespaces:
     memory   persistent memory store (backs the Claude Code memory plugin)
+    plan     apply a /plan bundle - sha1 checked, drift aware
     prompt   token-prefix prompt expander (UserPromptSubmit hook + CLI)
 
   Commands:
@@ -23,6 +24,7 @@ require 'set'
 # checkout still load matching lib/, not an older installed gem copy).
 _llm_root = File.dirname(File.realpath(__FILE__))
 require File.join(_llm_root, 'lib/llm/usage')
+require File.join(_llm_root, 'lib/llm/plan')
 
 STORE        ||= ENV['CLAUDE_MEMORY_STORE'] || File.expand_path('~/dev/ai/memory')
 VALID_TYPES  ||= %w[user feedback project reference].freeze
@@ -40,10 +42,10 @@ task :usage do
     `~/.cache/llm/claude-limits.json`, falling back to the OAuth usage API. `month` shows
     Claude extra-usage credits (API only, and only when you've enabled them).
   D
-  example 'llm usage'
-  example 'llm usage month'
-  example 'llm usage --json'
-  example 'llm usage --provider grok'
+  example 'usage'
+  example 'usage month'
+  example 'usage --json'
+  example 'usage --provider grok'
 
   # :period is declared first on purpose — the parser fills un-set scalar opts
   # from positionals in declaration order, so `llm usage month` must reach
@@ -91,7 +93,7 @@ task :wrap do
     newest one sits on the very last line. It is --lines + 1 rows tall.
 
     Each prompt gets one row: a multi-line prompt is flattened onto it with line breaks
-    shown as a literal \\n, and the whole thing is clipped to the terminal width.
+    shown as a backslash, and the whole thing is clipped to the terminal width.
 
     A prompt is whatever you type between Enters. Shift/Option+Enter and pasted newlines
     keep appending to the current one. This is keystroke sniffing, so text the program
@@ -108,27 +110,59 @@ task :wrap do
 
     Put `--` before the wrapped command when it has flags of its own, otherwise they are
     parsed as flags to `llm wrap`.
+
+    With no command at all, the commands in ~/.config/hammer/llm-wrap.txt are offered in
+    an arrow-key picker instead. That file is plain text, one command per line. A line
+    starting with # is dropped, and a line with no letter in it stays on screen but
+    cannot be picked - so blanks and ---- rules group the list without being in the way.
+    `--config` opens it in $EDITOR, writing a starting set the first time.
   D
-  example 'llm wrap claude'
-  example 'llm wrap -- claude --resume'
-  example 'llm wrap --lines 5 -- bash -l'
+  example 'wrap'
+  example 'wrap --config'
+  example 'wrap claude'
+  example 'wrap -- claude --resume'
+  example 'wrap --lines 5 -- bash -l'
 
   # `positional: false` is load-bearing: the parser fills un-set scalar opts
   # from positionals in declaration order, so without it `llm wrap claude`
-  # would hand "claude" to --lines and die on the integer cast.
+  # would hand "claude" to --lines and die on the integer cast. `--config` is
+  # boolean, which the parser skips over, so it needs no such guard.
   opt :lines, type: :integer, default: 3, positional: false,
               desc: 'how many recent prompts to pin', placeholder: 'N'
+  opt :config, type: :boolean, desc: 'open the command list in $EDITOR'
 
   proc do |opts|
-    cmd = Array(opts[:args])
-    error 'usage: llm wrap [--lines N] [--] <command> [args...]' if cmd.empty?
-
     # Required lazily - llm.rb also runs as a per-prompt hook (`llm prompt
     # hook`), which should not pay to load pty/io-console. `_llm_root` is a
     # local from the file scope; the block closes over it (instance_exec
     # rebinds self, not locals).
     require File.join(_llm_root, 'lib/llm/wrap')
 
+    if opts[:config]
+      editor = ENV['EDITOR'] || ENV['VISUAL']
+      error '$EDITOR not set' unless editor
+      say.green "created #{LlmWrap::Config.path}" if LlmWrap::Config.seed
+      exit system(editor, LlmWrap::Config.path) ? 0 : 1
+    end
+
+    cmd = Array(opts[:args])
+
+    # Nothing asked for: offer the list rather than a usage error. The picker
+    # shows each line as it was written - re-joining a split argv would quote
+    # it back differently from what is in the file.
+    if cmd.empty?
+      LlmWrap::Config.seed
+      choices = LlmWrap::Config.lines
+      unless choices.any? { |line| LlmWrap::Config.runnable?(line) }
+        error "no commands in #{LlmWrap::Config.path} - add one with: llm wrap --config"
+      end
+
+      idx = choose('wrap which command?', choices, skip: ->(line) { !LlmWrap::Config.runnable?(line) })
+      next say.gray('cancelled') unless idx
+
+      cmd = LlmWrap::Config.argv(choices[idx])
+    end
+
     # The wrapper renames itself after the program it runs, so that a pane
     # watcher can still see which agent is in there - which leaves nothing
     # behind that says how the pane was started. This is that: the invocation
@@ -179,7 +213,7 @@ namespace :memory do
 
   task :list do
     desc 'List stored memories with type and one-line description'
-    example 'llm memory list'
+    example 'memory list'
 
     proc do
       files = Dir[File.join(STORE, '*.md')].sort
@@ -199,7 +233,7 @@ namespace :memory do
 
   task :read do
     desc 'Print the full content of a memory (frontmatter + body)'
-    example 'llm memory read user-role'
+    example 'memory read user-role'
 
     proc do |opts|
       name = opts[:args].first
@@ -251,7 +285,7 @@ namespace :memory do
 
   task :delete do
     desc 'Delete a memory by name'
-    example 'llm memory delete old-fact'
+    example 'memory delete old-fact'
 
     proc do |opts|
       name = opts[:args].first
@@ -265,7 +299,7 @@ namespace :memory do
 
   task :search do
     desc 'Search memory bodies for a query string (case-insensitive)'
-    example 'llm memory search react'
+    example 'memory search react'
 
     proc do |opts|
       query = opts[:args].first
@@ -524,8 +558,8 @@ namespace :prompt do
 
   task :expand do
     desc 'Expand prompt token(s) and print the resulting context'
-    example 'llm prompt:expand :foo :bar'
-    example 'llm prompt:expand foo:'
+    example 'prompt:expand :foo :bar'
+    example 'prompt:expand foo:'
 
     proc do |opts|
       input = opts[:args].join(' ')
@@ -561,3 +595,104 @@ namespace :prompt do
     end
   end
 end
+
+# The namespace's sibling task: `llm plan` explains the thing, `llm plan:*`
+# does it. The command list underneath is hammer's own, not a copy.
+task :plan do
+  desc 'How the /plan bundle apply works: logic, bundle format, exit codes'
+  example 'plan'
+
+  proc do
+    say LlmPlan.readme
+    say ''
+    self.class.print_help 'plan:'
+  end
+end
+
+namespace :plan do
+  # Helpers live inside the namespace block for the same reason as :memory -
+  # a top-level `helpers do` lands on the root class, which namespaces do not
+  # inherit from.
+  private
+
+  def load_bundle(opts)
+    path = opts[:args].first
+    error 'usage: llm plan:<apply|check|verify|revert> ./tmp/plan-[SLUG].json' unless path
+    LlmPlan::Bundle.new(path)
+  rescue LlmPlan::Error => e
+    error e.message
+  end
+
+  # Hammer owns colour (and turns it off for a non-tty), so hand its painter
+  # to the report rather than teaching the report about ANSI.
+  def render(outcome)
+    report = LlmPlan::Report.new(outcome, paint: Hammer::Shell.method(:paint))
+    report.lines.each { |text, color| say text, color }
+  end
+
+  def run_verify(runner)
+    result = runner.verify { |cmd| say "  > #{cmd}", :cyan }
+    result.ok ? say('  verify ok', :green) : say("  FAIL #{result.failed_command}", :red)
+    result
+  end
+
+  task :apply do
+    # Composed from plan.md rather than written out again - see `llm plan`.
+    desc ['Apply a /plan bundle: sha1-checked edits now, drift handed back to you.',
+          "The bundle, normally ./tmp/plan-[SLUG].json:\n\n#{LlmPlan.section('The bundle')}",
+          LlmPlan.section('Drift'),
+          LlmPlan.section('Exit codes')].join("\n\n")
+    example 'plan:apply ./tmp/plan-note-anchor.json'
+
+    proc do |opts|
+      bundle  = load_bundle(opts)
+      runner  = LlmPlan::Runner.new(bundle)
+      outcome = runner.apply
+
+      render outcome
+      outcome.verify = run_verify(runner) if outcome.clean?
+
+      exit outcome.exit_code
+    end
+  end
+
+  task :check do
+    desc ['Dry run: the summary to read before approving a plan. Writes nothing.',
+          LlmPlan.section('Summary')].join("\n\n")
+    example 'plan:check ./tmp/plan-note-anchor.json'
+    example 'plan:check --md ./tmp/plan-note-anchor.json'
+
+    opt :md, type: :boolean, desc: 'emit the summary as markdown, to paste into a reply'
+
+    proc do |opts|
+      outcome = LlmPlan::Runner.new(load_bundle(opts)).apply(check_only: true)
+      opts[:md] ? puts(LlmPlan::MarkdownReport.new(outcome).to_s) : render(outcome)
+      exit outcome.exit_code
+    end
+  end
+
+  task :verify do
+    desc <<~D
+      Run only the bundle's verify commands.
+
+      For after you have closed a drift by hand, or fixed what a failing verify
+      caught. Exit 0 green, 20 failed.
+    D
+    example 'plan:verify ./tmp/plan-note-anchor.json'
+
+    proc do |opts|
+      exit run_verify(LlmPlan::Runner.new(load_bundle(opts))).ok ? 0 : 20
+    end
+  end
+
+  task :revert do
+    desc 'Undo an applied bundle from <slug>.bak: restore changed and deleted files, remove created ones.'
+    example 'plan:revert ./tmp/plan-note-anchor.json'
+
+    proc do |opts|
+      LlmPlan::Runner.new(load_bundle(opts)).revert.each { |path| say "  restored #{path}", :green }
+    rescue LlmPlan::Error => e
+      error e.message
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lux-hammer
 version: !ruby/object:Gem::Version
-  version: 0.3.20
+  version: 0.3.22
 platform: ruby
 authors:
 - Dino Reic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-26 00:00:00.000000000 Z
+date: 2026-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -55,15 +55,7 @@ files:
 - "./lib/lux-hammer.rb"
 - "./recipes/deploy.rb"
 - "./recipes/git-helper.rb"
-- "./recipes/lib/deploy/boot.rb"
-- "./recipes/lib/deploy/commands.rb"
-- "./recipes/lib/deploy/config.rb"
-- "./recipes/lib/deploy/context.rb"
-- "./recipes/lib/deploy/doctor.rb"
-- "./recipes/lib/deploy/hammer.rb"
-- "./recipes/lib/deploy/manifest.rb"
-- "./recipes/lib/deploy/ssh.rb"
-- "./recipes/lib/deploy/template.rb"
+- "./recipes/lib/llm/plan.rb"
 - "./recipes/lib/llm/usage.rb"
 - "./recipes/lib/llm/wrap.rb"
 - "./recipes/llm.rb"

data/recipes/lib/deploy/boot.rb

@@ -1,52 +0,0 @@
-require 'fileutils'
-require 'pathname'
-require 'open3'
-require 'set'
-require 'shellwords'
-require 'yaml'
-
-module LuxDeploy
-  # Recipe layout: this file and its siblings live under
-  # recipes/lib/deploy/, so ROOT points here and `templates/` sits
-  # right next to us (no gem root anymore).
-  ROOT ||= Pathname.new(__dir__)
-  VERSION ||= '0.2.0'
-
-  # Branches that select `.env` instead of `.env.staging`.
-  MAIN_BRANCHES ||= %w[master main]
-
-  # Server-side conventions. Not config-tunable because doctor and the
-  # deploy flow both hardcode these paths in the host setup. A different
-  # caddy/systemd layout means a different recipe.
-  PORT_RANGE  ||= (3010..3990).step(10).to_a
-  CADDY_SITES ||= '/etc/caddy/sites'
-  SYSTEMD_DIR ||= '/etc/systemd/system'
-
-  class Error < StandardError
-    def to_s
-      "ERROR: #{super}"
-    end
-  end
-
-  # Host-supplied defaults that sit under the user's .yaml. Set once by a
-  # wrapping plugin/Hammerfile (e.g. lux-fw seeds 'lux-web' / 'lux-apps'),
-  # consumed by Config.new. Empty by default so the recipe stays "generic".
-  @defaults = {}
-
-  class << self
-    attr_reader :defaults
-
-    def set_defaults(hash)
-      @defaults = (hash || {}).each_with_object({}) { |(k, v), h| h[k.to_s] = v }
-    end
-  end
-end
-
-require_relative 'config'
-require_relative 'ssh'
-require_relative 'template'
-require_relative 'doctor'
-require_relative 'context'
-require_relative 'manifest'
-require_relative 'commands'
-require_relative 'hammer'