pwn 0.5.783 → 0.5.784

data/lib/pwn/sessions.rb

@@ -88,11 +88,13 @@ module PWN
                      when :trace then ['traces', File.join(id, 'trace.jsonl')]
                      else raise ArgumentError, 'Invalid session support kind'
                      end
-      legacy = File.join(sessions_dir, name)
+      directory = opts[:read_only] ? SESSIONS_DIR : sessions_dir
+      legacy = File.join(directory, name)
       return legacy if File.exist?(legacy) || File.symlink?(legacy)
 
-      path = File.join(sessions_dir, 'support', folder, name)
-      return legacy unless File.exist?(path) || File.symlink?(path) || File.file?(File.join(sessions_dir, '.layout-v2'))
+      path = File.join(directory, 'support', folder, name)
+      return legacy unless File.exist?(path) || File.symlink?(path) || File.file?(File.join(directory, '.layout-v2'))
+      return path if opts[:read_only]
 
       FileUtils.mkdir_p(File.dirname(path), mode: 0o700)
       raise IOError, 'Unsafe session support directory' unless File.realpath(File.dirname(path)) == File.expand_path(File.dirname(path))
@@ -183,11 +185,31 @@ module PWN
       files.concat(Dir.glob(File.join(root, 'artifacts', '{manifest.jsonl,*/index.jsonl,*/engagement-memory.json}')))
       databases = Dir.glob(File.join(root, 'embeddings', '*.db'))
       errors.concat(%w[artifacts embeddings].map { |name| File.join(root, name) }.select { |dir| File.symlink?(dir) || (File.exist?(dir) && !File.directory?(dir)) })
+      admission = Thread.current[:pwn_maintenance_admission]
       directories.each do |dir|
         next unless File.directory?(dir) && !File.symlink?(dir)
 
-        files.concat(Dir.glob(File.join(dir, '**', '*.{json,jsonl}')).reject { |path| File.basename(path) == 'loot.json' })
-        errors.concat(Dir.glob(File.join(dir, '**', '*')).select { |path| File.symlink?(path) })
+        pending = [[dir, Dir.each_child(dir)]]
+        until pending.empty?
+          begin
+            path = File.join(pending.last[0], pending.last[1].next)
+          rescue StopIteration
+            pending.pop
+            next
+          end
+          if admission && !admission.call
+            errors << 'incomplete_dependency_index'
+            break
+          end
+          if File.symlink?(path)
+            errors << path
+          elsif File.directory?(path)
+            pending << [path, Dir.each_child(path)]
+          elsif %w[.json .jsonl].include?(File.extname(path)) && File.basename(path) != 'loot.json'
+            files << path
+          end
+        end
+        break if errors.include?('incomplete_dependency_index')
       end
       dependencies = {}
       evidence_dependencies = {}
@@ -206,12 +228,20 @@ module PWN
         errors << path
       end
       files.uniq.sort.each do |path|
+        if admission && !admission.call
+          errors << 'incomplete_dependency_index'
+          break
+        end
         next unless File.exist?(path) || File.symlink?(path)
 
         begin
           raise IOError, 'Unsafe dependency parent' if errors.any? { |parent| path.start_with?("#{parent}/") }
           raise IOError, 'Unsafe dependency store' unless File.file?(path) && File.realpath(path) == File.expand_path(path)
 
+          if admission && !admission.call(File.size(path))
+            errors << 'incomplete_dependency_index'
+            break
+          end
           bytes = File.binread(path)
           units = dependency_units(path: path, bytes: bytes)
           units.each do |locator, record|
@@ -560,9 +590,12 @@ module PWN
       sid = opts[:session_id].to_s
       raise ArgumentError, 'Invalid session ID' if sid.empty? || File.basename(sid) != sid || sid == '.' || sid == '..'
 
-      File.open(support_path(kind: :lease, session_id: sid), File::RDWR | File::CREAT | File::NOFOLLOW, 0o600) do |lock|
+      path = support_path(kind: :lease, session_id: sid, read_only: true)
+      File.open(path, File::RDONLY | File::NOFOLLOW) do |lock|
         !lock.flock(File::LOCK_EX | File::LOCK_NB)
       end
+    rescue Errno::ENOENT
+      false
     end
 
     # Supported Method Parameters::
@@ -752,7 +785,9 @@ module PWN
       # Character chunks keep Unicode intact, including four-byte characters.
       text.chars.each_slice(1500) do |chunk|
         output = PWN::AI::Router.summarize(text: "Previous overall summary: #{result[:summary]}\nNew conversation turns:\n#{chunk.join}", llm: true, session: true)
-        parsed = JSON.parse(output.to_s.sub(/\A```(?:json)?\s*/, '').sub(/\s*```\z/, ''), symbolize_names: true)
+        raise IOError, 'Session title provider returned no text' if output.to_s.strip.empty?
+
+        parsed = JSON.parse(output.to_s.strip.sub(/\A```(?:json)?\s*/, '').sub(/\s*```\z/, ''), symbolize_names: true)
         raise ArgumentError, 'Invalid summary response' unless parsed.is_a?(Hash) && parsed[:title].is_a?(String) && parsed[:summary].is_a?(String)
         raise ArgumentError, 'Invalid summary title' if !summary_title_valid?(title: parsed[:title]) || parsed[:summary].strip.empty?
 
@@ -835,7 +870,14 @@ module PWN
         content: content,
         timestamp: Time.now.utc.iso8601
       }
-      File.open(path, 'a') { |f| f.puts(JSON.dump(entry)) }
+      File.open("#{path}.write.lock", File::RDWR | File::CREAT | File::NOFOLLOW, 0o600) do |writer|
+        writer.flock(File::LOCK_EX)
+        File.open(path, File::WRONLY | File::APPEND | File::NOFOLLOW) do |file|
+          file.puts(JSON.dump(entry))
+          file.flush
+          file.fsync
+        end
+      end
       provisional_title(session_id: sid, request: content) if role == 'user'
       entry
     ensure
@@ -1236,12 +1278,10 @@ module PWN
       return false unless File.exist?(path)
 
       lease = activate(session_id: File.basename(path, '.jsonl'))
+      writer = File.open("#{path}.write.lock", File::RDWR | File::CREAT | File::NOFOLLOW, 0o600) # rubocop:disable Style/FileOpen -- held through atomic replace; ensure closes it
+      writer.flock(File::LOCK_EX)
       lines = File.readlines(path)
-      rows = lines.map do |l|
-        JSON.parse(l, symbolize_names: true)
-      rescue StandardError
-        nil
-      end.compact
+      rows = lines.map { |line| JSON.parse(line, symbolize_names: true) }
       return false if rows.empty?
 
       # Preserve last assistant fully-ish; compact tools and older assistants
@@ -1266,17 +1306,19 @@ module PWN
       end
       return changed if dry || !changed
 
-      tmp = "#{path}.#{Process.pid}.tmp"
-      File.open(tmp, File::WRONLY | File::CREAT | File::TRUNC, 0o600) do |f|
+      tmp = "#{path}.#{SecureRandom.hex(12)}.tmp"
+      File.open(tmp, File::WRONLY | File::CREAT | File::EXCL | File::NOFOLLOW, 0o600) do |f|
         f.flock(File::LOCK_EX)
         rows.each { |e| f.puts(JSON.generate(e)) }
         f.flush
         f.fsync
       end
       File.rename(tmp, path)
+      File.open(File.dirname(path), File::RDONLY, &:fsync)
       true
     ensure
       FileUtils.rm_f(tmp) if defined?(tmp) && tmp && File.exist?(tmp)
+      writer&.close
       deactivate(lease: lease)
     end
 
@@ -1358,7 +1400,7 @@ module PWN
         #{self}.list(include_hidden: 'optional - include unretained sessions for diagnostics and explicit resume', current_session_id: 'optional - include this active session regardless of naming classification', references: 'optional - precomputed structural dependency index')
 
         # Resolve housekeeping paths with legacy compatibility.
-        #{self}.support_path(kind: 'required - metadata, lease, owner or trace', session_id: 'required - support record identifier')
+        #{self}.support_path(kind: 'required - metadata, lease, owner or trace', session_id: 'required - support record identifier', read_only: 'optional - resolve without creating session or support directories')
 
         # Page retained sessions separately from global store diagnostics.
         #{self}.catalog(offset: 'optional - nonnegative retained session offset, omitted selects newest page', limit: 'optional - page size from one to 200, defaults 25 plus active row if outside page', current_session_id: 'optional - active session id always included without granting retention')

data/lib/pwn/setup.rb

@@ -1047,22 +1047,20 @@ module PWN
       end
 
       if dry_run
-        st = PWN::Cron.scheduler_status(apply: false)
+        st = { worker: PWN::Cron.worker_status, backend: :worker }
         io.puts "#{'cron worker'.ljust(26)} #{st.dig(:worker, :running) ? OK : MISS}   (dry-run, backend=#{st[:backend]}, enabled=#{enabled})"
         return { ok: true, dry_run: true, worker: st[:worker], backend: st[:backend], enabled: enabled }
       end
 
       unless enabled
-        native = begin
-          PWN::Cron.uninstall_scheduler(apply: opts.fetch(:apply, PWN::Cron.apply_native?))
-        rescue StandardError => e
-          io.puts "#{'cron scheduler'.ljust(26)} #{MISS}   #{e.class}: #{e.message}"
-          { ok: false, error: "#{e.class}: #{e.message}" }
-        end
+        PWN::Cron.persist_scheduler_config(enabled: false)
+        worker = PWN::Cron.stop_worker
+        native = { backend: :worker, worker: worker }
         io.puts "#{'cron scheduler'.ljust(26)} #{OK}   disabled (#{native[:backend] || 'none'})"
         return { ok: true, enabled: false, native: native, seeded: [] }
       end
 
+      PWN::Cron.persist_scheduler_config(enabled: true) if opts.key?(:enabled)
       seeded = begin
         PWN::Cron.install_defaults
       rescue StandardError => e
@@ -1078,6 +1076,7 @@ module PWN
           seeded: seeded,
           worker: live.merge(already_running: true),
           skipped_spawn: true,
+          backend: :worker,
           enabled: true
         }
       end
@@ -1097,16 +1096,9 @@ module PWN
       mark = st[:running] ? OK : MISS
       io.puts "#{'cron worker'.ljust(26)} #{mark}   #{label} pid=#{st[:pid] || worker[:pid] || 'none'}"
 
-      native = begin
-        PWN::Cron.install_scheduler(
-          enabled: true,
-          apply: opts.fetch(:apply, PWN::Cron.apply_native?)
-        )
-      rescue StandardError => e
-        io.puts "#{'cron scheduler'.ljust(26)} #{MISS}   #{e.class}: #{e.message}"
-        { ok: false, error: "#{e.class}: #{e.message}" }
-      end
-      backend = native.is_a?(Hash) ? native[:backend] : nil
+      # Setup never installs, starts, removes or repairs native schedulers.
+      native = { ok: true, backend: :worker, persisted: false }
+      backend = :worker
       io.puts "#{'cron scheduler'.ljust(26)} #{native[:ok] == false ? MISS : OK}   backend=#{backend || 'none'}"
 
       {

data/lib/pwn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PWN
-  VERSION = '0.5.783'
+  VERSION = '0.5.784'
 end

data/scripts/build_gate.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# Run only the validation gate, never installation. Keep one bounded, private
+# log even when a terminal disconnects or the child exits without a summary.
+require 'fileutils'
+require 'open3'
+
+abort 'Usage: ruby scripts/build_gate.rb command [args...]' if ARGV.empty?
+
+limit = 1_048_576
+path = File.join(Dir.home, '.pwn', 'logs', 'build-gate.log')
+FileUtils.mkdir_p(File.dirname(path), mode: 0o700)
+File.open(path, File::RDWR | File::CREAT | File::NOFOLLOW, 0o600) do |log|
+  abort "Build gate already running; log: #{path}" unless log.flock(File::LOCK_EX | File::LOCK_NB)
+
+  log.chmod(0o600)
+  log.truncate(0)
+  log.sync = true
+  $stdout.sync = true
+  append = lambda do |bytes|
+    if log.size + bytes.bytesize > limit
+      log.rewind
+      retained = (log.read + bytes).byteslice(-limit, limit)
+      log.rewind
+      log.truncate(0)
+      log.write(retained)
+    else
+      log.seek(0, IO::SEEK_END)
+      log.write(bytes)
+    end
+  end
+  emit = lambda do |bytes|
+    append.call(bytes)
+    begin
+      $stdout.write(bytes)
+    rescue Errno::EPIPE, IOError
+      # Continue draining the child into the durable log after stream loss.
+      nil
+    end
+  end
+  emit.call("Build gate log: #{path} (last #{limit} bytes; replaced on next run)\n")
+  emit.call("Gate launcher: uid=#{Process.uid} ruby=#{RUBY_VERSION} cwd=#{Dir.pwd} HOME=#{Dir.home}\n")
+  status = nil
+  Open3.popen2e(*ARGV) do |input, output, waiter|
+    input.close
+    loop { emit.call(output.readpartial(16_384)) }
+  rescue EOFError
+    status = waiter.value
+  end
+  result = status.signaled? ? "signal=#{Signal.signame(status.termsig)}" : "exit=#{status.exitstatus}"
+  emit.call("\nBuild gate #{result}\n")
+  unless status.success?
+    log.rewind
+    tail = log.read.byteslice(-16_384, 16_384) || log.tap(&:rewind).read
+    warn "\nBuild gate failed (#{result}). Build gate log: #{path}\n#{tail}"
+  end
+  exit(status.exitstatus || (128 + status.termsig))
+end

data/spec/integration/build_gate_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'open3'
+require 'tmpdir'
+
+RSpec.describe 'build gate diagnostics' do
+  it 'reports the RSpec child signal rather than only a generic command failure' do
+    Dir.mktmpdir('pwn-rake-signal-') do |home|
+      spec = File.join(home, 'terminated_spec.rb')
+      File.write(spec, "RSpec.describe('fixture') { it('terminates') { Process.kill('KILL', Process.pid) } }\n")
+      output, status = Open3.capture2e({ 'HOME' => home, 'SPEC' => spec, 'SPEC_OPTS' => nil }, 'bundle', 'exec', 'rake', 'spec')
+      expect(status.success?).to be(false)
+      expect(output).to match(/RSpec child failed: (signal=KILL|exit=137)/)
+    end
+  end
+
+  it 'retains the first failure details even if a later example terminates RSpec' do
+    Dir.mktmpdir('pwn-rake-failure-') do |home|
+      spec = File.join(home, 'terminated_spec.rb')
+      File.write(spec, "RSpec.describe('fixture') { it('fails first') { expect(1).to eq(2) }; it('terminates') { Process.kill('KILL', Process.pid) } }\n")
+      output, status = Open3.capture2e({ 'HOME' => home, 'SPEC' => spec, 'SPEC_OPTS' => nil }, 'bundle', 'exec', 'rake', 'spec')
+      expect(status.success?).to be(false)
+      expect(output).to include('fixture fails first', 'expected: 2', 'got: 1')
+    end
+  end
+
+  it 'keeps a bounded log and preserves successful exit after large output' do
+    Dir.mktmpdir('pwn-build-bound-') do |home|
+      script = File.expand_path('../../scripts/build_gate.rb', __dir__)
+      output, status = Open3.capture2e({ 'HOME' => home }, RbConfig.ruby, script, RbConfig.ruby, '-e', 'puts "x" * 2_000_000; puts "finished fixture"')
+      expect(status.success?).to be(true)
+      expect(output).to include('finished fixture')
+      log = File.join(home, '.pwn', 'logs', 'build-gate.log')
+      expect(File.size(log)).to be <= 1_048_576
+      expect(File.read(log)).to include('finished fixture', 'exit=0')
+    end
+  end
+
+  it 'records a directly signalled gate without inventing a summary' do
+    Dir.mktmpdir('pwn-build-signal-') do |home|
+      script = File.expand_path('../../scripts/build_gate.rb', __dir__)
+      output, status = Open3.capture2e({ 'HOME' => home }, RbConfig.ruby, script, RbConfig.ruby, '-e', 'Process.kill("TERM", Process.pid)')
+      expect(status.exitstatus).to eq(143)
+      expect(output).to include('signal=TERM')
+      expect(File.read(File.join(home, '.pwn', 'logs', 'build-gate.log'))).to include('signal=TERM')
+    end
+  end
+
+  it 'finishes recording when both terminal streams disconnect' do
+    Dir.mktmpdir('pwn-build-disconnect-') do |home|
+      script = File.expand_path('../../scripts/build_gate.rb', __dir__)
+      reader, writer = IO.pipe
+      reader.close
+      pid = Process.spawn({ 'HOME' => home }, RbConfig.ruby, script, RbConfig.ruby, '-e', 'warn "Failures: disconnected fixture"; exit 23', out: writer, err: writer)
+      writer.close
+      expect(Process.wait2(pid).last.exitstatus).to eq(23)
+      expect(File.read(File.join(home, '.pwn', 'logs', 'build-gate.log'))).to include('Failures: disconnected fixture', 'exit=23')
+    end
+  end
+
+  it 'preserves merged failure output and the gate exit status outside the terminal stream' do
+    Dir.mktmpdir('pwn-build-gate-') do |home|
+      script = File.expand_path('../../scripts/build_gate.rb', __dir__)
+      output, status = Open3.capture2e({ 'HOME' => home }, RbConfig.ruby, script, RbConfig.ruby, '-e', '$stdout.sync = true; puts "F.F"; warn "Failures: fixture assertion"; exit 23')
+      expect(status.exitstatus).to eq(23)
+      expect(output).to include('Failures: fixture assertion', 'exit=23', 'Build gate log:')
+      log = File.join(home, '.pwn', 'logs', 'build-gate.log')
+      expect(File.read(log)).to include('F.F', 'Failures: fixture assertion', 'exit=23')
+      expect(File.stat(log).mode & 0o777).to eq(0o600)
+    end
+  end
+end

data/spec/integration/persistence_roundtrip_spec.rb

@@ -58,13 +58,7 @@ RSpec.describe 'PWN persistence stores — write → reload → delete round-tri
       expect(PWN::Cron.list.keys).not_to include(job[:id])
 
       seeded = PWN::Cron.install_defaults
-      expect(seeded.map { |j| j[:name] }).to include(
-        'curriculum_practice_nightly',
-        'curriculum_train_weekly',
-        'curriculum_offline_judge',
-        'learning_consolidate_nightly',
-        'pwn_stores_lean_nightly'
-      )
+      expect(seeded.map { |j| j[:name] }).to eq(['session_cleanup'])
       expect(PWN::Cron.install_defaults).to eq([]) # idempotent
     end
   end

data/spec/lib/pwn/ai/agent/policy_spec.rb

@@ -12,6 +12,33 @@ describe PWN::AI::Agent::Policy do
     expect(described_class).to respond_to :help
   end
 
+  it 'serializes trajectory retention and episode append on the same permanent writer lock' do
+    Dir.mktmpdir do |tmp|
+      stub_const('PWN::AI::Agent::Policy::POLICY_FILE', File.join(tmp, 'policy.json'))
+      stub_const('PWN::AI::Agent::Policy::TRAJECTORY_FILE', File.join(tmp, 'policy_traj.jsonl'))
+      File.write(described_class::TRAJECTORY_FILE, '')
+      [-> { described_class.lean! }, -> { described_class.send(:persist_episode!, episode: { session_id: 'fixture', score: nil, steps: [] }) }].each do |operation|
+        entered = Queue.new
+        thread = nil
+        begin
+          PWN::Memory.transaction(path: described_class::TRAJECTORY_FILE) do
+            thread = Thread.new do
+              entered << true
+              operation.call
+            end
+            entered.pop
+            expect(thread.join(0.1)).to be_nil
+          end
+          expect(thread.join(2)).to eq(thread)
+          thread.value
+        ensure
+          thread&.join(2)
+        end
+      end
+      expect(described_class.trajectories.length).to eq(1)
+    end
+  end
+
   it 'learns a better Q for a rewarded action than a punished one' do
     tmp = Dir.mktmpdir
     stub_const('PWN::AI::Agent::Policy::POLICY_FILE', File.join(tmp, 'policy.json'))

data/spec/lib/pwn/ai/router_spec.rb

@@ -37,7 +37,7 @@ describe PWN::AI::Router do
     expect(PWN::Plugins::AuthenticationHelper).not_to receive(:mask_password)
     expect(PWN::AI::OpenAI).not_to receive(:obtain_oauth_bearer_token)
     allow(PWN::AI::OpenAI).to receive(:chat).and_raise(IOError, 'offline provider')
-    expect(described_class.summarize(text: 'Conversation', llm: true, session: true)).to eq('')
+    expect { described_class.summarize(text: 'Conversation', llm: true, session: true) }.to raise_error(IOError, 'offline provider')
     expect(Thread.current[:pwn_session_title]).to be_nil
     PWN::Env[:ai][:openai].delete(:key)
     expect(PWN::AI::OpenAI).not_to receive(:chat)
@@ -52,11 +52,39 @@ describe PWN::AI::Router do
       expect(mod).not_to receive(:obtain_oauth_bearer_token)
       expect(PWN::Plugins::AuthenticationHelper).not_to receive(:mask_password)
       expect(PWN::Plugins::TransparentBrowser).not_to receive(:open)
-      expect(described_class.summarize(text: 'Conversation', llm: true, session: true)).to eq('')
+      if engine == 'anthropic'
+        # This adapter parses a nil transport result; preserve that failure
+        # rather than disguising it as a downstream title JSON parse error.
+        expect { described_class.summarize(text: 'Conversation', llm: true, session: true) }.to raise_error(TypeError)
+      else
+        expect(described_class.summarize(text: 'Conversation', llm: true, session: true)).to eq('')
+      end
       expect(Thread.current[:pwn_session_title]).to be_nil
     end
   end
 
+  it 'extracts supported symbol and string keyed wrapper content without reasoning or tool data' do
+    stub_const('PWN::Env', { ai: { active: :openai, openai: { model: 'fixture', key: 'fixture-key' } } })
+    body = JSON.generate(title: 'Certificate repair', summary: 'Repaired login certificates.')
+    payloads = [
+      { choices: [{ message: { role: 'assistant', content: body } }] },
+      { 'choices' => [{ 'role' => 'assistant', 'content' => body }] },
+      { 'content' => [{ 'type' => 'thinking', 'thinking' => 'not output' }, { 'type' => 'text', 'text' => body }] },
+      { choices: [{ content: [{ type: 'output_text', text: body }] }] },
+      { message: { role: 'assistant', content: body } },
+      { title: 'Certificate repair', summary: 'Repaired login certificates.' }
+    ]
+    payloads.each do |payload|
+      allow(PWN::AI::OpenAI).to receive(:chat).and_return(payload)
+      expect(described_class.summarize(text: 'Fixture', llm: true, session: true)).to eq(body)
+    end
+    [{ content: [{ type: 'tool_use', input: { title: 'Wrong', summary: 'Wrong' } }] },
+     { choices: [{ role: 'user', content: body }] }, { content: { title: 'Wrong' } }].each do |payload|
+      allow(PWN::AI::OpenAI).to receive(:chat).and_return(payload)
+      expect(described_class.summarize(text: 'Fixture', llm: true, session: true)).to eq('')
+    end
+  end
+
   it 'should display information for authors' do
     expect(described_class).to respond_to :authors
   end

data/spec/lib/pwn/cron_spec.rb

@@ -34,6 +34,48 @@ describe PWN::Cron do
       FileUtils.remove_entry(@tmp) if @tmp && Dir.exist?(@tmp)
     end
 
+    it 'removes only a schedule without native effects when explicitly requested' do
+      target = described_class.create(name: 'curriculum_practice_nightly', enabled: false, sync_native: false)
+      other = described_class.create(name: 'custom', enabled: false, sync_native: false)
+      log = File.join(@tmp, "#{target[:id]}.log")
+      File.write(log, 'evidence')
+      expect(described_class).not_to receive(:remove_native_job)
+      described_class.remove(id: target[:id], sync_native: false)
+      expect(described_class.list).to eq(other[:id] => other)
+      expect(File.read(log)).to eq('evidence')
+    end
+
+    it 'does not resurrect a schedule removed during execution or erase concurrent creations' do
+      target = described_class.create(name: 'running', ruby: '42', sync_native: false)
+      allow(described_class).to receive(:eval) do
+        described_class.remove(id: target[:id], sync_native: false)
+        described_class.create(name: 'concurrent', ruby: '43', sync_native: false)
+        42
+      end
+      described_class.run(id: target[:id])
+      expect(described_class.list.values.map { |row| row[:name] }).to eq(['concurrent'])
+    end
+
+    it 'refuses destructive registry updates when existing YAML is corrupt' do
+      File.write(described_class.jobs_file, '--- [broken')
+      before = File.binread(described_class.jobs_file)
+      expect { described_class.remove(id: 'absent', sync_native: false) }.to raise_error(IOError)
+      expect(File.binread(described_class.jobs_file)).to eq(before)
+    end
+
+    it 'preserves concurrent process creations with atomic registry readback' do
+      count = 4
+      pids = Array.new(count) do |index|
+        fork do
+          5.times { |n| described_class.create(name: "process-#{index}-#{n}", ruby: '42', enabled: false, sync_native: false) }
+          exit! 0
+        end
+      end
+      pids.each { |pid| expect(Process.wait2(pid).last.success?).to be(true) }
+      expect(described_class.list.length).to eq(count * 5)
+      expect(Dir.glob("#{described_class.jobs_file}.*.tmp")).to be_empty
+    end
+
     it 'exposes worker control methods' do
       %i[
         due? due_jobs run_due tick worker_loop
@@ -155,9 +197,16 @@ describe PWN::Cron do
       expect(res[:started]).to be true
     end
   end
+end
+
+describe PWN::Cron do
   describe 'OS-agnostic scheduler' do
     before do
-      @tmp = Dir.mktmpdir('pwn-cron-os-spec-')
+      # install_defaults owns siblings of cron_dir (maintenance/cache/tmp).
+      # Give it a complete private root, never the shared Dir.tmpdir parent.
+      @root = Dir.mktmpdir('pwn-cron-os-spec-')
+      @tmp = File.join(@root, 'cron')
+      FileUtils.mkdir_p(@tmp)
       stub_const('PWN::Cron::CRON_DIR', @tmp)
       stub_const('PWN::Cron::JOBS_FILE', File.join(@tmp, 'jobs.yml'))
       stub_const('PWN::Cron::PID_FILE', File.join(@tmp, 'worker.pid'))
@@ -167,7 +216,53 @@ describe PWN::Cron do
 
     after do
       ENV.delete('PWN_CRON_DIR')
-      FileUtils.remove_entry(@tmp) if @tmp && Dir.exist?(@tmp)
+      FileUtils.remove_entry(@root) if @root && Dir.exist?(@root)
+    end
+
+    it 'keeps default housekeeping off every native installer' do
+      allow(described_class).to receive(:scheduler_backend).and_return(:systemd_user)
+      expect(described_class).not_to receive(:systemd_user)
+      described_class.install_defaults
+      expect(File.file?(File.join(@root, 'maintenance', 'policy.json'))).to be(true)
+      job = described_class.list.values.find { |row| row[:name] == 'session_cleanup' }
+      %i[install_native_job install_systemd_user_job install_crontab_job install_launchd_job install_schtasks_job].each do |method|
+        expect(described_class.public_send(method, job: job, apply: true)).to include(skipped: true, reason: :housekeeping_internal_only)
+      end
+      expect(Dir.glob(File.join(@tmp, 'native', "*#{job[:id]}*"))).to be_empty
+    end
+
+    it 'setup uses only the existing internal worker even with systemd available' do
+      allow(described_class).to receive(:systemd_user_available?).and_return(true)
+      expect(described_class).not_to receive(:install_scheduler)
+      expect(described_class).not_to receive(:uninstall_scheduler)
+      expect(described_class).not_to receive(:install_native_job)
+      allow(described_class).to receive(:worker_status).and_return({ running: false }, { running: true, pid: 123 })
+      expect(described_class).to receive(:ensure_worker).with(restart: false, interval: nil).once.and_return(started: true, pid: 123)
+      expect(PWN::Setup.ensure_cron(io: StringIO.new)).to include(ok: true, backend: :worker)
+    end
+
+    it 'preserves custom cron bytes and runs housekeeping identically by tick and manual run' do
+      custom = described_class.create(name: 'operator-custom', schedule: '12 9 * * *', ruby: '41', enabled: false)
+      described_class.install_defaults
+      expect(described_class.list[custom[:id]]).to eq(custom)
+      jobs = described_class.list
+      jobs.each_value { |job| job[:enabled] = false }
+      job = jobs.values.find { |row| row[:name] == 'session_cleanup' }
+      job.merge!(enabled: true, schedule: 'every 1s', ruby: 'PWN::SessionCleanup.maintain(dry_run: false)')
+      File.write(described_class.jobs_file, YAML.dump(jobs))
+      expect(PWN::SessionCleanup).to receive(:maintain).with(dry_run: false).twice.and_return(deleted: 0)
+      expect(described_class.run(id: job[:id])).to include(status: 'success', result: { deleted: 0 })
+      expect(described_class.tick(now: Time.now + 2)).to contain_exactly(include(id: job[:id], status: 'success'))
+      expect(described_class.list[custom[:id]]).to eq(custom)
+    end
+
+    it 'native worker markers exclude housekeeping while leaving custom jobs runnable' do
+      allow(ENV).to receive(:[]).and_call_original
+      allow(ENV).to receive(:[]).with('PWN_CRON_NATIVE').and_return('1')
+      house = described_class.create(name: 'session_cleanup', ruby: 'raise "must not run"')
+      custom = described_class.create(name: 'operator-custom', schedule: 'every 1s', ruby: '41')
+      expect(described_class.tick).to contain_exactly(include(id: custom[:id], status: 'success'))
+      expect(described_class.list[house[:id]][:last_run]).to be_nil
     end
 
     it 'exposes scheduler control methods' do
@@ -178,12 +273,12 @@ describe PWN::Cron do
       ].each do |m|
         expect(PWN::Cron).to respond_to(m)
       end
-      expect(PWN::Cron::DEFAULT_JOBS.length).to eq(6)
+      expect(PWN::Cron::DEFAULT_JOBS.length).to eq(1)
       names = PWN::Cron::DEFAULT_JOBS.map { |j| j[:name] }
-      expect(names).to include('pwn_stores_lean_nightly')
-      expect(names).to include('learning_consolidate_nightly')
+      expect(names).to eq(['session_cleanup'])
       enabled = PWN::Cron::DEFAULT_JOBS.reject { |j| j[:enabled] == false }.map { |j| j[:name] }
-      expect(enabled).to contain_exactly('pwn_stores_lean_nightly', 'learning_consolidate_nightly', 'session_cleanup')
+      expect(enabled).to contain_exactly('session_cleanup')
+      expect(PWN::Cron::CURRICULUM_JOBS.length).to eq(3)
     end
 
     it 'picks a native backend per OS without consulting live daemons' do
@@ -237,6 +332,7 @@ describe PWN::Cron do
       expect(body).to include('<key>KeepAlive</key>')
       PWN::Cron.list.each_value do |job|
         next unless job[:enabled]
+        next if described_class.send(:housekeeping_job?, job: job)
 
         plist = File.join(@tmp, 'native', "com.0dayinc.pwn.cron.job.#{job[:id]}.plist")
         expect(File).to exist(plist)
@@ -247,6 +343,15 @@ describe PWN::Cron do
       end
     end
 
+    it 'rejects housekeeping execution from a systemd invocation without evaluating the payload' do
+      job = described_class.create(name: 'session_cleanup', ruby: 'raise "must not run"')
+      allow(File).to receive(:read).and_call_original
+      allow(File).to receive(:read).with('/proc/self/cgroup').and_return('0::/user.slice/pwn-cron-worker.service')
+      expect(described_class.run(id: job[:id])).to include(skipped: true, reason: :housekeeping_internal_only)
+      expect(described_class.list[job[:id]][:last_run]).to be_nil
+      expect(described_class.tick).to eq([])
+    end
+
     it 'systemd backend emits OnCalendar that matches each default schedule' do
       PWN::Cron.install_defaults
       res = PWN::Cron.install_scheduler(backend: :systemd_user, apply: false)
@@ -256,6 +361,7 @@ describe PWN::Cron do
       expect(unit).to include('Restart=always')
       PWN::Cron.list.each_value do |job|
         next unless job[:enabled]
+        next if described_class.send(:housekeeping_job?, job: job)
 
         tmr = File.join(@tmp, 'native', "pwn-cron-j#{job[:id]}.timer")
         expect(File).to exist(tmr)
@@ -273,6 +379,7 @@ describe PWN::Cron do
       expect(worker).to include('PWN::Cron.ensure_worker')
       PWN::Cron.list.each_value do |job|
         next unless job[:enabled]
+        next if described_class.send(:housekeeping_job?, job: job)
 
         preview = File.read(File.join(@tmp, 'native', "job-#{job[:id]}.crontab"))
         expect(preview).to include(job[:schedule])