ruby_raider 4.1.0 → 4.2.0

data/spec/utilities/{flows → schedules}/os/cron_spec.rb

@@ -2,12 +2,12 @@
 
 require 'shellwords'
 require 'tmpdir'
-require_relative '../../../../lib/utilities/flows/os/cron'
+require_relative '../../../../lib/utilities/schedules/os/cron'
+require_relative '../../../../lib/utilities/schedules/schedule'
 
-# Flow specs live under spec/utilities/flows, next to the code in lib/utilities/flows
 # The fake runner and project folders sit next to the adapter under test
 # rubocop:disable RSpec/MultipleMemoizedHelpers
-RSpec.describe RubyRaider::Flows::Os::Cron do # rubocop:disable RSpec/FilePath
+RSpec.describe RubyRaider::Schedules::Os::Cron do # rubocop:disable RSpec/FilePath
   # Plays crontab: -l prints the current table (or fails), - stores stdin; never runs anything
   let(:fake_runner_class) do
     Class.new do
@@ -27,22 +27,24 @@ RSpec.describe RubyRaider::Flows::Os::Cron do # rubocop:disable RSpec/FilePath
         stderr, status = answers.fetch(verb) { missing ? ['no crontab for raider', 1] : ['', 0] }
         stdout = verb == '-l' ? table.to_s : ''
         self.table = stdin_data if verb == '-' && status.zero?
-        RubyRaider::Flows::Os::CommandRunner::Result.new(stdout: stdout, stderr: stderr, exitstatus: status)
+        RubyRaider::Schedules::Os::CommandRunner::Result.new(stdout: stdout, stderr: stderr, exitstatus: status)
       end
     end
   end
 
   let(:hostile) { %q('; rm -rf ~; ' </string> %h $(id) " \\ &) }
-  let(:tmp) { File.realpath(Dir.mktmpdir('flows-cron')) }
+  let(:tmp) { File.realpath(Dir.mktmpdir('schedules-cron')) }
   let(:project_dir) { File.join(tmp, 'plain') }
   let(:runner) { fake_runner_class.new }
-  let(:cron) { described_class.new(runner: runner) }
+  let(:cron) { described_class.new(kind: RubyRaider::Schedules::Kind::TESTS, runner: runner) }
   let(:now) { Time.utc(2026, 11, 9, 10, 0, 0) }
 
-  def schedule(dir: project_dir, name: 'report', **options)
+  def schedule(dir: project_dir, name: 'report', gem_env: {}, bundle: '/opt/ruby/bin/bundle', **options)
     FileUtils.mkdir_p(dir)
-    project = RubyRaider::Flows::Project.new(File.realpath(dir))
-    RubyRaider::Flows::Schedule.build(project: project, name: name, every: 'day', at: '08:00', now: now, **options)
+    # Hermetic: the GEM_HOME/GEM_PATH and bundle this spec runs with never reach the entry; a spec passes its own
+    allow(RubyRaider::Schedules::Schedule).to receive_messages(captured_gem_env: gem_env, bundle_path: bundle)
+    project = RubyRaider::Schedules::Project.new(File.realpath(dir))
+    RubyRaider::Schedules::Schedule.build(project: project, name: name, every: 'day', at: '08:00', now: now, **options)
   end
 
   # What cron (cronie/vixie do_command.c) hands to /bin/sh: a backslash escapes the next character, an
@@ -76,7 +78,7 @@ RSpec.describe RubyRaider::Flows::Os::Cron do # rubocop:disable RSpec/FilePath
      '>>', item.log_path, '2>&1']
   end
 
-  def block(item) = "# raider-flow #{item.os_id}\n#{cron.line(item)}\n"
+  def block(item) = "# raider-schedule #{item.os_id}\n#{cron.line(item)}\n"
 
   after { FileUtils.rm_rf(tmp) }
 
@@ -103,27 +105,30 @@ RSpec.describe RubyRaider::Flows::Os::Cron do # rubocop:disable RSpec/FilePath
     end
 
     it 'keeps GEM_HOME and GEM_PATH in the environment when they were captured' do
-      allow(RubyRaider::Flows::Schedule).to receive(:captured_gem_env).and_return('GEM_HOME' => '/g/%home', 'GEM_PATH' => '/g/path')
+      item = schedule(gem_env: { 'GEM_HOME' => '/g/%home', 'GEM_PATH' => '/g/path' })
 
-      expect(fields_and_words(cron.line(schedule)).last).to include('GEM_HOME=/g/%home', 'GEM_PATH=/g/path')
+      expect(fields_and_words(cron.line(item)).last).to include('GEM_HOME=/g/%home', 'GEM_PATH=/g/path')
     end
 
     it 'refuses a ruby path env would read as a variable' do
       plain = schedule
-      item = RubyRaider::Flows::Schedule.from_h(plain.to_h.merge('ruby' => '/opt/a=b/ruby'), plain.project_root)
+      item = RubyRaider::Schedules::Schedule.from_h(plain.to_h.merge('ruby' => '/opt/a=b/ruby'), plain.project_root)
 
-      expect { cron.line(item) }.to raise_error(RubyRaider::Flows::Error, /cron can not run ruby from .*a=b/)
+      expect { cron.line(item) }.to raise_error(RubyRaider::Schedules::Error, /cron can not run ruby from .*a=b/)
     end
 
-    describe 'with hostile values in an input and in the project path' do
-      let(:item) { schedule(dir: File.join(tmp, "p#{hostile}<", "string> #{hostile} 100%"), inputs: ["note=#{hostile} 50%"]) }
+    describe 'with hostile values in the bundle path, GEM_HOME and the project path' do
+      let(:item) do
+        schedule(dir: File.join(tmp, "p#{hostile}<", "string> #{hostile} 100%"), bundle: "/opt/#{hostile} 50%/bundle",
+                 gem_env: { 'GEM_HOME' => "/g/#{hostile} 25%" })
+      end
       let(:text) { cron.line(item) }
 
       it 'gives back the exact command words after cron and the shell read it' do
         fields, words = fields_and_words(text)
 
         expect([fields, words]).to eq([%w[0 8 * * *], expected_words(item)])
-        expect(words).to include("note=#{hostile} 50%")
+        expect(words).to include("/opt/#{hostile} 50%/bundle", "GEM_HOME=/g/#{hostile} 25%")
         expect(item.working_directory).to include('</string>', "'; rm -rf ~; '", '$(id)', '%h', '"', '\\', '&', ' ')
       end
 
@@ -145,7 +150,7 @@ RSpec.describe RubyRaider::Flows::Os::Cron do # rubocop:disable RSpec/FilePath
 
     it 'puts the block first and keeps every other byte, CRLF and a missing last newline included' do
       item = schedule
-      other = "SHELL=/bin/fish\r\nMAILTO=\"\"\r\n# raider-flow dev.rubyraider.flow.0123456789.other\n1 2 * * * echo % \\%\n5 5 * * * last"
+      other = "SHELL=/bin/fish\r\nMAILTO=\"\"\r\n# raider-schedule dev.rubyraider.schedule.0123456789.other\n1 2 * * * echo % \\%\n5 5 * * * last"
       runner.table = other
 
       cron.install(item)
@@ -164,7 +169,7 @@ RSpec.describe RubyRaider::Flows::Os::Cron do # rubocop:disable RSpec/FilePath
       expect(runner.table).not_to include(daily)
     end
 
-    it 'keeps another flow block' do
+    it "keeps another schedule's block" do
       other = schedule(name: 'nightly')
       runner.table = block(other)
 
@@ -174,16 +179,16 @@ RSpec.describe RubyRaider::Flows::Os::Cron do # rubocop:disable RSpec/FilePath
     end
 
     it 'refuses a line vixie cron would cut short and writes nothing' do
-      item = schedule(inputs: ["note=#{'x' * 900}"])
+      item = schedule(gem_env: { 'GEM_HOME' => "/g/#{'x' * 900}" })
 
-      expect { cron.install(item) }.to raise_error(RubyRaider::Flows::Error, /crontab line is \d{4} bytes, over 990/)
+      expect { cron.install(item) }.to raise_error(RubyRaider::Schedules::Error, /crontab line is \d{4} bytes, over 990/)
       expect(runner.calls).to be_empty
     end
 
     it 'raises with the scheduler error when crontab -l fails for another reason' do
       runner.answers['-l'] = ["crontab: permission denied\e[2J", 1]
 
-      expect { cron.install(schedule) }.to raise_error(RubyRaider::Flows::Error, /cron could not read .*permission denied\?\[2J/)
+      expect { cron.install(schedule) }.to raise_error(RubyRaider::Schedules::Error, /cron could not read .*permission denied\?\[2J/)
       expect(runner.calls).to eq([%w[crontab -l]])
     end
 
@@ -191,7 +196,7 @@ RSpec.describe RubyRaider::Flows::Os::Cron do # rubocop:disable RSpec/FilePath
       runner.table = "1 * * * * a\n"
       runner.answers['-'] = ['crontab: errors in crontab file', 1]
 
-      expect { cron.install(schedule) }.to raise_error(RubyRaider::Flows::Error, /cron could not save .*errors in crontab file/)
+      expect { cron.install(schedule) }.to raise_error(RubyRaider::Schedules::Error, /cron could not save .*errors in crontab file/)
       expect(runner.table).to eq("1 * * * * a\n")
     end
   end
@@ -217,7 +222,7 @@ RSpec.describe RubyRaider::Flows::Os::Cron do # rubocop:disable RSpec/FilePath
     it 'keeps an unrelated line that follows an orphaned tag' do
       item = schedule
       other = schedule(name: 'nightly')
-      runner.table = "# raider-flow #{item.os_id}\n#{cron.line(other)}\n1 * * * * a\n"
+      runner.table = "# raider-schedule #{item.os_id}\n#{cron.line(other)}\n1 * * * * a\n"
 
       expect(cron.remove(item.os_id)).to be(true)
       expect(runner.table).to eq("#{cron.line(other)}\n1 * * * * a\n")
@@ -226,7 +231,7 @@ RSpec.describe RubyRaider::Flows::Os::Cron do # rubocop:disable RSpec/FilePath
     it 'keeps a line under its tag that is not a schedule run' do
       item = schedule
       manual = cron.line(item).sub(' --trigger schedule', ' --trigger manual')
-      runner.table = "# raider-flow #{item.os_id}\n#{manual}\n"
+      runner.table = "# raider-schedule #{item.os_id}\n#{manual}\n"
 
       expect(cron.remove(item.os_id)).to be(true)
       expect(runner.table).to eq("#{manual}\n")
@@ -234,14 +239,14 @@ RSpec.describe RubyRaider::Flows::Os::Cron do # rubocop:disable RSpec/FilePath
 
     it 'removes a tag line left without its line' do
       item = schedule
-      runner.table = "1 * * * * a\n# raider-flow #{item.os_id}"
+      runner.table = "1 * * * * a\n# raider-schedule #{item.os_id}"
 
       expect(cron.remove(item.os_id)).to be(true)
       expect(runner.table).to eq("1 * * * * a\n")
     end
 
     it 'is false and writes nothing when its block is not there' do
-      runner.table = "1 * * * * a\n# raider-flow #{schedule.os_id}x\n"
+      runner.table = "1 * * * * a\n# raider-schedule #{schedule.os_id}x\n"
 
       expect(cron.remove(schedule.os_id)).to be(false)
       expect(runner.calls).to eq([%w[crontab -l]])
@@ -251,8 +256,8 @@ RSpec.describe RubyRaider::Flows::Os::Cron do # rubocop:disable RSpec/FilePath
       expect(cron.remove(schedule.os_id)).to be(false)
     end
 
-    it 'refuses an os_id that is not a flow schedule id' do
-      expect { cron.remove("x\n* * * * * evil") }.to raise_error(RubyRaider::Flows::Error, /Invalid os_id/)
+    it 'refuses an os_id that is not a schedule id' do
+      expect { cron.remove("x\n* * * * * evil") }.to raise_error(RubyRaider::Schedules::Error, /Invalid os_id/)
       expect(runner.calls).to be_empty
     end
   end

data/spec/utilities/{flows → schedules}/os/launchd_spec.rb

@@ -2,12 +2,12 @@
 
 require 'tmpdir'
 require 'rexml/document'
-require_relative '../../../../lib/utilities/flows/os/launchd'
+require_relative '../../../../lib/utilities/schedules/os/launchd'
+require_relative '../../../../lib/utilities/schedules/schedule'
 
-# Flow specs live under spec/utilities/flows, next to the code in lib/utilities/flows
 # The fake runner, temp home and project folders sit next to the adapter under test
 # rubocop:disable RSpec/MultipleMemoizedHelpers
-RSpec.describe RubyRaider::Flows::Os::Launchd do # rubocop:disable RSpec/FilePath
+RSpec.describe RubyRaider::Schedules::Os::Launchd do # rubocop:disable RSpec/FilePath
   # Records every command and answers from a table (success unless told otherwise); never runs anything
   let(:fake_runner_class) do
     Class.new do
@@ -24,7 +24,7 @@ RSpec.describe RubyRaider::Flows::Os::Launchd do # rubocop:disable RSpec/FilePat
         @stdin << stdin_data
         @seen&.call(argv)
         stderr, status = answers.fetch(argv[1], ['', 0])
-        RubyRaider::Flows::Os::CommandRunner::Result.new(stdout: '', stderr: stderr, exitstatus: status)
+        RubyRaider::Schedules::Os::CommandRunner::Result.new(stdout: '', stderr: stderr, exitstatus: status)
       end
 
       def on_call(&block) = @seen = block
@@ -32,18 +32,20 @@ RSpec.describe RubyRaider::Flows::Os::Launchd do # rubocop:disable RSpec/FilePat
   end
 
   let(:hostile) { %q('; rm -rf ~; ' </string> %h $(id) " \\ &) }
-  let(:tmp) { File.realpath(Dir.mktmpdir('flows-launchd')) }
+  let(:tmp) { File.realpath(Dir.mktmpdir('schedules-launchd')) }
   let(:home) { File.join(tmp, 'home') }
   let(:project_dir) { File.join(tmp, 'plain') }
   let(:runner) { fake_runner_class.new }
-  let(:launchd) { described_class.new(runner: runner, home: home, uid: 501) }
+  let(:launchd) { described_class.new(kind: RubyRaider::Schedules::Kind::TESTS, runner: runner, home: home, uid: 501) }
   let(:now) { Time.utc(2026, 11, 9, 10, 0, 0) }
   let(:agents) { File.join(home, 'Library', 'LaunchAgents') }
 
-  def schedule(dir: project_dir, **options)
+  def schedule(dir: project_dir, gem_env: {}, bundle: '/opt/ruby/bin/bundle', **options)
     FileUtils.mkdir_p(dir)
-    project = RubyRaider::Flows::Project.new(File.realpath(dir))
-    RubyRaider::Flows::Schedule.build(project: project, name: 'report', every: 'day', at: '08:00', now: now, **options)
+    # Hermetic: the GEM_HOME/GEM_PATH and bundle this spec runs with never reach the entry; a spec passes its own
+    allow(RubyRaider::Schedules::Schedule).to receive_messages(captured_gem_env: gem_env, bundle_path: bundle)
+    project = RubyRaider::Schedules::Project.new(File.realpath(dir))
+    RubyRaider::Schedules::Schedule.build(project: project, name: 'report', every: 'day', at: '08:00', now: now, **options)
   end
 
   # plist XML back to Ruby: dict -> Hash, array -> Array, string -> String, integer -> Integer
@@ -116,7 +118,7 @@ RSpec.describe RubyRaider::Flows::Os::Launchd do # rubocop:disable RSpec/FilePat
     end
 
     it 'round-trips every field and never sets RunAtLoad' do
-      item = schedule(retries: 2, inputs: %w[env=staging])
+      item = schedule(retries: 2, selection: RubyRaider::Schedules::Selection.new(kind: 'tag', tag: 'smoke'))
 
       expect(parsed(launchd.plist(item))).to eq(
         'Label' => item.os_id, 'ProgramArguments' => item.argv, 'WorkingDirectory' => item.working_directory,
@@ -126,9 +128,7 @@ RSpec.describe RubyRaider::Flows::Os::Launchd do # rubocop:disable RSpec/FilePat
     end
 
     it 'keeps GEM_HOME and GEM_PATH in the environment when they were captured' do
-      allow(RubyRaider::Flows::Schedule).to receive(:captured_gem_env).and_return('GEM_HOME' => '/g/home', 'GEM_PATH' => '/g/path')
-
-      env = parsed(launchd.plist(schedule))['EnvironmentVariables']
+      env = parsed(launchd.plist(schedule(gem_env: { 'GEM_HOME' => '/g/home', 'GEM_PATH' => '/g/path' })))['EnvironmentVariables']
 
       expect(env.slice('LANG', 'GEM_HOME', 'GEM_PATH')).to eq('LANG' => 'en_US.UTF-8', 'GEM_HOME' => '/g/home', 'GEM_PATH' => '/g/path')
     end
@@ -149,15 +149,17 @@ RSpec.describe RubyRaider::Flows::Os::Launchd do # rubocop:disable RSpec/FilePat
       expect(days).to eq([0, 1, 6].map { |day| { 'Weekday' => day, 'Hour' => 8, 'Minute' => 0 } })
     end
 
-    describe 'with hostile values in an input and in the project path' do
-      let(:item) { schedule(dir: File.join(tmp, "p#{hostile}<", "string> #{hostile}"), inputs: ["note=#{hostile}"]) }
+    describe 'with hostile values in the bundle path, GEM_HOME and the project path' do
+      let(:item) do
+        schedule(dir: File.join(tmp, "p#{hostile}<", "string> #{hostile}"), bundle: "/opt/#{hostile}/bundle", gem_env: { 'GEM_HOME' => "/g/#{hostile}" })
+      end
       let(:text) { launchd.plist(item) }
 
       it 'round-trips them exactly' do
         data = parsed(text)
 
         expect([data['ProgramArguments'], data['WorkingDirectory'], data['StandardOutPath']]).to eq([item.argv, item.working_directory, item.log_path])
-        expect(data['ProgramArguments'].last).to eq("note=#{hostile}")
+        expect([data['ProgramArguments'][1], data['EnvironmentVariables']['GEM_HOME']]).to eq(["/opt/#{hostile}/bundle", "/g/#{hostile}"])
         expect(item.working_directory).to include('</string>', "'; rm -rf ~; '", '$(id)', '%h', '"', '\\', '&')
       end
 
@@ -203,7 +205,7 @@ RSpec.describe RubyRaider::Flows::Os::Launchd do # rubocop:disable RSpec/FilePat
       item = schedule
       runner.answers['bootstrap'] = ["Bootstrap failed: 5: Input/output error\e[2J\n", 5]
 
-      expect { launchd.install(item) }.to raise_error(RubyRaider::Flows::Error, %r{launchd.*Bootstrap failed: 5: Input/output error\?\[2J})
+      expect { launchd.install(item) }.to raise_error(RubyRaider::Schedules::Error, %r{launchd.*Bootstrap failed: 5: Input/output error\?\[2J})
       expect(Dir.children(agents)).to be_empty
     end
 
@@ -213,14 +215,14 @@ RSpec.describe RubyRaider::Flows::Os::Launchd do # rubocop:disable RSpec/FilePat
       allow(File).to receive(:unlink).and_call_original
       allow(File).to receive(:unlink).with(plist_path(item)).and_raise(Errno::EACCES)
 
-      expect { launchd.install(item) }.to raise_error(RubyRaider::Flows::Error, /Bootstrap failed: 5; also: Could not remove .*Permission denied/)
+      expect { launchd.install(item) }.to raise_error(RubyRaider::Schedules::Error, /Bootstrap failed: 5; also: Could not remove .*Permission denied/)
     end
 
-    it 'raises a flow error and runs nothing when it can not write the plist' do
+    it 'raises a schedule error and runs nothing when it can not write the plist' do
       FileUtils.mkdir_p(File.dirname(agents))
       File.write(agents, 'not a folder')
 
-      expect { launchd.install(schedule) }.to raise_error(RubyRaider::Flows::Error, /Could not write .*LaunchAgents/)
+      expect { launchd.install(schedule) }.to raise_error(RubyRaider::Schedules::Error, /Could not write .*LaunchAgents/)
       expect([runner.calls, File.read(agents)]).to eq([[], 'not a folder'])
     end
 
@@ -230,20 +232,31 @@ RSpec.describe RubyRaider::Flows::Os::Launchd do # rubocop:disable RSpec/FilePat
       File.write(plist_path(item), 'old')
       runner.answers['-lint'] = ['bad plist', 1]
 
-      expect { launchd.install(item) }.to raise_error(RubyRaider::Flows::Error, /bad plist/)
+      expect { launchd.install(item) }.to raise_error(RubyRaider::Schedules::Error, /bad plist/)
       expect([runner.calls.map { |argv| argv[1] }, Dir.children(agents), File.read(plist_path(item))])
         .to eq([['-lint'], [File.basename(plist_path(item))], 'old'])
     end
   end
 
   describe '#remove' do
-    it 'boots out and deletes the plist' do
+    it 'deletes the plist, then boots out' do
       item = schedule
       FileUtils.mkdir_p(agents)
       File.write(plist_path(item), 'x')
+      seen = []
+      runner.on_call { |argv| seen << [argv[1], File.exist?(plist_path(item))] }
 
       expect(launchd.remove(item.os_id)).to be(true)
-      expect([runner.calls, File.exist?(plist_path(item))]).to eq([[['/bin/launchctl', 'bootout', "gui/501/#{item.os_id}"]], false])
+      expect([runner.calls, seen]).to eq([[['/bin/launchctl', 'bootout', "gui/501/#{item.os_id}"]], [['bootout', false]]])
+    end
+
+    it 'is true when only the plist was there' do
+      item = schedule
+      FileUtils.mkdir_p(agents)
+      File.write(plist_path(item), 'x')
+      runner.answers['bootout'] = ['Boot-out failed: 3: No such process', 3]
+
+      expect([launchd.remove(item.os_id), File.exist?(plist_path(item))]).to eq([true, false])
     end
 
     it 'is true when only the service was loaded' do
@@ -260,12 +273,12 @@ RSpec.describe RubyRaider::Flows::Os::Launchd do # rubocop:disable RSpec/FilePat
       item = schedule
       allow(File).to receive(:unlink).and_raise(Errno::EACCES)
 
-      expect { launchd.remove(item.os_id) }.to raise_error(RubyRaider::Flows::Error, /Could not remove .*Permission denied/)
-      expect(runner.calls).to eq([['/bin/launchctl', 'bootout', "gui/501/#{item.os_id}"]])
+      expect { launchd.remove(item.os_id) }.to raise_error(RubyRaider::Schedules::Error, /Could not remove .*Permission denied/)
+      expect(runner.calls).to be_empty
     end
 
-    it 'refuses an os_id that is not a flow schedule id' do
-      expect { launchd.remove('../../evil') }.to raise_error(RubyRaider::Flows::Error, /Invalid os_id/)
+    it 'refuses an os_id that is not a schedule id' do
+      expect { launchd.remove('../../evil') }.to raise_error(RubyRaider::Schedules::Error, /Invalid os_id/)
       expect(runner.calls).to be_empty
     end
   end
@@ -278,8 +291,8 @@ RSpec.describe RubyRaider::Flows::Os::Launchd do # rubocop:disable RSpec/FilePat
       expect(runner.calls).to eq([['/bin/launchctl', 'print', "gui/501/#{item.os_id}"]])
     end
 
-    it 'refuses an os_id that is not a flow schedule id and runs nothing' do
-      expect { launchd.present?('../../evil') }.to raise_error(RubyRaider::Flows::Error, /Invalid os_id/)
+    it 'refuses an os_id that is not a schedule id and runs nothing' do
+      expect { launchd.present?('../../evil') }.to raise_error(RubyRaider::Schedules::Error, /Invalid os_id/)
       expect(runner.calls).to be_empty
     end
 

data/spec/utilities/{flows → schedules}/os/linux_spec.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 require 'tmpdir'
-require_relative '../../../../lib/utilities/flows/os/linux'
+require_relative '../../../../lib/utilities/schedules/os/linux'
+require_relative '../../../../lib/utilities/schedules/schedule'
 
-# Flow specs live under spec/utilities/flows, next to the code in lib/utilities/flows
 # rubocop:disable RSpec/MultipleMemoizedHelpers
-RSpec.describe RubyRaider::Flows::Os::Linux do # rubocop:disable RSpec/FilePath
+RSpec.describe RubyRaider::Schedules::Os::Linux do # rubocop:disable RSpec/FilePath
   # Plays systemctl --user and crontab: answers keyed by "systemctl verb" or "crontab -l"; never runs anything
   let(:fake_runner_class) do
     Class.new do
@@ -24,34 +24,36 @@ RSpec.describe RubyRaider::Flows::Os::Linux do # rubocop:disable RSpec/FilePath
         missing = key == 'crontab -l' && table.nil?
         stderr, status = answers.fetch(key) { missing ? ['no crontab for raider', 1] : ['', 0] }
         self.table = stdin_data if key == 'crontab -' && status.zero?
-        RubyRaider::Flows::Os::CommandRunner::Result.new(stdout: key == 'crontab -l' ? table.to_s : '', stderr: stderr, exitstatus: status)
+        RubyRaider::Schedules::Os::CommandRunner::Result.new(stdout: key == 'crontab -l' ? table.to_s : '', stderr: stderr, exitstatus: status)
       end
     end
   end
 
-  let(:tmp) { File.realpath(Dir.mktmpdir('flows-linux')) }
+  let(:tmp) { File.realpath(Dir.mktmpdir('schedules-linux')) }
   let(:runner) { fake_runner_class.new }
   let(:item) do
-    project = RubyRaider::Flows::Project.new(tmp)
-    RubyRaider::Flows::Schedule.build(project: project, name: 'report', every: 'day', at: '08:00', now: Time.utc(2026, 11, 9))
+    # Hermetic: the GEM_HOME/GEM_PATH and bundle this spec runs with never reach the entry
+    allow(RubyRaider::Schedules::Schedule).to receive_messages(captured_gem_env: {}, bundle_path: '/opt/ruby/bin/bundle')
+    project = RubyRaider::Schedules::Project.new(tmp)
+    RubyRaider::Schedules::Schedule.build(project: project, name: 'report', every: 'day', at: '08:00', now: Time.utc(2026, 11, 9))
   end
-  let(:cron_block) { "# raider-flow #{item.os_id}\n#{RubyRaider::Flows::Os::Cron.new.line(item)}\n" }
+  let(:cron_block) { "# raider-schedule #{item.os_id}\n#{RubyRaider::Schedules::Os::Cron.new(kind: RubyRaider::Schedules::Kind::TESTS).line(item)}\n" }
   let(:no_bus) { ['Failed to connect to bus', 1] }
 
   # The systemd units go to a temp home, never the real one
-  def pick = described_class.new(runner: runner, systemd: RubyRaider::Flows::Os::Systemd.new(runner: runner, home: tmp, config_home: nil))
+  def pick = described_class.new(kind: RubyRaider::Schedules::Kind::TESTS, runner: runner, systemd: RubyRaider::Schedules::Os::Systemd.new(kind: RubyRaider::Schedules::Kind::TESTS, runner: runner, home: tmp, config_home: nil))
 
   after { FileUtils.rm_rf(tmp) }
 
   it 'uses systemd when the user manager answers' do
     linux = pick
 
-    expect([linux.label, linux.missed_runs_note, described_class.pick(runner).label]).to eq(['systemd', nil, 'systemd'])
+    expect([linux.label, linux.missed_runs_note, described_class.pick(runner, kind: RubyRaider::Schedules::Kind::TESTS).label]).to eq(['systemd', nil, 'systemd'])
     expect(runner.calls.uniq).to eq([%w[systemctl --user show-environment]])
   end
 
   it 'falls back to cron when it does not, or systemctl is missing' do
-    [no_bus, ['Could not run systemctl', RubyRaider::Flows::Os::CommandRunner::MISSING]].each do |answer|
+    [no_bus, ['Could not run systemctl', RubyRaider::Schedules::Os::CommandRunner::MISSING]].each do |answer|
       runner.answers['systemctl show-environment'] = answer
 
       expect([pick.label, pick.missed_runs_note]).to eq(['cron', '(cron: missed runs are skipped)'])
@@ -111,10 +113,22 @@ RSpec.describe RubyRaider::Flows::Os::Linux do # rubocop:disable RSpec/FilePath
       runner.table = "#{cron_block}1 * * * * a\n"
 
       expect { pick.remove(item.os_id) }
-        .to raise_error(RubyRaider::Flows::Error, 'This schedule is a systemd timer; run raider flow unschedule report ' \
-                                                  'from a session where systemctl --user works')
+        .to raise_error(RubyRaider::Schedules::Error, 'This schedule is a systemd timer; run raider schedule remove report ' \
+                                                      'from a session where systemctl --user works')
       expect([runner.table, File.exist?(File.join(units, "#{item.os_id}.timer"))]).to eq(["1 * * * * a\n", true])
     end
+
+    it 'names raider schedule list, with no name, for a 4.1 timer' do
+      legacy = RubyRaider::Schedules::Kind::FLOW_LEGACY
+      os_id = "#{legacy.os_id_prefix}.0123456789.report"
+      File.write(File.join(units, "#{os_id}.timer"), 'x')
+      linux = described_class.new(kind: legacy, runner: runner,
+                                  systemd: RubyRaider::Schedules::Os::Systemd.new(kind: legacy, runner: runner, home: tmp, config_home: nil))
+
+      expect { linux.remove(os_id) }
+        .to raise_error(RubyRaider::Schedules::Error, 'This schedule is a systemd timer; run raider schedule list ' \
+                                                      'from a session where systemctl --user works')
+    end
   end
 
   it 'does not look for systemd unit files when systemd is the primary' do