pwn 0.5.782 → 0.5.784

data/lib/pwn/ai/agent/curriculum.rb

@@ -229,9 +229,9 @@ module PWN
           commit  = opts.key?(:commit) ? opts[:commit] : true
           cutoff  = Time.now.utc - (since_h * 3_600)
 
-          # PWN::Sessions.list is arity-0 (no kwargs). Cap/sort after the call.
+          # Offline evidence discovery must include sessions hidden from operator lists.
           sids = if PWN::Sessions.respond_to?(:list)
-                   Array(PWN::Sessions.list)
+                   Array(PWN::Sessions.list(include_hidden: true))
                      .sort_by { |s| s.is_a?(Hash) ? s[:mtime].to_s : '' }
                      .reverse
                      .first(limit * 2)

data/lib/pwn/ai/agent/extrospection.rb

@@ -3572,16 +3572,15 @@ module PWN
             [true, log]
           when :festival
             # Use plugin if text file available
-            tmp = File.join(Dir.tmpdir, "pwn_tts_#{Process.pid}.txt")
-            File.write(tmp, text)
+            require_relative '../../../../etc/default_cron/session_cleanup' unless defined?(PWN::SessionCleanup)
             begin
-              require 'pwn/plugins/voice' unless defined?(PWN::Plugins::Voice)
-              PWN::Plugins::Voice.text_to_speech(text_path: tmp)
-              [true, 'festival via PWN::Plugins::Voice']
+              PWN::SessionCleanup.temporary(bytes: text) do |tmp|
+                require 'pwn/plugins/voice' unless defined?(PWN::Plugins::Voice)
+                PWN::Plugins::Voice.text_to_speech(text_path: tmp)
+                [true, 'festival via PWN::Plugins::Voice']
+              end
             rescue StandardError => e
               [false, "#{e.class}: #{e.message}"]
-            ensure
-              FileUtils.rm_f(tmp)
             end
           else
             [false, "unsupported TTS engine: #{engine}"]

data/lib/pwn/ai/agent/learning.rb

@@ -101,7 +101,14 @@ module PWN
         # Plan by default; no provider calls, vault reads, transcript logging or deletion.
         public_class_method def self.migrate_evidence(opts = {})
           dry = opts[:dry_run] != false
-          lock = learning_lock unless dry
+          max_sessions = opts[:max_sessions]
+          stop = opts[:stop]
+          raise ArgumentError, 'max_sessions must be positive' if max_sessions && (!max_sessions.is_a?(Integer) || max_sessions <= 0)
+
+          leases = []
+          lock = learning_lock(nonblocking: opts[:nonblocking]) unless dry
+          return { dry_run: false, deferred: 'learning_writer_active', migrated_rows: 0 } if lock == :busy
+
           original = File.exist?(LEARNING_FILE) ? evidence_read(path: LEARNING_FILE) : ''
           malformed = 0
           rows = original.lines.filter_map do |line|
@@ -116,9 +123,13 @@ module PWN
 
           report = { dry_run: dry, rows: rows.length, malformed_rows: malformed, session_refs: 0, migratable_sessions: 0,
                      missing_sessions: 0, malformed_sessions: 0, malformed_refs: 0, verified_rows: 0,
-                     estimated_source_bytes: 0, migrated_rows: 0 }
+                     estimated_source_bytes: 0, migrated_rows: 0, deferred_active_sessions: 0 }
           snapshots = {}
           rows.each do |row|
+            if stop&.call || (max_sessions && report[:migratable_sessions] >= max_sessions)
+              report[:bounded] = true
+              break
+            end
             sid = row[:session_id]
             next if sid.nil? || sid == ''
 
@@ -140,6 +151,22 @@ module PWN
               next
             end
             begin
+              # Keep the permanent exclusive lease through index publication;
+              # a point-in-time active? check alone races subsequent activation.
+              if dry
+                if PWN::Sessions.active?(session_id: sid)
+                  report[:deferred_active_sessions] += 1
+                  next
+                end
+              else
+                lease = File.open(PWN::Sessions.support_path(kind: :lease, session_id: sid), File::RDWR | File::CREAT | File::NOFOLLOW, 0o600) # rubocop:disable Style/FileOpen -- released together after commit
+                leases << lease
+                unless lease.flock(File::LOCK_EX | File::LOCK_NB)
+                  lease.close
+                  report[:deferred_active_sessions] += 1
+                  next
+                end
+              end
               body = evidence_read(path: path)
               transcript = body.lines.map { |line| JSON.parse(line, symbolize_names: true) }
               raise IOError, 'Malformed source transcript' if transcript.empty? || !transcript.all?(Hash)
@@ -179,7 +206,8 @@ module PWN
 
           evidence_commit(rows: rows, original: original, snapshots: snapshots, report: report)
         ensure
-          learning_unlock(lock: lock) if lock
+          leases&.each { |lease| lease.close unless lease.closed? }
+          learning_unlock(lock: lock) if lock && lock != :busy
         end
 
         private_class_method def self.evidence_read(opts = {})
@@ -253,6 +281,8 @@ module PWN
 
             raise IOError, 'Restore source sessions before rollback' unless evidence_complete?(row: row) && File.file?(File.join(PWN::Sessions::SESSIONS_DIR, "#{sid}.jsonl"))
           end
+          return { dry_run: true, restored: false } if opts[:dry_run] == true
+
           evidence_write(path: LEARNING_FILE, body: backup)
           evidence_write(path: path, body: JSON.generate(record.merge(state: 'rolled_back')))
           { restored: true }
@@ -262,7 +292,9 @@ module PWN
 
         private_class_method def self.evidence_write(opts = {})
           path = opts[:path]
-          body = opts[:body]
+          # Verification is byte equality, not Ruby's encoding-sensitive text equality.
+          # Retag a copy only: do not transcode, normalize or scrub evidence/backups.
+          body = opts[:body].b
           dir = File.dirname(path)
           ancestor = dir
           ancestor = File.dirname(ancestor) until File.exist?(ancestor) || File.symlink?(ancestor)
@@ -330,9 +362,10 @@ module PWN
         end
 
         # Reentrant across note_outcome -> pruning; flock serializes cooperating processes.
-        private_class_method def self.learning_lock
+        private_class_method def self.learning_lock(opts = {})
           key = :pwn_learning_write_lock
-          return nil if Thread.current[key]
+          owner = Thread.current[key]
+          return nil if owner.is_a?(Hash) && owner[:pid] == Process.pid && owner[:thread] == Thread.current && !owner[:file].closed?
 
           root = File.dirname(LEARNING_FILE)
           FileUtils.mkdir_p(root, mode: 0o700)
@@ -340,9 +373,12 @@ module PWN
           raise IOError, 'Unsafe learning lock' if File.symlink?(path) || File.realpath(root) != File.expand_path(root)
 
           # Ownership transfers to the caller's ensure/learning_unlock.
-          file = File.open(path, File::RDWR | File::CREAT, 0o600) # rubocop:disable Style/FileOpen
-          file.flock(File::LOCK_EX)
-          Thread.current[key] = file
+          file = File.open(path, File::RDWR | File::CREAT | File::NOFOLLOW, 0o600) # rubocop:disable Style/FileOpen
+          unless file.flock(File::LOCK_EX | (opts[:nonblocking] ? File::LOCK_NB : 0))
+            file.close
+            return :busy
+          end
+          Thread.current[key] = { pid: Process.pid, thread: Thread.current, file: file }
           file
         end
 
@@ -1250,6 +1286,8 @@ module PWN
         # stays high-signal.
 
         public_class_method def self.consolidate(opts = {})
+          return PWN::Memory.transaction(path: PWN::Memory::MEMORY_FILE) { consolidate(opts) } unless PWN::Memory.transaction_owned?(path: PWN::Memory::MEMORY_FILE)
+
           cap = opts[:max_entries] || MAX_MEMORY_ENTRIES
           return { removed: 0 } unless defined?(PWN::Memory)
 
@@ -2221,6 +2259,8 @@ module PWN
         # after upgrading; subsequent writes never produce these.
 
         public_class_method def self.purge_noise
+          return PWN::Memory.transaction(path: PWN::Memory::MEMORY_FILE) { purge_noise } unless PWN::Memory.transaction_owned?(path: PWN::Memory::MEMORY_FILE)
+
           return { removed: 0 } unless defined?(PWN::Memory)
 
           mem = nil
@@ -2381,10 +2421,18 @@ module PWN
         public_class_method def self.help
           puts "
             # Plan a full-snapshot evidence migration, or explicitly apply it.
-            #{self}.migrate_evidence(dry_run: 'optional - Boolean; defaults true, false writes evidence and references')
+            #{self}.migrate_evidence(
+              dry_run: 'optional - Boolean; defaults true, false writes evidence and references',
+              max_sessions: 'optional - Positive maximum source snapshots per transaction',
+              nonblocking: 'optional - Boolean; defer instead of waiting for a cooperating learning writer',
+              stop: 'optional - Cooperative stop callable checked between source snapshots'
+            )
 
             # Restore an unchanged learning ledger before any source-session cleanup.
-            #{self}.rollback_evidence(migration: 'required - SHA-256 migration ID from the ledger filename')
+            #{self}.rollback_evidence(
+              migration: 'required - SHA-256 migration ID from the ledger filename',
+              dry_run: 'optional - validate rollback without replacing learning bytes; defaults to false'
+            )
 
             # Persist derived PRM rewards without rewriting immutable supporting content.
             #{self}.annotate_evidence(

data/lib/pwn/ai/agent/mistakes.rb

@@ -63,15 +63,18 @@ module PWN
           FileUtils.mkdir_p(File.dirname(MISTAKES_FILE))
           return {} unless File.exist?(MISTAKES_FILE)
 
-          JSON.parse(File.read(MISTAKES_FILE), symbolize_names: true)
-        rescue StandardError
-          {}
+          store = JSON.parse(File.read(MISTAKES_FILE), symbolize_names: true)
+          raise IOError, 'Invalid mistakes map' unless store.is_a?(Hash)
+
+          store
         end
 
         # Supported Method Parameters::
         # PWN::AI::Agent::Mistakes.save(store: hash)
 
         public_class_method def self.save(opts = {})
+          return PWN::Memory.transaction(path: MISTAKES_FILE) { save(opts) } unless PWN::Memory.transaction_owned?(path: MISTAKES_FILE)
+
           store = opts[:store] ||= {}
           FileUtils.mkdir_p(File.dirname(MISTAKES_FILE))
           atomic_write(path: MISTAKES_FILE, body: JSON.pretty_generate(store))
@@ -195,6 +198,8 @@ module PWN
         # the caller (Loop.run) can drive cross-session repeat detection.
 
         public_class_method def self.record(opts = {})
+          return PWN::Memory.transaction(path: MISTAKES_FILE) { record(opts) } unless PWN::Memory.transaction_owned?(path: MISTAKES_FILE)
+
           tool  = opts[:tool].to_s
           error = opts[:error].to_s
           return nil if tool.empty? || error.strip.empty?
@@ -272,6 +277,8 @@ module PWN
         # )
 
         public_class_method def self.resolve(opts = {})
+          return PWN::Memory.transaction(path: MISTAKES_FILE) { resolve(opts) } unless PWN::Memory.transaction_owned?(path: MISTAKES_FILE)
+
           sig = opts[:signature].to_s
           fix = opts[:fix].to_s
           raise 'ERROR: signature is required' if sig.empty?
@@ -416,6 +423,8 @@ module PWN
         }.freeze
 
         public_class_method def self.extinguish!(opts = {})
+          return PWN::Memory.transaction(path: MISTAKES_FILE) { extinguish!(opts) } unless PWN::Memory.transaction_owned?(path: MISTAKES_FILE)
+
           sig = opts[:signature].to_s
           return nil if sig.empty?
 
@@ -457,6 +466,8 @@ module PWN
         # Auto-resolve parked items that already have a known extinguish recipe
         # so the operator inbox does not keep scars the loop can close itself.
         public_class_method def self.extinguish_parked!(opts = {})
+          return PWN::Memory.transaction(path: MISTAKES_FILE) { extinguish_parked!(opts) } unless PWN::Memory.transaction_owned?(path: MISTAKES_FILE)
+
           limit = (opts[:limit] || 20).to_i
           dry = opts[:dry_run] ? true : false
           rows = load.values.select do |m|
@@ -495,6 +506,8 @@ module PWN
         end
 
         public_class_method def self.park(opts = {})
+          return PWN::Memory.transaction(path: MISTAKES_FILE) { park(opts) } unless PWN::Memory.transaction_owned?(path: MISTAKES_FILE)
+
           sig = opts[:signature].to_s
           raise 'ERROR: signature is required' if sig.empty?
 
@@ -692,6 +705,8 @@ module PWN
         end
 
         public_class_method def self.note_hint_outcome(opts = {})
+          return PWN::Memory.transaction(path: MISTAKES_FILE) { note_hint_outcome(opts) } unless PWN::Memory.transaction_owned?(path: MISTAKES_FILE)
+
           sig = (opts[:signature] || signature(tool: opts[:tool], error: opts[:error])).to_s
           return nil if sig.empty?
 
@@ -777,6 +792,8 @@ module PWN
         # drop after Memory already holds mistake_fix_<sig>.
 
         public_class_method def self.lean!(opts = {})
+          return PWN::Memory.transaction(path: MISTAKES_FILE) { lean!(opts) } unless PWN::Memory.transaction_owned?(path: MISTAKES_FILE)
+
           dry = opts[:dry_run] ? true : false
           max_resolved = (opts[:max_resolved_kept] || MAX_RESOLVED_KEPT).to_i
           min_age = (opts[:resolved_min_age_days] || RESOLVED_MIN_AGE_DAYS).to_f
@@ -878,6 +895,8 @@ module PWN
         # PWN::AI::Agent::Mistakes.reset
 
         public_class_method def self.reset
+          return PWN::Memory.transaction(path: MISTAKES_FILE) { reset } unless PWN::Memory.transaction_owned?(path: MISTAKES_FILE)
+
           FileUtils.rm_f(MISTAKES_FILE)
           {}
         end

data/lib/pwn/ai/agent/policy.rb

@@ -4,6 +4,7 @@ require 'json'
 require 'fileutils'
 require 'time'
 require 'digest'
+require_relative '../../memory'
 
 module PWN
   module AI
@@ -696,6 +697,8 @@ module PWN
 
         public_class_method def self.lean!(opts = {})
           dry = opts[:dry_run] ? true : false
+          return PWN::Memory.transaction(path: TRAJECTORY_FILE) { lean!(opts) } unless dry || PWN::Memory.transaction_owned?(path: TRAJECTORY_FILE)
+
           return { skipped: true } unless File.exist?(TRAJECTORY_FILE)
 
           rows = File.readlines(TRAJECTORY_FILE)
@@ -1385,6 +1388,8 @@ module PWN
         end
 
         private_class_method def self.persist_episode!(opts = {})
+          return PWN::Memory.transaction(path: TRAJECTORY_FILE) { persist_episode!(opts) } unless PWN::Memory.transaction_owned?(path: TRAJECTORY_FILE)
+
           ep = opts[:episode]
           return unless ep.is_a?(Hash)
 

data/lib/pwn/ai/agent/swarm.rb

@@ -120,12 +120,19 @@ module PWN
         public_class_method def self.retire(opts = {})
           name = opts[:name].to_s
           sid = opts[:swarm_id].to_s
+          continuation = nil
+          if opts[:continuation]
+            raise ArgumentError, 'Continuation retirement requires local and swarm_id' unless opts[:local] == true && !sid.empty?
+
+            require File.expand_path('../../../../etc/default_cron/session_cleanup', __dir__)
+            continuation = PWN::SessionCleanup.retire_continuation(root: SWARM_ROOT, swarm_id: sid, name: name)
+          end
           if opts[:local] == true && !sid.empty?
             path = File.join(SWARM_ROOT, sid, 'agents.yml')
             all = load_personas_file(path: path)
             gone = all.delete(name.to_sym)
             File.write(path, YAML.dump(deep_stringify(hash: all))) if gone
-            return { name: name, removed: !gone.nil?, scope: :swarm }
+            return { name: name, removed: !gone.nil?, scope: :swarm, continuation: continuation }
           end
 
           all  = personas
@@ -414,21 +421,28 @@ module PWN
           sid  = opts[:swarm_id].to_s
           name = opts[:name].to_s
           map_path = File.join(SWARM_ROOT, sid, 'personas.json')
-          map = File.exist?(map_path) ? JSON.parse(File.read(map_path)) : {}
-          if map[name]
-            opts[:leases] << PWN::Sessions.activate(session_id: map[name]) if opts[:leases]
-            return map[name]
-          end
+          require File.expand_path('../../../../etc/default_cron/session_cleanup', __dir__)
+          PWN::SessionCleanup.with_continuation_lock(root: File.dirname(SWARM_ROOT)) do
+            raise IOError, 'Unsafe continuation map' if File.symlink?(map_path)
 
-          sess = PWN::Sessions.create(
-            title: "swarm:#{sid} persona:#{name}",
-            source: 'pwn-ai-swarm',
-            active: !opts[:leases].nil?
-          )
-          opts[:leases] << sess[:lease] if opts[:leases]
-          map[name] = sess[:id]
-          File.write(map_path, JSON.pretty_generate(map))
-          sess[:id]
+            map = File.exist?(map_path) ? JSON.parse(File.read(map_path)) : {}
+            raise IOError, 'Unknown continuation map' unless map.is_a?(Hash)
+
+            if map[name]
+              opts[:leases] << PWN::Sessions.activate(session_id: map[name]) if opts[:leases]
+              next map[name]
+            end
+
+            sess = PWN::Sessions.create(
+              title: "swarm:#{sid} persona:#{name}",
+              source: 'pwn-ai-swarm',
+              active: !opts[:leases].nil?
+            )
+            opts[:leases] << sess[:lease] if opts[:leases]
+            map[name] = sess[:id]
+            PWN::SessionCleanup.publish(map_path, JSON.pretty_generate(map))
+            sess[:id]
+          end
         end
 
         private_class_method def self.build_persona_prompt(opts = {})
@@ -759,7 +773,8 @@ module PWN
             #{self}.retire(
               name: 'required - persona name',
               swarm_id: 'optional - swarm directory when local is true',
-              local: 'optional - true retires only that swarm registry'
+              local: 'optional - true retires only that swarm registry',
+              continuation: 'optional - explicitly retire the inactive saved conversation association; requires local and swarm_id'
             )
 
             # Swarm lifecycle & bus

data/lib/pwn/ai/agent/tools/sessions.rb

@@ -52,23 +52,23 @@ PWN::AI::Agent::Registry.register(
   toolset: 'sessions',
   schema: {
     name: 'sessions_list',
-    description: 'List every pwn-ai session transcript in ~/.pwn/sessions ' \
-                 '(id, title, path, size, mtime, lines, dependencies, dependency_errors) newest-first. ' \
+    description: 'List the current active session and valid summarized or dependency-backed pwn-ai sessions in ~/.pwn/sessions ' \
+                 'as paginated concise rows (id, title, mtime, dependencies), oldest-first, with total and global diagnostics. ' \
                  'dependencies lists files referencing this session through structured links, not prose mentions. ' \
                  'Use to discover a session_id for learning_reflect / ' \
                  'learning_distill_skill / sessions_view.',
     parameters: {
       type: 'object',
       properties: {
-        limit: { type: 'integer', default: 25, description: 'Max sessions to return (newest first).' }
+        limit: { type: 'integer', default: 25, description: 'Max sessions to return (oldest first).' },
+        offset: { type: 'integer', description: 'Number of retained sessions to skip; omitted selects newest page. Current active session is also included.' }
       },
       required: []
     }
   },
   check: -> { defined?(PWN::Sessions) },
   handler: lambda { |args|
-    limit = (args[:limit] || 25).to_i
-    PWN::Sessions.list.sort_by { |s| s[:mtime].to_s }.reverse.first(limit)
+    PWN::Sessions.catalog(limit: args[:limit] || 25, offset: args[:offset], current_session_id: Thread.current[:pwn_session_id])
   }
 )
 
@@ -152,7 +152,7 @@ PWN::AI::Agent::Registry.register(
   },
   check: -> { defined?(PWN::Sessions) },
   handler: lambda { |_args|
-    listing = PWN::Sessions.list
+    listing = PWN::Sessions.list(include_hidden: true)
     PWN::Sessions.stats.merge(
       disk_bytes: listing.sum { |s| s[:size].to_i },
       dir: PWN::Sessions.sessions_dir

data/lib/pwn/ai/http_retry.rb

@@ -31,6 +31,9 @@ module PWN
       # Resolve provider defaults from the active request without mutating Env.
       public_class_method def self.provider_config(opts = {})
         engine = opts[:engine]
+        title_config = Thread.current[:pwn_session_title_config]
+        return title_config[engine] if title_config
+
         owner = Thread.current[:pwn_request_runtime]
         return owner.provider_config(engine) if owner.respond_to?(:provider_config)
 

data/lib/pwn/ai/router.rb

@@ -59,7 +59,7 @@ module PWN
 
         extractive(text: text)
       rescue StandardError
-        return '' if session
+        raise if session
 
         extractive(text: text)
       end
@@ -163,14 +163,57 @@ module PWN
         return nil unless mod.respond_to?(:chat)
 
         resp = mod.chat(request: opts[:request], model: endpoint[:model], spinner: false, quiet: true, timeout: 8)
-        text = resp.is_a?(Hash) ? (resp[:content] || resp['content'] || resp.dig(:choices, -1, :content)).to_s : resp.to_s
+        text = response_text(response: resp)
         text.strip.empty? ? nil : text
       rescue StandardError
+        raise if opts[:session]
+
         nil
       ensure
         Thread.current[:pwn_session_title] = previous_title_worker
       end
 
+      # Only decode documented assistant-content locations, never container inspect
+      # strings, reasoning blocks, tool arguments or echoed user messages.
+      private_class_method def self.response_text(opts = {})
+        response = opts[:response]
+        return response if response.is_a?(String)
+        return '' unless response.is_a?(Hash)
+
+        row = response.transform_keys(&:to_s)
+        return JSON.generate(row) if row['title'].is_a?(String) && row['summary'].is_a?(String)
+        return content_text(content: row['content']) if row.key?('content')
+
+        choice = Array(row['choices']).last
+        if choice.is_a?(Hash)
+          choice = choice.transform_keys(&:to_s)
+          message = choice['message'] || choice
+          if message.is_a?(Hash)
+            message = message.transform_keys(&:to_s)
+            return '' if message['role'] && message['role'] != 'assistant'
+
+            return content_text(content: message['content'])
+          end
+        end
+        message = row['message']
+        return content_text(content: message[:content] || message['content']) if message.is_a?(Hash)
+
+        ''
+      end
+
+      private_class_method def self.content_text(opts = {})
+        content = opts[:content]
+        return content if content.is_a?(String)
+        return '' unless content.is_a?(Array)
+
+        content.filter_map do |block|
+          next unless block.is_a?(Hash)
+
+          block = block.transform_keys(&:to_s)
+          block['text'] if %w[text output_text].include?(block['type']) && block['text'].is_a?(String)
+        end.join
+      end
+
       private_class_method def self.active_session_endpoint
         engine = env_dig(keys: %i[ai active]).to_s.downcase
         { engine: engine, model: env_dig(keys: [:ai, engine.to_sym, :model]) }
@@ -226,7 +269,9 @@ module PWN
       private_class_method def self.env_dig(opts = {})
         return {} unless defined?(PWN::Env) && PWN::Env.respond_to?(:dig)
 
-        val = PWN::Env.dig(*opts[:keys])
+        keys = opts[:keys]
+        config = Thread.current[:pwn_session_title_config]
+        val = config && keys.first == :ai ? config.dig(*keys.drop(1)) : PWN::Env.dig(*keys)
         if val.is_a?(Hash)
           val.transform_keys { |key| key.is_a?(String) ? key.to_sym : key }
         else