yatfa 1.0.80 → 1.0.82

package/agents.rb

@@ -224,7 +224,7 @@ AGENT_CONFIGS = {
 
   'researcher' => {
     name: 'yatfa-autonomous-researcher',
-    skills: ['researcher-tactical', 'researcher-strategic', 'researcher-digest', 'researcher-telegram-processor', 'memory', 'session-learnings', 'proposal-execution', 'proposal-rework-responder', 'memory-consolidation', 'retrospective', 'knowledge-management', 'sentry-investigation', 'agent-browser'],
+    skills: ['researcher-tactical', 'researcher-strategic', 'researcher-digest', 'researcher-telegram-processor', 'researcher-meta-learning', 'memory', 'session-learnings', 'proposal-execution', 'proposal-rework-responder', 'memory-consolidation', 'retrospective', 'knowledge-management', 'sentry-investigation', 'agent-browser'],
     banner: build_banner(
       header: RESEARCHER_HEADER,
       boundaries: RESEARCHER_BOUNDARIES,

package/bin/run-yatfa-agent.rb

@@ -15,6 +15,8 @@ require_relative "../lib/yatfa_agent/config"
 require_relative "../lib/yatfa_agent/docker"
 require_relative "../lib/yatfa_agent/agent"
 require_relative "../lib/yatfa_agent/setup"
+require_relative "../lib/yatfa_agent/updater"
+require_relative "../lib/yatfa_agent/installer"
 require_relative "../agents"
 
 def current_version
@@ -66,6 +68,8 @@ def show_usage
   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 "  npx yatfa update-agents [--once]              # Update stale agent containers"
+  puts "  npx yatfa install-updater [--uninstall]       # Install/remove auto-update service"
   puts ""
   puts "Options:"
   puts "  --no-prompt, -d    Run without prompts (for CI/scripts)"
@@ -100,6 +104,21 @@ if command == "setup"
   exit 0
 end
 
+# Handle update-agents command (runs on host, no project config needed)
+if command == "update-agents"
+  once = ARGV.include?("--once")
+  interval = ENV.fetch("YATFA_UPDATE_INTERVAL", (4 * 60 * 60).to_s).to_i
+  YatfaAgent::Updater.run(once: once, interval: interval)
+  exit 0
+end
+
+# Handle install-updater command (runs on host, no project config needed)
+if command == "install-updater"
+  uninstall = ARGV.include?("--uninstall")
+  YatfaAgent::Installer.run(uninstall: uninstall)
+  exit 0
+end
+
 # 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).

package/lib/yatfa_agent/agent.rb

@@ -14,6 +14,19 @@ module YatfaAgent
       !result.empty?
     end
 
+    # Get container creation time
+    def self.container_creation_time(container_name)
+      result = IO.popen(["docker", "inspect", "--format", "{{.Created}}", container_name], err: File::NULL, &:read).strip
+      return nil if result.empty?
+      Time.parse(result)
+    rescue ArgumentError
+      nil
+    end
+
+    def self.format_time(t)
+      t.strftime("%H:%M")
+    end
+
     # Prompt user for input with a default value
     def self.prompt(message, default: nil, options: nil)
       loop do
@@ -47,6 +60,28 @@ module YatfaAgent
     # 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})"
+
+      # Check if container was created before last deploy
+      deploy_manifest = File.join(File.dirname(__FILE__), '..', '..', 'deploy', '.deploy-manifest.json')
+      version_file = File.join(File.dirname(__FILE__), '..', '..', 'VERSION')
+      stale = false
+
+      if File.exist?(version_file)
+        current_version = File.read(version_file).strip
+        container_version = IO.popen(["docker", "exec", container_name, "printenv", "YATFA_VERSION_NUM"], err: File::NULL, &:read).strip
+        if !container_version.empty? && container_version != current_version
+          puts "   🆕 New version deployed (container: #{container_version}, current: #{current_version})"
+          stale = true
+        end
+      elsif File.exist?(deploy_manifest)
+        deploy_time = File.mtime(deploy_manifest)
+        container_created = container_creation_time(container_name)
+        if container_created && container_created < deploy_time
+          puts "   🆕 New deploy detected (container from #{format_time(container_created)}, deploy at #{format_time(deploy_time)})"
+          stale = true
+        end
+      end
+
       puts ""
 
       if non_interactive?
@@ -55,7 +90,8 @@ module YatfaAgent
         exit 0
       end
 
-      choice = prompt("   [A]ttach / [R]estart / [C]ancel? [A/r/c]: ", default: "A", options: %w[A R C])
+      default_choice = stale ? "R" : "A"
+      choice = prompt("   [A]ttach / [R]estart / [C]ancel? [#{default_choice == 'R' ? 'a/R/c' : 'A/r/c'}]: ", default: default_choice, options: %w[A R C])
 
       case choice
       when "A"
@@ -135,9 +171,10 @@ module YatfaAgent
 
       # Build Docker image only when we're about to create a new container
       # (Restart, Recreate, or no existing container)
-      Docker.build_image(config)
+      # build_image returns the remote version to avoid a redundant fetch
+      remote_version = Docker.build_image(config)
 
-      docker_cmd = build_docker_command(container_name, agent_type, config, agent_config, agent_def)
+      docker_cmd = build_docker_command(container_name, agent_type, config, agent_config, agent_def, remote_version: remote_version)
 
       success = system(*docker_cmd)
 
@@ -248,7 +285,7 @@ module YatfaAgent
 
     private
 
-    def self.build_docker_command(container_name, agent_type, config, agent_config, agent_def)
+    def self.build_docker_command(container_name, agent_type, config, agent_config, agent_def, remote_version: nil)
       docker_cmd = [
         "docker", "run", "-d",
         "--name", container_name,
@@ -258,6 +295,19 @@ module YatfaAgent
         "--tmpfs", "/rails/log"
       ]
 
+      # Inject current version for staleness detection
+      version_file = File.join(File.dirname(__FILE__), '..', '..', 'VERSION')
+      if File.exist?(version_file)
+        version = File.read(version_file).strip
+        docker_cmd += ["-e", "YATFA_VERSION_NUM=#{version}"] unless version.empty?
+      end
+
+      # Add yatfa.version label for updater daemon to detect stale containers
+      # Uses deployed_at from remote version.json (already fetched by build_image)
+      if remote_version
+        docker_cmd += ["--label", "yatfa.version=#{remote_version}"]
+      end
+
       # Inject custom environment variables from config
       # Merge global env with agent-specific env (agent-specific takes precedence)
       merged_env = {}

package/lib/yatfa_agent/docker.rb

@@ -117,6 +117,9 @@ module YatfaAgent
       write_build_stamp(remote_version) if remote_version
 
       puts "✅ Docker image built"
+
+      # Return the remote version so callers can reuse it (avoids duplicate fetch)
+      remote_version
     end
   end
 end

package/lib/yatfa_agent/installer.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module YatfaAgent
+  module Installer
+    SERVICE_NAME = "yatfa-update-agents"
+
+    # Install or uninstall the updater system service
+    # @param uninstall [Boolean] if true, remove the service
+    def self.run(uninstall: false)
+      os = detect_os
+
+      case os
+      when :linux
+        handle_systemd(uninstall: uninstall)
+      when :macos
+        handle_launchd(uninstall: uninstall)
+      else
+        puts "❌ Unsupported operating system: #{os}"
+        puts "   Supported: Linux (systemd), macOS (launchd)"
+        exit 1
+      end
+    end
+
+    # Detect the operating system
+    # @return [Symbol] :linux, :macos, or :unknown
+    def self.detect_os
+      case RUBY_PLATFORM
+      when /linux/
+        :linux
+      when /darwin/
+        :macos
+      else
+        :unknown
+      end
+    end
+
+    # Check if systemctl is available
+    # @return [Boolean]
+    def self.systemd_available?
+      system("which systemctl", out: File::NULL, err: File::NULL)
+    end
+
+    # ─── Systemd (Linux) ─────────────────────────────────────────────
+
+    def self.handle_systemd(uninstall: false)
+      unless systemd_available?
+        puts "❌ systemctl not found. Is systemd installed?"
+        exit 1
+      end
+
+      unit_path = systemd_unit_path
+      npx_path = find_npx_path
+
+      if uninstall
+        uninstall_systemd(unit_path)
+      else
+        install_systemd(unit_path, npx_path)
+      end
+    end
+
+    def self.systemd_unit_path
+      # Use user-level systemd (runs as current user, not root)
+      dir = File.expand_path("~/.config/systemd/user")
+      FileUtils.mkdir_p(dir)
+      File.join(dir, "#{SERVICE_NAME}.service")
+    end
+
+    def self.install_systemd(unit_path, npx_path)
+      project_root = Dir.pwd
+
+      unit_content = <<~UNIT
+        [Unit]
+        Description=YATFA Agent Updater - Auto-update agent containers
+        After=docker.service
+
+        [Service]
+        Type=simple
+        ExecStart=#{npx_path} yatfa update-agents
+        WorkingDirectory=#{project_root}
+        Restart=on-failure
+        RestartSec=60
+        Environment=PATH=#{File.dirname(npx_path)}:/usr/local/bin:/usr/bin:/bin
+
+        [Install]
+        WantedBy=default.target
+      UNIT
+
+      File.write(unit_path, unit_content)
+      puts "📝 Written systemd unit to #{unit_path}"
+
+      # Reload systemd
+      system("systemctl", "--user", "daemon-reload", out: File::NULL, err: File::NULL)
+      puts "✅ Reloaded systemd"
+
+      # Enable and start
+      system("systemctl", "--user", "enable", SERVICE_NAME, out: File::NULL, err: File::NULL)
+      puts "✅ Enabled #{SERVICE_NAME} (starts on login)"
+
+      if system("systemctl", "--user", "start", SERVICE_NAME, out: File::NULL, err: File::NULL)
+        puts "✅ Started #{SERVICE_NAME}"
+      else
+        puts "⚠️  Could not start #{SERVICE_NAME}. Check: systemctl --user status #{SERVICE_NAME}"
+      end
+
+      # Enable lingering so service runs even when user is logged out
+      username = ENV["USER"] || `whoami`.strip
+      unless system("loginctl", "enable-linger", username, out: File::NULL, err: File::NULL)
+        puts "⚠️  Could not enable linger. Service will stop when you log out."
+        puts "   Fix: sudo loginctl enable-linger #{username}"
+      end
+
+      puts ""
+      puts "🎉 Updater installed as systemd user service"
+      puts ""
+      puts "   Status:   systemctl --user status #{SERVICE_NAME}"
+      puts "   Logs:     journalctl --user -u #{SERVICE_NAME} -f"
+      puts "   Stop:     systemctl --user stop #{SERVICE_NAME}"
+      puts "   Uninstall: npx yatfa install-updater --uninstall"
+    end
+
+    def self.uninstall_systemd(unit_path)
+      # Stop and disable
+      system("systemctl", "--user", "stop", SERVICE_NAME, out: File::NULL, err: File::NULL)
+      system("systemctl", "--user", "disable", SERVICE_NAME, out: File::NULL, err: File::NULL)
+
+      # Remove unit file
+      FileUtils.rm_f(unit_path)
+      puts "🗑️  Removed #{unit_path}"
+
+      # Reload systemd
+      system("systemctl", "--user", "daemon-reload", out: File::NULL, err: File::NULL)
+      puts "✅ Reloaded systemd"
+
+      puts ""
+      puts "✅ Updater service uninstalled"
+    end
+
+    # ─── Launchd (macOS) ─────────────────────────────────────────────
+
+    def self.handle_launchd(uninstall: false)
+      plist_path = launchd_plist_path
+      npx_path = find_npx_path
+
+      if uninstall
+        uninstall_launchd(plist_path)
+      else
+        install_launchd(plist_path, npx_path)
+      end
+    end
+
+    def self.launchd_plist_path
+      dir = File.expand_path("~/Library/LaunchAgents")
+      FileUtils.mkdir_p(dir)
+      File.join(dir, "com.yatfa.#{SERVICE_NAME}.plist")
+    end
+
+    def self.install_launchd(plist_path, npx_path)
+      project_root = Dir.pwd
+
+      plist_content = <<~PLIST
+        <?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+            <key>Label</key>
+            <string>com.yatfa.#{SERVICE_NAME}</string>
+            <key>ProgramArguments</key>
+            <array>
+                <string>#{npx_path}</string>
+                <string>yatfa</string>
+                <string>update-agents</string>
+            </array>
+            <key>WorkingDirectory</key>
+            <string>#{project_root}</string>
+            <key>RunAtLoad</key>
+            <true/>
+            <key>KeepAlive</key>
+            <true/>
+            <key>StandardOutPath</key>
+            <string>#{File.expand_path("~/.yatfa/updater.log")}</string>
+            <key>StandardErrorPath</key>
+            <string>#{File.expand_path("~/.yatfa/updater.log")}</string>
+            <key>EnvironmentVariables</key>
+            <dict>
+                <key>PATH</key>
+                <string>#{File.dirname(npx_path)}:/usr/local/bin:/usr/bin:/bin</string>
+            </dict>
+        </dict>
+        </plist>
+      PLIST
+
+      # Create log directory
+      FileUtils.mkdir_p(File.expand_path("~/.yatfa"))
+
+      File.write(plist_path, plist_content)
+      puts "📝 Written launchd plist to #{plist_path}"
+
+      # Load the plist
+      system("launchctl", "load", plist_path, out: File::NULL, err: File::NULL)
+      puts "✅ Loaded #{SERVICE_NAME}"
+
+      puts ""
+      puts "🎉 Updater installed as launchd agent"
+      puts ""
+      puts "   Logs:     tail -f ~/.yatfa/updater.log"
+      puts "   Unload:   launchctl unload #{plist_path}"
+      puts "   Uninstall: npx yatfa install-updater --uninstall"
+    end
+
+    def self.uninstall_launchd(plist_path)
+      # Unload first
+      system("launchctl", "unload", plist_path, out: File::NULL, err: File::NULL)
+
+      # Remove plist
+      FileUtils.rm_f(plist_path)
+      puts "🗑️  Removed #{plist_path}"
+
+      puts ""
+      puts "✅ Updater service uninstalled"
+    end
+
+    # ─── Helpers ─────────────────────────────────────────────────────
+
+    # Find the full path to npx
+    # @return [String] path to npx
+    def self.find_npx_path
+      result = `which npx 2>/dev/null`.strip
+      return result unless result.empty?
+
+      # Common paths to check
+      candidates = [
+        "/usr/local/bin/npx",
+        "/usr/bin/npx",
+        File.expand_path("~/.npm/bin/npx"),
+        File.expand_path("~/.nvm/versions/node/*/bin/npx")
+      ]
+
+      candidates.each do |path|
+        # Handle glob patterns
+        Dir.glob(path).each do |expanded|
+          return expanded if File.executable?(expanded)
+        end
+      end
+
+      # Fallback
+      "npx"
+    end
+  end
+end

package/lib/yatfa_agent/updater.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+
+module YatfaAgent
+  module Updater
+    DEFAULT_CHECK_INTERVAL = 4 * 60 * 60 # 4 hours in seconds
+    VERSION_LABEL = "yatfa.version"
+
+    # Run the updater daemon
+    # @param once [Boolean] if true, run a single check and exit
+    # @param interval [Integer] check interval in seconds (default 4h)
+    def self.run(once: false, interval: DEFAULT_CHECK_INTERVAL)
+      puts "🔄 YATFA Agent Updater"
+      puts "   Mode: #{once ? 'single check' : "daemon (every #{interval / 3600}h)"}"
+      puts ""
+
+      if once
+        perform_check
+      else
+        loop do
+          perform_check
+          puts ""
+          puts "💤 Next check in #{interval / 3600} hours (at #{(Time.now + interval).strftime('%H:%M')})"
+          sleep(interval)
+        end
+      end
+    end
+
+    # Perform a single update check cycle
+    def self.perform_check
+      puts "🔍 [#{Time.now.strftime('%Y-%m-%d %H:%M:%S')}] Checking for updates..."
+
+      # 1. Fetch remote version
+      remote_version = Docker.fetch_remote_version
+      unless remote_version
+        puts "⚠️  Could not fetch remote version, skipping check"
+        return
+      end
+
+      puts "   Remote version: #{remote_version[0..19]}..."
+
+      # 2. Find yatfa-managed containers
+      containers = list_yatfa_containers
+      if containers.empty?
+        puts "   No yatfa-managed containers found"
+        return
+      end
+
+      puts "   Found #{containers.size} yatfa-managed container(s)"
+
+      # 3. Check each container for staleness
+      stale = containers.select { |c| c[:version] != remote_version }
+      if stale.empty?
+        puts "✅ All containers are up to date"
+        return
+      end
+
+      puts "   #{stale.size} container(s) need updates:"
+      stale.each do |c|
+        puts "     - #{c[:name]} (version: #{c[:version]&.[](0..19) || 'unknown'})"
+      end
+
+      # 4. Update stale containers
+      stale.each do |container|
+        update_container(container, remote_version)
+      end
+
+      puts ""
+      puts "✅ Update cycle complete (#{stale.size} updated)"
+    end
+
+    # List all Docker containers that have the yatfa.version label
+    # @return [Array<Hash>] array of container info hashes
+    def self.list_yatfa_containers
+      result = IO.popen(
+        ["docker", "ps", "-a",
+         "--filter", "label=#{VERSION_LABEL}",
+         "--format", "{{.ID}}\t{{.Names}}\t{{.Status}}"],
+        err: File::NULL,
+        &:read
+      ).strip
+
+      return [] if result.empty?
+
+      result.lines.map do |line|
+        id, name, status = line.strip.split("\t")
+        version = get_container_label(id, VERSION_LABEL)
+        {
+          id: id,
+          name: name,
+          status: status,
+          version: version
+        }
+      end
+    end
+
+    # Get a specific label value from a container
+    # @param container_id [String] container ID or name
+    # @param label [String] label key
+    # @return [String, nil] label value
+    def self.get_container_label(container_id, label)
+      result = IO.popen(
+        ["docker", "inspect", "--format", "{{.Config.Labels.#{label}}}", container_id],
+        err: File::NULL,
+        &:read
+      ).strip
+      result.empty? ? nil : result
+    end
+
+    # Update a single stale container
+    # @param container [Hash] container info from list_yatfa_containers
+    # @param new_version [String] target version (deployed_at)
+    def self.update_container(container, new_version)
+      name = container[:name]
+      puts ""
+      puts "🔄 Updating #{name}..."
+
+      begin
+        # 1. Extract container config before stopping
+        config = inspect_container_config(container[:id])
+        unless config
+          puts "   ❌ Could not inspect container #{name}, skipping"
+          return
+        end
+
+        # 2. Build fresh image FIRST (while old container still running)
+        #    This ensures the old container survives if the build fails.
+        #    Both Config.load and Docker.build_image call exit(1) on failure,
+        #    which SystemExit catches here (not caught by rescue StandardError).
+        puts "   Building fresh image..."
+        begin
+          project_root = find_project_root_for_container(config)
+          if project_root && Dir.exist?(project_root)
+            Dir.chdir(project_root) do
+              docker_config = load_config_for_container(project_root)
+              Docker.build_image(docker_config)
+            end
+          else
+            puts "   ⚠️  Could not find project root, attempting build in cwd"
+            docker_config = Config.load
+            Docker.build_image(docker_config)
+          end
+        rescue SystemExit => e
+          puts "   ❌ Build failed (exit #{e.status}), keeping old container running"
+          return
+        end
+
+        # 3. Only after successful build, stop and remove the old container
+        puts "   Stopping old container..."
+        system("docker", "stop", name, out: File::NULL, err: File::NULL)
+        system("docker", "rm", name, out: File::NULL, err: File::NULL)
+
+        # 4. Recreate container with preserved config
+        puts "   Starting new container..."
+        new_cmd = build_recreate_command(name, config, new_version)
+        success = system(*new_cmd)
+
+        if success
+          puts "   ✅ #{name} updated successfully"
+        else
+          puts "   ❌ Failed to start new container #{name}"
+          puts "   Old container has been removed. Manual intervention may be needed."
+        end
+      rescue StandardError => e
+        puts "   ❌ Error updating #{name}: #{e.message}"
+      end
+    end
+
+    # Inspect a container and extract its configuration
+    # @param container_id [String] container ID
+    # @return [Hash, nil] parsed container config
+    def self.inspect_container_config(container_id)
+      result = IO.popen(
+        ["docker", "inspect", "--format", "{{json .}}", container_id],
+        err: File::NULL,
+        &:read
+      ).strip
+      return nil if result.empty?
+
+      JSON.parse(result)
+    rescue JSON::ParserError
+      nil
+    end
+
+    # Find the project root directory for a container based on its config
+    # @param config [Hash] container inspect data
+    # @return [String, nil] project root path
+    def self.find_project_root_for_container(config)
+      # Try to find project root from mounted setup directory
+      mounts = config.dig("Mounts") || []
+      mounts.each do |mount|
+        next unless mount["Destination"] == "/tmp/setup"
+        source = mount["Source"]
+        # The source is .../setup, project root is its parent
+        return File.expand_path("..", source) if source && Dir.exist?(File.expand_path("..", source))
+      end
+
+      # Try REPOSITORIES_CONFIG env var to find workspace path
+      env = config.dig("Config", "Env") || []
+      env.each do |var|
+        if var.start_with?("REPOSITORIES_CONFIG=")
+          begin
+            repos = JSON.parse(var.sub("REPOSITORIES_CONFIG=", ""))
+            if repos.is_a?(Array) && repos.any?
+              path = repos.first["path_in_sandbox"]
+              if path
+                parent = File.dirname(path)
+                # Walk up looking for yatfa.env.rb
+                dir = parent
+                while dir != "/"
+                  return dir if File.exist?(File.join(dir, "yatfa.env.rb"))
+                  dir = File.dirname(dir)
+                end
+              end
+            end
+          rescue JSON::ParserError
+            nil
+          end
+        end
+      end
+
+      # Try CWD from mount sources
+      binds = config.dig("HostConfig", "Binds") || []
+      binds.each do |bind|
+        source = bind.split(":").first
+        next unless source
+        return File.dirname(source) if File.exist?(File.join(File.dirname(source), "yatfa.env.rb"))
+      end
+
+      nil
+    end
+
+    # Load config for a container from its project root
+    # @param project_root [String] path to project root
+    # @return [Hash] loaded config
+    def self.load_config_for_container(project_root)
+      config_file = File.join(project_root, "yatfa.env.rb")
+      if File.exist?(config_file)
+        config = eval(File.read(config_file), binding, config_file)
+        config = config.transform_keys(&:to_s)
+
+        # Normalize via JSON round-trip
+        JSON.parse(JSON.generate(config))
+      else
+        {}
+      end
+    end
+
+    # Build a docker run command to recreate a container with preserved config
+    # @param name [String] container name
+    # @param config [Hash] container inspect data
+    # @param new_version [String] target version (deployed_at)
+    # @return [Array<String>] docker command arguments
+    def self.build_recreate_command(name, config, new_version)
+      cmd = ["docker", "run", "-d", "--name", name]
+
+      # Preserve restart policy
+      restart = config.dig("HostConfig", "RestartPolicy", "Name")
+      cmd += ["--restart", restart || "unless-stopped"]
+
+      # Preserve network mode
+      network = config.dig("HostConfig", "NetworkMode")
+      cmd += ["--network", network] if network && network != "default"
+
+      # Preserve tmpfs mounts
+      tmpfs = config.dig("HostConfig", "Tmpfs") || {}
+      tmpfs.each_key do |path|
+        cmd += ["--tmpfs", path]
+      end
+
+      # Preserve volume mounts (excluding setup mount which is dev-only)
+      mounts = config.dig("Mounts") || []
+      mounts.each do |mount|
+        src = mount["Source"]
+        dst = mount["Destination"]
+        mode = mount["Mode"] || "rw"
+
+        # Skip mounts that no longer exist on host
+        next unless File.exist?(src)
+
+        if mode == "ro"
+          cmd += ["-v", "#{src}:#{dst}:ro"]
+        else
+          cmd += ["-v", "#{src}:#{dst}"]
+        end
+      end
+
+      # Preserve environment variables
+      env = config.dig("Config", "Env") || []
+      env.each do |var|
+        # Skip internal Docker env vars
+        next if var.start_with?("PATH=", "HOME=", "HOSTNAME=")
+        cmd += ["-e", var]
+      end
+
+      # Add updated version label
+      cmd += ["--label", "#{VERSION_LABEL}=#{new_version}"]
+
+      # Preserve the original Entrypoint
+      # Docker --entrypoint only accepts the executable, not arguments.
+      # If entrypoint has multiple elements (e.g. ["/bin/sh", "-c"]), use only
+      # the first as --entrypoint and prepend the rest before CMD.
+      entrypoint = config.dig("Config", "Entrypoint")
+      entrypoint_extra = []
+      if entrypoint.is_a?(Array) && entrypoint.any?
+        cmd += ["--entrypoint", entrypoint[0]]
+        entrypoint_extra = entrypoint[1..]
+      end
+
+      # Use the same image
+      image = config.dig("Config", "Image")
+      cmd += [image || "yatfa-sandbox"]
+
+      # Use the original CMD (prepended with any extra entrypoint args)
+      original_cmd = config.dig("Config", "Cmd")
+      full_cmd = entrypoint_extra + (original_cmd.is_a?(Array) ? original_cmd : [])
+      cmd += full_cmd if full_cmd.any?
+
+      cmd
+    end
+  end
+end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yatfa",
-  "version": "1.0.80",
+  "version": "1.0.82",
   "description": "YATFA - Yet Another Tool For Agents",
   "bin": "./bin/run-yatfa-agent.rb",
   "files": [

package/setup/setup-agent.rb

@@ -330,6 +330,15 @@ def setup_claude_settings!
       puts "   Opus model: #{llm_credentials['model_opus']}"
     end
 
+    # Configure context window if specified (value is in k-units, append 'k' suffix)
+    if llm_credentials["context_window"] && !llm_credentials["context_window"].to_s.empty?
+      context_window_value = llm_credentials["context_window"].to_i
+      if context_window_value > 0
+        settings_config["env"]["CLAUDE_CODE_AUTO_COMPACT_WINDOW"] = "#{context_window_value}000"
+        puts "   Context window: #{context_window_value}k tokens"
+      end
+    end
+
     if !llm_credentials["model_haiku"] && !llm_credentials["model_sonnet"] && !llm_credentials["model_opus"]
       puts "   Using default Anthropic models"
     end
@@ -1035,4 +1044,4 @@ else
   # prepare_git_state! is now in entrypoint.sh
   bin_dir = download_agent_bridge!
   run_agent!(bin_dir)
-end
+end