def work(settings)
  loop do
    result = DRC.bput(@command, *PATTERNS)
    case result
    when 'pattern1' then swap_tool('tool1'); @command = 'new_command'
    when 'pattern2' then assemble_part
    when 'Roundtime' then finish if Flags['work-done']
    end
  end
end

[temper, hone, balance, lighten, reinforce].compact.each do |enhancement|
  DRC.wait_for_script_to_complete('forge', [enhancement, recipe['noun']])
end

@cloth = %w[silk wool burlap cotton felt linen electroweave steelsilk ...]
if @cloth.include?(@mat_type)
  # cloth workflow
else
  # leather workflow
end

@container = mortar (external) or bowl/cauldron (internal)
@pestle = pestle (external) or mixing stick (internal)
@verb = crush (external) or mix (internal)

# Water/alcohol containers that generate contents
if @settings.water_container
  fput("rub my #{@settings.water_container}")  # Generate water
end

@main_tool = if @type == 'stack' || @type == 'bone'
               @settings.carving_tools.find { |item| /\bsaw/i =~ item }
             else
               @settings.carving_tools.find { |item| /\bchisel/i =~ item }
             end

# Tracks whether item needs "my" prefix
@my = 'my '   # If we picked it up
@my = ''      # If it's too heavy (boulder) or on sled

def resume
  case DRC.bput("analyze my #{@noun}", ...)
  when /prevent|obstruct carving/ then cut
  when /riffler set/ then rub with rifflers
  when /rasp/ then rub with rasp
  when /polish/ then apply polish
  when /finished/ then exit
  end
end

# Direct invocation for mechanism making
# ;tinker mechanisms bronze 3
def mechanisms(args)
  DRCC.find_shaping_room(@hometown)
  fput("turn press to 4")
  count.times do
    DRCC.get_crafting_item("#{args.material} ingot", ...)
    swap_tool("shovel")   # Fuel the press
    swap_tool("pliers")
    work('push my ingot with press')
    # Combine stacks if making multiple
    DRCC.stow_crafting_item('mechanisms', @bag, nil)
  end
end

# Uses same pattern as forge.lic
if next_tool.include?('shovel') && @adjustable_tongs
  DRCC.get_adjust_tongs?('shovel', @bag, @bag_items, @belt, @adjustable_tongs)
end

# Special handling for mechanisms vs other parts
if part.include?("mechanism")
  until /is not required/ =~ DRC.bput("assemble my mechanism with my #{@noun}", ...)
    pause 0.05
  end
else
  DRC.bput("assemble my #{@noun} with my #{part}", ...)
end

# Tinker has unique symbiosis handling
def magic_cleanup
  DRC.bput('prepare symbiosis', ...)  # Prepare then release
  DRC.bput('release symbiosis', ...)
  DRC.bput('release spell', ...)
  DRC.bput('release mana', ...)
end

def trace_sigil(sigil)
  DRCI.get_item?("#{sigil} sigil")
  DRC.bput("study my #{sigil} sigil", /commit the design to memory/)
  DRC.bput("trace #{@item} on #{@brazier}", /trace its form/)
end

def forage_ingredient(ingredient)
  DRCT.walk_to(@forage_location)         # Go to forage room
  while quantity_needed >= 0
    DRC.bput("forage #{ingredient['name']} #{@alchemy_forage_type}")
    DRCI.put_away_item?(ingredient['name'], @alchemy_herb_storage)
    quantity_needed -= 6                  # Forage yields 6 units
  end
end

def prepare_ingredient(ingredient)
  DRCC.find_press_grinder_room(@press_location)
  while count(ingredient['name'], @alchemy_herb_storage) > 0
    if ingredient['output'].include?("dried")
      fput("put my #{ingredient['name']} in press")   # Drying
    else
      fput("put my #{ingredient['name']} in grinder") # Crushing
    end
    # Combine stacks up to 75
  end
end

# Counts stacked items using ordinals (first, second, etc.)
def count(item, container)
  $ORDINALS.each do |ordinal|
    # "count my first dried flower in my haversack"
    # Stops when "I could not find" is returned
  end
end

# Rank-based tier selection (12 tiers)
Tier 1:  0-25      # Extremely Easy
Tier 2:  26-50     # Very Easy
Tier 3:  51-100    # Easy
Tier 4:  101-175   # Simple
Tier 5:  176-300   # Basic
Tier 6:  301-425   # Somewhat Challenging
Tier 7:  426-550   # Challenging
Tier 8:  551-700   # Complicated
Tier 9:  701-850   # Intricate
Tier 10: 851-1175  # Difficult
Tier 11: 1176-1400 # Very Difficult
Tier 12: 1401+     # Extremely Difficult

def check_yarn
  buy_yarn if count < @yarn_quantity
end

def check_fabric(fabric_volumes)
  existing = count_fabric_in_bag
  stock_needed = ((fabric_volumes - existing) / 10.0).ceil
  order_fabric(stock_room, stock_needed, ...)
end

def check_wood
  buy_wood if count < 5
end

# Teaching support
def check_teaching
  @settings.classes_to_teach.each { |class| teach_to_pcs }
end

# Learning support
def check_listening
  DRC.listen?(@last_teacher, @settings.listen_observe)
  DRC.assess_teach  # Find classes to join
end

# All crafted items are disposed after completion
DRCI.dispose_trash(item_noun, @worn_trashcan, @worn_trashcan_verb)

case result
when 'clumps of molten metal' then turn crucible
when 'flickers' then push bellows
when 'needs more fuel' then push fuel with shovel/tongs
end

def initialize
  # 1. Calculate cost and buy fibers
  DRCM.ensure_copper_on_hand(data[:cost] * data[:count], @settings, @hometown)

  # 2. Order and combine fibers
  data[:count].times do |index|
    DRCT.order_item(stock_room, data[:index])
    if index == 0 && data[:name] == 'silk'
      # Silk requires special handling - cut at 10 yards
      DRC.bput('mark my fibers at 10', /mark it for cutting/)
      # Cut with scissors, drop excess
    else
      fput('combine my fiber')
    end
  end

  # 3. Find spinning wheel
  until DRCC.find_wheel(@hometown)
    move('go door')
    pause 30
  end

  # 4. Spin the fiber
  fput('put fiber on wheel')
  fput("adjust wheel to #{args.weight || 'heavy'}")

  # 5. State machine loop
  until DRC.left_hand || DRC.right_hand
    case DRC.bput('spin wheel', ...)
    when 'shade'    then fput('clean wheel')
    when 'twist'    then fput('turn wheel')
    when 'bunch'    then fput('push wheel')
    when 'slide'    then fput('push wheel')
    end
  end

  # 6. Stow result
  fput("stow my #{DRC.right_hand || DRC.left_hand}")
end

DRCC.find_anvil(hometown)       # Find empty anvil room
DRCC.find_empty_crucible(hometown)
DRCC.find_grindstone(hometown)
DRCC.find_sewing_room(hometown, override)
DRCC.find_shaping_room(hometown, override)
DRCC.find_enchanting_room(hometown, override)
DRCC.find_wheel(hometown)       # Spinning wheel
DRCC.find_press_grinder_room(hometown)

DRCC.get_crafting_item(name, bag, bag_items, belt, skip_exit = false)
DRCC.stow_crafting_item(name, bag, belt)
DRCC.get_adjust_tongs?(usage, bag, bag_items, belt, adjustable_tongs = false)

DRCC.find_recipe(chapter, match_string, book = 'book')
DRCC.find_recipe2(chapter, match_string, book = 'book', discipline = nil)
DRCC.recipe_lookup(recipes, item_name)

DRCC.check_consumables(name, room, number, bag, bag_items, belt, count = 3)
DRCC.repair_own_tools(info, tools, bag, bag_items, belt)

DRCC.empty_crucible?
DRCC.clean_anvil?
DRCC.clean_brazier?
DRCC.logbook_item(logbook, noun, container)
DRCC.crafting_cost(recipe, hometown, parts, quantity, material)
DRCC.count_raw_metal(container, type = nil)

# workorders.lic
items_per_stock = materials_info['stock-volume'] / recipe['volume']
spare_stock = (materials_info['stock-volume'] % recipe['volume']).nonzero?
scrap = spare_stock || (quantity % items_per_stock).nonzero?

# Example: stock-volume = 10, recipe volume = 3
# items_per_stock = 3 (can make 3 items per stock)
# spare_stock = 1 (1 volume leftover per stock)

# Common anti-pattern: Exit without cleanup
when 'I could not find what you were referring to'
  echo '*** ERROR TRYING TO CRAFT, EXITING ***'
  exit  # No stowing, no magic release, no state save

def craft_error(message, cleanup: true, exit_script: true)
  DRC.message("CRAFT ERROR: #{message}")
  if cleanup
    DRCC.stow_crafting_item(DRC.right_hand, @bag, @belt)
    DRCC.stow_crafting_item(DRC.left_hand, @bag, @belt)
    magic_cleanup
  end
  exit if exit_script
end

# Bug: "tap first flower in my haversack" matches "Inkin"
/You tap (.*) inside your|I could not find|You lightly tap/ =~
  DRC.bput("tap #{stack_descriptor} #{herb_for_tapping} in my #{@bag}", ...)
# "You lightly tap Inkin on the shoulder" triggers wrong branch

# State tracking via instance variable @tongs_status
# Problem 1: Not persistent across script restarts
# Problem 2: Can get out of sync with actual game state

case DRC.bput("adjust my tongs", ...)
when 'You lock the tongs'     # Now shovel
when 'With a yank you fold'   # Now tongs
when 'You cannot adjust'      # Not adjustable!
when 'You have no idea how'   # Not adjustable!

# forge.lic uses @adjustable_tongs at script start
@adjustable_tongs = DRCC.get_adjust_tongs?('reset tongs', @bag, @bag_items, @forging_belt)
# But if script crashes, @tongs_status in DRCC may be wrong on restart

# forge.lic
before_dying do
  Flags.delete('forge-assembly')
  Flags.delete('hone-done')      # 'hone-done' never created!
  Flags.delete('ingot-restow')
end

# Proposed: lib/dragonrealms/commons/common-crafting-errors.rb
module DRCC
  class CraftError < StandardError
    attr_reader :recoverable, :context

    def initialize(message, recoverable: false, context: {})
      @recoverable = recoverable
      @context = context
      super(message)
    end
  end

  def handle_craft_error(error, bag:, belt:)
    DRC.message("CRAFT: #{error.message}")
    cleanup_hands(bag, belt)
    raise unless error.recoverable
  end
end

# Proposed: Unified tool management
class CraftingToolManager
  def initialize(bag:, belt:, tools:)
    @bag = bag
    @belt = belt
    @tools = tools
    @current_tool = nil
  end

  def swap_to(tool_name, consumable: false)
    return if @current_tool == tool_name
    stow_current
    get_tool(tool_name, consumable: consumable)
    @current_tool = tool_name
  end

  def stow_current
    return unless @current_tool
    DRCC.stow_crafting_item(@current_tool, @bag, @belt)
    @current_tool = nil
  end
end

# Proposed: Material planning before crafting
class MaterialCalculator
  def calculate_needs(recipe, quantity, inventory)
    {
      stock_needed: calculate_stock(recipe, quantity, inventory[:stock]),
      parts_needed: calculate_parts(recipe, quantity, inventory[:parts]),
      consumables_needed: calculate_consumables(quantity, inventory[:consumables]),
      total_cost: calculate_cost(...)
    }
  end
end

# Current: @debug = args.debug || settings.debug_mode
# Proposed: Structured logging
module DRCC
  def debug_log(category, message, data = {})
    return unless @debug
    timestamp = Time.now.strftime('%H:%M:%S')
    echo "[#{timestamp}][#{category}] #{message} #{data.inspect}"
  end
end

# Some recipes lack full metadata
- work_order: false  # Many recipes excluded from work orders
- material: nil      # Missing material type for some
- part: nil          # Missing part requirements