yatfa 1.0.66 → 1.0.68

package/README.md

@@ -102,23 +102,46 @@ npx yatfa setup
 
 Launches interactive setup wizard to configure `yatfa.env.rb`.
 
+### Check Version
+
+```bash
+npx yatfa version
+npx yatfa -v
+npx yatfa --version
+```
+
+Prints the installed yatfa package version (e.g., `yatfa v1.0.67`).
+
 ### Run Agents
 
+When you run an agent, the CLI automatically:
+1. **Checks if the agent is already running** - prompts to Attach, Restart, or Cancel
+2. **Starts the agent** - creates the Docker container
+3. **Prompts to attach** - after starting, asks if you want to attach to the session
+
 ```bash
-# Start an agent
 npx yatfa worker
 npx yatfa planner
 npx yatfa reviewer
 npx yatfa researcher
 ```
 
-### Attach to Running Agents
+#### Non-interactive Mode (for CI/scripts)
 
 ```bash
-npx yatfa attach worker
+# Run without prompts
+npx yatfa worker --no-prompt
+# or
+YATFA_NO_PROMPT=1 npx yatfa worker
 ```
 
-Opens tmux session to view agent activity.
+### Attach to Running Agents (deprecated)
+
+The `attach` command still works but is deprecated. Running `npx yatfa <agent-type>` now prompts to attach automatically.
+
+```bash
+npx yatfa attach worker  # Deprecated - use 'npx yatfa worker' instead
+```
 
 ### List Running Agents
 
@@ -241,8 +264,10 @@ See hook files for implementation details and customization options.
 
 ## Attaching to Running Agent
 
+After starting an agent, the CLI will prompt you to attach. You can also attach directly:
+
 ```bash
-docker exec -it <container> tmux attach -t agent-wrapper
+docker exec -it <container> tmux attach -t agent
 ```
 
 Press `Ctrl+B` then `D` to detach.

package/agents.rb

@@ -144,6 +144,32 @@ If you encounter blocking problems or need to improve workflow:
 5. **Context:** Include what you tried, the error/blocker, and suggested fix (e.g., "Escalation: Need additional MCP tools for research").
 ESCALATION
 
+CLAW_HEADER = <<~HEADER
+You are the **YATFA CLAW** agent.
+
+**ROLE:** OpenClaw Gateway Runner.
+Your purpose is to run an OpenClaw gateway inside this container, providing a Telegram-based chat interface with the Pi agent.
+
+### OPERATIONAL MODE
+*   **Execution:** The OpenClaw gateway starts automatically and runs persistently.
+*   **Telegram Integration:** Chat messages from Telegram are forwarded to the Pi agent via the gateway.
+*   **Configuration:** Set via environment variables or `~/.openclaw/openclaw.json`.
+*   **Persistence:** Gateway data is stored in a Docker volume at `~/.openclaw/`.
+
+### ENVIRONMENT
+*   Sandboxed Docker container with ROOT privileges.
+*   Network mode: host (port 18789 exposed for gateway).
+*   OpenClaw installed globally via npm.
+HEADER
+
+CLAW_BOUNDARIES = <<~BOUNDARIES
+### ROLE BOUNDARIES
+*   This agent runs the OpenClaw gateway - it does NOT run Claude Code.
+*   No Yatfa MCP tools are available (that is a future enhancement).
+*   No git repositories are mounted.
+*   No skills are loaded.
+BOUNDARIES
+
 # Dynamic banner builder
 def build_banner(header:, boundaries:, escalation: nil, extra_sections: [])
   [
@@ -178,7 +204,7 @@ AGENT_CONFIGS = {
 
   'reviewer' => {
     name: 'yatfa-autonomous-reviewer',
-    skills: ['reviewer-workflow', 'memory', 'proposal-reviewer'],
+    skills: ['reviewer-workflow', 'qa-workflow', 'memory', 'proposal-reviewer'],
     banner: build_banner(
       header: REVIEWER_HEADER,
       boundaries: REVIEWER_BOUNDARIES,
@@ -194,5 +220,14 @@ AGENT_CONFIGS = {
       boundaries: RESEARCHER_BOUNDARIES,
       escalation: RESEARCHER_ESCALATION
     )
+  },
+
+  'claw' => {
+    name: 'yatfa-openclaw',
+    skills: [],
+    banner: build_banner(
+      header: CLAW_HEADER,
+      boundaries: CLAW_BOUNDARIES
+    )
   }
 }.freeze

package/bin/run-yatfa-agent.rb

@@ -2,8 +2,7 @@
 # frozen_string_literal: true
 
 # YATFA Agent Runner (Yet Another Tool For Agents)
-# Usage: npx yatfa [worker|planner|reviewer|researcher]
-#        npx yatfa attach [agent-type]
+# Usage: npx yatfa [worker|planner|reviewer|researcher|claw]
 #        npx yatfa setup
 #
 # Requirements:
@@ -18,13 +17,26 @@ require_relative "../lib/yatfa_agent/agent"
 require_relative "../lib/yatfa_agent/setup"
 require_relative "../agents"
 
+def show_version
+  require "json"
+  real_path = File.realpath(__FILE__)
+  package_json_path = File.join(File.dirname(real_path), "..", "package.json")
+  version = JSON.parse(File.read(package_json_path))["version"]
+  puts "yatfa v#{version}"
+  exit 0
+end
+
 def show_usage
   puts "YATFA Agent Runner (Yet Another Tool For Agents)"
   puts ""
   puts "Usage:"
-  puts "  npx yatfa setup                    # Interactive setup wizard"
-  puts "  npx yatfa [worker|planner|reviewer|researcher]  # Run agent"
-  puts "  npx yatfa attach [agent-type]      # Attach to running agent"
+  puts "  npx yatfa version                             # Show version"
+  puts "  npx yatfa setup                               # Interactive setup wizard"
+  puts "  npx yatfa [worker|planner|reviewer|researcher|claw] # Run agent (prompts to attach)"
+  puts ""
+  puts "Options:"
+  puts "  --no-prompt, -d    Run without prompts (for CI/scripts)"
+  puts "  YATFA_NO_PROMPT=1  Environment variable alternative"
   puts ""
   puts "Setup:"
   puts "  Run 'npx yatfa setup' for interactive configuration"
@@ -42,6 +54,13 @@ show_usage if ARGV.empty?
 
 command = ARGV[0].downcase
 
+# Set process title so ps/top shows the agent type instead of "node" (from npx)
+agent_type_for_title = %w[worker planner reviewer researcher claw].include?(command) ? command : "yatfa"
+Process.setproctitle("yatfa-#{agent_type_for_title}")
+
+# Handle version command
+show_version if %w[version -v --version].include?(command)
+
 # Handle setup command
 if command == "setup"
   wizard = YatfaAgent::Setup::SetupWizard.new
@@ -49,15 +68,28 @@ if command == "setup"
   exit 0
 end
 
-# Handle attach command
+# Resolve project root by walking up the directory tree.
+# This allows running `npx yatfa` from subfolders inside the project.
+# Skipped for setup (which creates new config in cwd).
+project_root = YatfaAgent::Config.find_project_root
+if project_root && project_root != Dir.pwd
+  puts "📂 Running from subfolder, using config from #{project_root}"
+  Dir.chdir(project_root)
+end
+
+# Handle attach command (deprecated - will still work)
 if command == "attach"
+  puts ""
+  puts "⚠️  Deprecation: The 'attach' command is deprecated"
+  puts "   Running `npx yatfa <agent-type>` now prompts to attach automatically."
+  puts ""
   agent_type = ARGV[1]&.downcase
   abort "Usage: npx yatfa attach [agent-type]" unless agent_type
   config = YatfaAgent::Config.load
   YatfaAgent::Config.fetch_repositories!(config)
   YatfaAgent::Agent.attach(agent_type, config, AGENT_CONFIGS)
 else
-  # Handle run commands (worker, planner, reviewer, researcher)
+  # Handle run commands (worker, planner, reviewer, researcher, claw)
   config = YatfaAgent::Config.load
   # Fetch repositories from Rails API before building
   YatfaAgent::Config.fetch_repositories!(config)

package/bin/yatfa

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+# yatfa - Agent runner wrapper
+# Sets process name to yatfa-<agent-type> so ps/top/Activity Monitor shows it clearly.
+DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exec -a "yatfa-${1:-yatfa}" ruby "$DIR/run-yatfa-agent.rb" "$@"

package/lib/yatfa_agent/agent.rb

@@ -1,8 +1,113 @@
 # frozen_string_literal: true
-require 'fileutils'
 
 module YatfaAgent
   module Agent
+    # Check if container is currently running
+    def self.container_running?(container_name)
+      result = IO.popen(["docker", "ps", "--filter", "name=^#{container_name}$", "--format", "{{.Names}}"], err: File::NULL, &:read).strip
+      !result.empty?
+    end
+
+    # Check if container exists (running or stopped)
+    def self.container_exists?(container_name)
+      result = IO.popen(["docker", "ps", "-a", "--filter", "name=^#{container_name}$", "--format", "{{.Names}}"], err: File::NULL, &:read).strip
+      !result.empty?
+    end
+
+    # Prompt user for input with a default value
+    def self.prompt(message, default: nil, options: nil)
+      loop do
+        print message
+        input = $stdin.gets&.strip&.downcase || ""
+
+        # Handle default on empty input
+        if input.empty? && default
+          return default
+        end
+
+        # If options specified, validate input
+        if options
+          valid = options.any? { |opt| opt.downcase == input || opt.downcase.start_with?(input) }
+          if valid
+            # Return the full option that matches
+            return options.find { |opt| opt.downcase.start_with?(input) }
+          end
+          puts "   Invalid option. Please choose: #{options.join('/')}"
+        else
+          return input
+        end
+      end
+    end
+
+    # Check if running in non-interactive mode
+    def self.non_interactive?
+      !$stdin.tty? || ENV['YATFA_NO_PROMPT'] == '1' || ARGV.include?('--no-prompt') || ARGV.include?('-d')
+    end
+
+    # Handle running container: prompt user for action
+    def self.handle_running_container(agent_type, container_name, config, agent_configs)
+      puts "⚠️  #{agent_type} agent is already running (#{container_name})"
+      puts ""
+
+      if non_interactive?
+        puts "   Running in non-interactive mode. Run 'npx yatfa #{agent_type}' to attach, or stop the container first."
+        puts "   docker stop #{container_name}"
+        exit 0
+      end
+
+      choice = prompt("   [A]ttach / [R]estart / [C]ancel? [A/r/c]: ", default: "A", options: %w[A R C])
+
+      case choice
+      when "A"
+        puts ""
+        attach(agent_type, config, agent_configs)
+      when "R"
+        puts ""
+        puts "🔄 Stopping existing container..."
+        system("docker", "stop", container_name, err: File::NULL, out: File::NULL)
+        system("docker", "rm", "-f", container_name, err: File::NULL, out: File::NULL)
+        return true # Continue with start
+      when "C"
+        puts "   Cancelled."
+        exit 0
+      end
+    end
+
+    # Banner file is no longer generated on the host.
+    # System prompt is generated inside the container by setup-agent.rb
+    # using AGENT_TYPE and REPOSITORIES_CONTEXT env vars.
+
+    # Handle stopped container: prompt user for action
+    def self.handle_stopped_container(agent_type, container_name, config, agent_configs)
+      puts "⚠️  #{agent_type} agent container exists but is stopped (#{container_name})"
+      puts ""
+
+      if non_interactive?
+        puts "   Non-interactive mode: starting existing container."
+        system("docker", "start", container_name, out: File::NULL)
+        puts "✅ Agent started in background"
+        exit 0
+      end
+
+      choice = prompt("   [S]tart existing / [R]ecreate / [C]ancel? [S/r/c]: ", default: "S", options: %w[S R C])
+
+      case choice
+      when "S"
+        puts ""
+        puts "🔄 Starting existing container..."
+        system("docker", "start", container_name, out: File::NULL)
+        puts "✅ Agent started in background"
+        exit 0
+      when "R"
+        puts ""
+        puts "🔄 Removing stopped container..."
+        system("docker", "rm", "-f", container_name, err: File::NULL, out: File::NULL)
+      when "C"
+        puts "   Cancelled."
+        exit 0
+      end
+    end
+
     def self.run(agent_type, config, agent_configs)
       unless agent_configs.keys.include?(agent_type)
         puts "❌ Unknown agent type: #{agent_type}"
@@ -14,48 +119,65 @@ module YatfaAgent
       agent_config = config.dig("agents", agent_type) || {}
       container_name = agent_config["container_name"] || agent_def[:name]
 
-      puts "🚀 Starting #{agent_type} agent..."
-
-      # Stop existing container if running
-      system("docker", "rm", "-f", container_name, err: File::NULL, out: File::NULL)
-
-      # Write banner to a persistent temp file (not auto-deleted)
-      banner_path = "/tmp/yatfa-banner-#{agent_type}.txt"
-      FileUtils.rm_rf(banner_path)
-
-      # Append repository context to banner
-      banner_content = agent_def[:banner].dup
-      if config["repositories"]&.any?
-        sorted_repos = config["repositories"].sort_by { |r| r["position"] || 0 }
-        repo_info = sorted_repos.map do |repo|
-          name = repo["name"]
-          path = repo["path_in_sandbox"] || "/workspace/#{name}"
-          "  - **#{name}**: #{path}"
-        end.join("\n")
-
-        banner_content += "\n\n## REPOSITORY STRUCTURE\n\n"
-        banner_content += "This project has #{sorted_repos.count} repositories:\n\n"
-        banner_content += "#{repo_info}\n\n"
+      # Check if container is already running and handle interactively
+      if container_running?(container_name)
+        should_continue = handle_running_container(agent_type, container_name, config, agent_configs)
+        # If user chose Attach or Cancel, the method calls exec/exit, so we never reach here
+        # If user chose Restart, should_continue is true and we proceed to start a new container
+        return unless should_continue
+      elsif container_exists?(container_name)
+        handle_stopped_container(agent_type, container_name, config, agent_configs)
       end
 
-      File.write(banner_path, banner_content)
+      puts "🚀 Starting #{agent_type} agent..."
 
-      docker_cmd = build_docker_command(container_name, agent_type, config, agent_config, agent_def, banner_path)
+      docker_cmd = build_docker_command(container_name, agent_type, config, agent_config, agent_def)
 
       success = system(*docker_cmd)
 
       if success
         puts "✅ Agent started in background"
         puts ""
-        puts "   Attach: npx yatfa attach #{agent_type}"
-        puts "   Logs:   docker logs -f #{container_name}"
-        puts "   Stop:   docker stop #{container_name}"
+
+        # Prompt to attach (interactive mode only)
+        prompt_to_attach(agent_type, container_name, config, agent_configs)
       else
         puts "❌ Failed to start agent"
         exit 1
       end
     end
 
+    # Prompt user to attach after starting a new agent
+    def self.prompt_to_attach(agent_type, container_name, config, agent_configs)
+      if non_interactive?
+        # Non-interactive: just print helpful info
+        puts "   Logs:   docker logs -f #{container_name}"
+        puts "   Stop:   docker stop #{container_name}"
+        puts "   Attach: docker exec -it #{container_name} tmux attach -t agent"
+        return
+      end
+
+      choice = prompt("   Agent started. Attach to session? [Y/n]: ", default: "Y", options: %w[Y N])
+
+      if choice == "Y"
+        puts ""
+        # Wait briefly for container to initialize
+        print "   Waiting for agent to initialize"
+        5.times do
+          print "."
+          sleep 1
+        end
+        puts ""
+        attach(agent_type, config, agent_configs)
+      else
+        puts ""
+        puts "   Agent is running in background."
+        puts "   Logs:   docker logs -f #{container_name}"
+        puts "   Stop:   docker stop #{container_name}"
+        puts "   Attach: docker exec -it #{container_name} tmux attach -t agent"
+      end
+    end
+
     def self.attach(agent_type, config, agent_configs)
       unless agent_configs.keys.include?(agent_type)
         puts "❌ Unknown agent type: #{agent_type}"
@@ -66,7 +188,7 @@ module YatfaAgent
       agent_config = config.dig("agents", agent_type) || {}
       container_name = agent_config["container_name"] || agent_def[:name]
 
-      running = `docker ps --filter name=^#{container_name}$ --format '{{.Names}}'`.strip
+      running = IO.popen(["docker", "ps", "--filter", "name=^#{container_name}$", "--format", "{{.Names}}"], err: File::NULL, &:read).strip
 
       if running.empty?
         puts "⚠️  #{agent_type} agent is not running. Auto-starting..."
@@ -95,7 +217,7 @@ module YatfaAgent
 
     private
 
-    def self.build_docker_command(container_name, agent_type, config, agent_config, agent_def, banner_path)
+    def self.build_docker_command(container_name, agent_type, config, agent_config, agent_def)
       docker_cmd = [
         "docker", "run", "-d",
         "--name", container_name,
@@ -110,7 +232,7 @@ module YatfaAgent
       merged_env = {}
       merged_env.merge!(config["env"]) if config["env"]
       merged_env.merge!(agent_config["env"]) if agent_config["env"]
-      
+
       if merged_env.any?
         merged_env.each do |k, v|
           docker_cmd += ["-e", "#{k}=#{v}"]
@@ -124,22 +246,51 @@ module YatfaAgent
         end
       end
 
-      docker_cmd += [
-        "-v", "#{banner_path}:/etc/yatfa/system-prompt.txt:ro",
-        "-e", "YATFA_VERSION=main",
-        "-e", "SKILLS=#{agent_def[:skills]&.join(',')}",
-        "-e", "AGENT_TYPE=#{agent_type}",
-        "-e", "YATFA_URL=#{YatfaAgent::Config.yatfa_url(config)}",
-        "-e", "YATFA_API_KEY=#{agent_config['mcp_api_key']}"
-      ]
+      if agent_type == "claw"
+        # Claw-specific Docker command setup
+        docker_cmd += [
+          "-e", "AGENT_TYPE=#{agent_type}",
+          "-e", "YATFA_VERSION=main"
+        ]
+
+        # Add persistence volume for OpenClaw config and data (scoped per container)
+        docker_cmd += ["-v", "#{container_name}-openclaw-data:/home/claude/.openclaw"]
+
+        # Auto-inject telegram_bot_token as env var so users don't need to duplicate in env block
+        if agent_config["telegram_bot_token"]
+          docker_cmd += ["-e", "OPENCLAW_TELEGRAM_BOT_TOKEN=#{agent_config['telegram_bot_token']}"]
+        end
+
+        # Pass YATFA_URL if configured (optional for claw)
+        if config["yatfa_url"]
+          docker_cmd += ["-e", "YATFA_URL=#{config['yatfa_url']}"]
+          docker_cmd += ["-e", "YATFA_API_URL=#{config['yatfa_url']}/api/v1"]
+        end
+
+        # Pass MCP API key if configured (for future MCP integration)
+        if agent_config["mcp_api_key"]
+          docker_cmd += ["-e", "YATFA_API_KEY=#{agent_config['mcp_api_key']}"]
+        end
 
-      add_github_auth!(docker_cmd, config)
-      add_git_config!(docker_cmd, config)
-      add_repository_mounts!(docker_cmd, config)
-      add_development_mounts!(docker_cmd)
+        add_development_mounts!(docker_cmd)
+      else
+        # Standard agent setup (worker, planner, reviewer, researcher)
+        docker_cmd += [
+          "-e", "YATFA_VERSION=main",
+          "-e", "SKILLS=#{agent_def[:skills]&.join(',')}",
+          "-e", "AGENT_TYPE=#{agent_type}",
+          "-e", "YATFA_URL=#{YatfaAgent::Config.yatfa_url(config)}",
+          "-e", "YATFA_API_KEY=#{agent_config['mcp_api_key']}"
+        ]
+
+        add_github_auth!(docker_cmd, config)
+        add_git_config!(docker_cmd, config)
+        add_repository_mounts!(docker_cmd, config)
+        add_development_mounts!(docker_cmd)
+      end
 
       local_setup_script = File.join(File.dirname(__FILE__), "..", "..", "setup-agent.rb")
-      
+
       if File.exist?(local_setup_script)
         docker_cmd += [Config.image_name(config), "ruby", "/tmp/setup-agent.rb"]
       else
@@ -208,52 +359,27 @@ module YatfaAgent
 
     def self.add_development_mounts!(docker_cmd)
       # Check for local setup-agent.rb (for development)
-      local_setup_script = File.join(File.dirname(__FILE__), "..", "..", "setup-agent.rb")
-
-      # Check for local agent-bridge binaries (for development)
-      arch = `uname -m`.strip
-      linux_arch = (arch == "x86_64") ? "amd64" : "arm64"
-
-      # Try multiple possible paths for the binary (built Go binaries in dist/)
-      possible_paths = [
-        File.join(Dir.pwd, "overrides", "agent-bridge-linux-#{linux_arch}"),              # YATFA_SANDBOX/overrides
-        File.join(Dir.pwd, "yatfa-public", "dist", "agent-bridge-linux-#{linux_arch}"),  # Running from metafolder
-        File.join(Dir.pwd, "dist", "agent-bridge-linux-#{linux_arch}"),                    # Running from yatfa-public
+      # Try multiple paths: relative to gem, relative to cwd
+      setup_script_paths = [
+        File.join(File.dirname(__FILE__), "..", "..", "setup-agent.rb"),  # Relative to gem
+        File.join(Dir.pwd, "tinker-public", "setup-agent.rb"),             # Running from metafolder
+        File.join(Dir.pwd, "setup-agent.rb"),                               # Running from yatfa-public
       ]
 
-      linux_bridge = nil
-      possible_paths.each do |path|
+      local_setup_script = nil
+      setup_script_paths.each do |path|
         if File.exist?(path)
-          linux_bridge = path
+          local_setup_script = path
           break
         end
       end
 
-      local_bridge_default = File.join(Dir.pwd, "bin", "agent-bridge")
-      local_tmux = File.join(File.dirname(__FILE__), "..", "..", "bin", "agent-bridge-tmux")
-
-      if File.exist?(local_setup_script)
+      # Mount local setup-agent.rb for development if present
+      # Binaries are always fetched from bucket by setup-agent.rb
+      if local_setup_script
         puts "🔧 Using local setup-agent.rb for development"
         docker_cmd.concat(["-v", "#{File.expand_path(local_setup_script)}:/tmp/setup-agent.rb:ro"])
       end
-
-      if linux_bridge && File.exist?(linux_bridge)
-        puts "🔧 Using local linux binary: #{linux_bridge}"
-        docker_cmd.concat(["-v", "#{File.expand_path(linux_bridge)}:/tmp/agent-bridge:ro"])
-      elsif File.exist?(local_bridge_default)
-        # Check if it's a binary or script
-        is_script = File.read(local_bridge_default, 4) == "#!/b"
-        if is_script
-          puts "⚠️  bin/agent-bridge is a host wrapper script. Please run 'bin/build-bridge' to generate linux binaries."
-        else
-          puts "🔧 Using local agent-bridge binary"
-          docker_cmd.concat(["-v", "#{local_bridge_default}:/tmp/agent-bridge:ro"])
-        end
-      end
-
-      if File.exist?(local_tmux)
-        docker_cmd.concat(["-v", "#{File.expand_path(local_tmux)}:/tmp/agent-bridge-tmux:ro"])
-      end
     end
 
     def self.detect_agent_user(container_name)

package/lib/yatfa_agent/config.rb

@@ -4,17 +4,31 @@ require "json"
 
 module YatfaAgent
   module Config
+    # Walk up the directory tree from +start_dir+ (default: Dir.pwd)
+    # looking for yatfa.env.rb. Returns the directory containing the
+    # config file, or nil if not found.
+    def self.find_project_root(start_dir: Dir.pwd)
+      dir = File.expand_path(start_dir)
+      previous = nil
+
+      while dir != previous
+        return dir if File.exist?(File.join(dir, "yatfa.env.rb"))
+        previous = dir
+        dir = File.dirname(dir)
+      end
+
+      nil
+    end
+
     def self.load
-      rb_config_file = File.join(Dir.pwd, "yatfa.env.rb")
+      config_file = File.join(Dir.pwd, "yatfa.env.rb")
 
-      unless File.exist?(rb_config_file)
+      unless File.exist?(config_file)
         puts "❌ Error: yatfa.env.rb not found in current directory"
         puts ""
         puts "Create yatfa.env.rb:"
         puts "  {"
         puts "    yatfa_url: 'https://yatfa.example.com',  # Required"
-        puts "    # OR legacy name:"
-        puts "    rails_api_url: 'https://yatfa.example.com/api/v1',"
         puts "    # ..."
         puts "    # Paste your stripped .env content here:"
         puts "    dot_env: <<~ENV"
@@ -23,11 +37,11 @@ module YatfaAgent
         puts "    ENV"
         puts "  }"
         puts "  echo 'yatfa.env.rb' >> .gitignore"
-        puts "        exit 1"
+        exit 1
       end
 
       puts "⚙️  Loading configuration from yatfa.env.rb"
-      config = eval(File.read(rb_config_file), binding, rb_config_file)
+      config = eval(File.read(config_file), binding, config_file)
 
       # Convert symbols to strings for easier handling before JSON normalization
       config = config.transform_keys(&:to_s)
@@ -69,8 +83,7 @@ module YatfaAgent
     end
 
     def self.yatfa_url(config)
-      # Support both new name and legacy name for backwards compatibility
-      config["yatfa_url"] || config["yafta_url"] || config["rails_api_url"]
+      config["yatfa_url"] || config["rails_api_url"]
     end
 
     def self.api_url(config)

package/lib/yatfa_agent/setup.rb

@@ -106,8 +106,13 @@ module YatfaAgent
 
         @config[:agents] = {}
 
-        agent_types = ["worker", "planner", "reviewer", "researcher"]
+        agent_types = ["worker", "planner", "reviewer", "researcher", "claw"]
         agent_types.each do |agent_type|
+          if agent_type == "claw"
+            prompt_claw_agent
+            next
+          end
+
           print "#{agent_type.capitalize} API key (press Enter to skip): "
           key = STDIN.noecho(&:gets).chomp.strip
           puts ""
@@ -136,6 +141,43 @@ module YatfaAgent
         end
       end
 
+      def prompt_claw_agent
+        puts ""
+        puts "🐾 Claw Agent (OpenClaw Gateway)"
+        puts "   This runs an OpenClaw gateway with Telegram integration."
+        puts "   You'll need a Telegram Bot Token from @BotFather."
+        puts ""
+
+        print "Setup Claw agent? (press Enter to skip): "
+        confirm = Readline.readline.strip.downcase
+        return unless confirm == "y"
+
+        print "Telegram Bot Token: "
+        bot_token = STDIN.noecho(&:gets).chomp.strip
+        puts ""
+
+        if bot_token.empty?
+          puts "⊘ Skipped Claw agent (no token provided)"
+          return
+        end
+
+        agent_config = {
+          container_name: "#{@config[:project_name]}-claw",
+          telegram_bot_token: bot_token
+        }
+
+        # Optionally ask for MCP API key (for future Yatfa integration)
+        print "YATFA API key for MCP integration (optional, press Enter to skip): "
+        mcp_key = STDIN.noecho(&:gets).chomp.strip
+        puts ""
+        agent_config[:mcp_api_key] = mcp_key unless mcp_key.empty?
+
+        @config[:agents][:claw] = agent_config
+
+        puts "✅ Claw agent configured"
+        puts ""
+      end
+
       def prompt_git_config
         # Try to read from existing yatfa.env.rb
         existing_config = File.join(Dir.pwd, "yatfa.env.rb")
@@ -373,8 +415,19 @@ module YatfaAgent
         lines << "  agents: {"
         @config[:agents].each_with_index do |(agent_type, agent_config), idx|
           lines << "    #{agent_type}: {"
-          lines << "      mcp_api_key: #{agent_config[:mcp_api_key].inspect},"
-          lines << "      container_name: #{agent_config[:container_name].inspect}"
+          if agent_type.to_s == "claw"
+            lines << "      container_name: #{agent_config[:container_name].inspect},"
+            lines << "      telegram_bot_token: #{agent_config[:telegram_bot_token].inspect},"
+            lines << "      env: {"
+            lines << "        \"OPENCLAW_TELEGRAM_BOT_TOKEN\" => #{agent_config[:telegram_bot_token].inspect},"
+            if agent_config[:mcp_api_key]
+              lines << "        \"YATFA_API_KEY\" => #{agent_config[:mcp_api_key].inspect},"
+            end
+            lines << "      }"
+          else
+            lines << "      mcp_api_key: #{agent_config[:mcp_api_key].inspect},"
+            lines << "      container_name: #{agent_config[:container_name].inspect}"
+          end
           lines << "    }#{',' if idx < @config[:agents].size - 1}"
         end
         lines << "  }"

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "yatfa",
-  "version": "1.0.66",
+  "version": "1.0.68",
   "description": "YATFA - Yet Another Tool For Agents",
-  "bin": "./bin/run-yatfa-agent.rb",
+  "bin": "./bin/yatfa",
   "files": [
+    "bin/yatfa",
     "bin/run-yatfa-agent.rb",
     "agents.rb",
     "lib/",