pwn 0.5.782 → 0.5.783

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

@@ -262,7 +262,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)
@@ -332,7 +334,8 @@ module PWN
         # Reentrant across note_outcome -> pruning; flock serializes cooperating processes.
         private_class_method def self.learning_lock
           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 +343,9 @@ 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 = File.open(path, File::RDWR | File::CREAT | File::NOFOLLOW, 0o600) # rubocop:disable Style/FileOpen
           file.flock(File::LOCK_EX)
-          Thread.current[key] = file
+          Thread.current[key] = { pid: Process.pid, thread: Thread.current, file: file }
           file
         end
 
@@ -1250,6 +1253,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 +2226,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

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/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

@@ -226,7 +226,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

data/lib/pwn/cron.rb

@@ -255,7 +255,7 @@ module PWN
       {
         name: 'session_cleanup',
         schedule: '45 3 * * *',
-        ruby: "require File.join(PWN::Cron.cron_dir, 'session_cleanup.rb'); PWN::SessionCleanup.run(dry_run: false)",
+        ruby: "require File.join(PWN::Cron.cron_dir, 'session_cleanup.rb'); PWN::SessionCleanup.maintain(dry_run: false)",
         enabled: true
       },
       {

data/lib/pwn/memory.rb

@@ -23,6 +23,31 @@ module PWN
     EPHEMERAL_KEY_PREFIXES = %w[session_].freeze
     EPHEMERAL_TTL_SECS = 7 * 86_400
 
+    # Permanent writer inode; nested calls share ownership only in this thread
+    # and process. Never unlink this lock when replacing a data file.
+    public_class_method def self.transaction(opts = {})
+      path = File.expand_path(opts[:path] || MEMORY_FILE)
+      return yield if transaction_owned?(path: path)
+
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open("#{path}.write.lock", File::RDWR | File::CREAT | File::NOFOLLOW, 0o600) do |lock|
+        lock.flock(File::LOCK_EX)
+        owners = (Thread.current[:pwn_store_transactions] ||= {})
+        owners[path] = Process.pid
+        begin
+          yield
+        ensure
+          owners.delete(path)
+        end
+      end
+    end
+
+    # Test ownership without mistaking an inherited post-fork marker for a lock.
+    public_class_method def self.transaction_owned?(opts = {})
+      path = File.expand_path(opts[:path] || MEMORY_FILE)
+      Thread.current[:pwn_store_transactions]&.fetch(path, nil) == Process.pid
+    end
+
     # Supported Method Parameters::
     #   memory = PWN::Memory.load
     public_class_method def self.load
@@ -47,6 +72,8 @@ module PWN
     # Supported Method Parameters::
     #   PWN::Memory.save(mem: memory_hash)
     public_class_method def self.save(opts = {})
+      return transaction(path: MEMORY_FILE) { save(opts) } unless PWN::Memory.transaction_owned?(path: MEMORY_FILE)
+
       mem = opts[:mem] ||= {}
       force = opts[:force] ? true : false
       FileUtils.mkdir_p(File.dirname(MEMORY_FILE))
@@ -58,8 +85,15 @@ module PWN
         warn "[pwn-ai/memory] refusing empty overwrite of #{File.size(path)}B #{path} (pass force:true to clear)"
         return load_raw_or_empty(path: path)
       end
+      atomic_write(path: path, body: JSON.pretty_generate(mem))
+      mem
+    end
+
+    # Caller holds the permanent store transaction across read and replacement.
+    private_class_method def self.atomic_write(opts = {})
+      path = opts[:path]
+      body = opts[:body]
       tmp = File.join(File.dirname(path), ".#{File.basename(path)}.#{Process.pid}.tmp")
-      body = JSON.pretty_generate(mem)
       File.open(tmp, File::WRONLY | File::CREAT | File::TRUNC, 0o644) do |f|
         f.flock(File::LOCK_EX)
         f.write(body)
@@ -67,7 +101,7 @@ module PWN
         f.fsync
       end
       File.rename(tmp, path)
-      mem
+      File.open(File.dirname(path), File::RDONLY, &:fsync)
     ensure
       FileUtils.rm_f(tmp) if defined?(tmp) && tmp && File.exist?(tmp)
     end
@@ -93,6 +127,8 @@ module PWN
     #     ttl: 'optional - seconds until stale (M3; consolidate evicts stale low-conf first)'
     #   )
     public_class_method def self.remember(opts = {})
+      return transaction(path: MEMORY_FILE) { remember(opts) } unless PWN::Memory.transaction_owned?(path: MEMORY_FILE)
+
       key = opts[:key]
       value = opts[:value]
       category = opts[:category] || :fact
@@ -479,7 +515,9 @@ module PWN
     #     force: 'optional - Boolean bypass protect policy (default false)'
     #   )
     # Refuses PROTECT_KEY_PREFIXES / PROTECT_CATEGORIES unless force:true.
-    public_class_method def self.forget(opts = {}) # rubocop:disable Naming/PredicateMethod
+    public_class_method def self.forget(opts = {})
+      return transaction(path: MEMORY_FILE) { forget(opts) } unless PWN::Memory.transaction_owned?(path: MEMORY_FILE)
+
       key = opts[:key]
       raise 'ERROR: key is required' if key.nil?
 
@@ -498,6 +536,8 @@ module PWN
     #   PWN::Memory.clear(force: true)
     # Requires force:true — protected prefs/SOPs must not vanish via bare clear.
     public_class_method def self.clear(opts = {})
+      return transaction(path: MEMORY_FILE) { clear(opts) } unless PWN::Memory.transaction_owned?(path: MEMORY_FILE)
+
       force = if opts.is_a?(Hash)
                 opts[:force] ? true : false
               else
@@ -514,6 +554,8 @@ module PWN
     #   context = PWN::Memory.to_context(limit: 20)
     #   (used internally by pwn-ai hook to inject into system prompt)
     public_class_method def self.to_context(opts = {})
+      return transaction(path: MEMORY_FILE) { to_context(opts) } unless PWN::Memory.transaction_owned?(path: MEMORY_FILE)
+
       limit = (opts[:limit] || 12).to_i
       limit = 12 if limit <= 0
       mem = load
@@ -556,14 +598,20 @@ module PWN
     end
 
     private_class_method def self.archive_expired!(opts = {})
+      return transaction(path: MEMORY_FILE) { archive_expired!(opts) } unless PWN::Memory.transaction_owned?(path: MEMORY_FILE)
+
       rows = opts[:rows]
       return if rows.nil? || rows.empty?
 
+      mem = load
+      rows = rows.select { |key, value| mem[key] == value }
+      return if rows.empty?
+
       arch = File.file?(ARCHIVE_FILE) ? JSON.parse(File.read(ARCHIVE_FILE), symbolize_names: true) : {}
+      raise IOError, 'Invalid memory archive' unless arch.is_a?(Hash)
+
       arch.merge!(rows)
-      FileUtils.mkdir_p(File.dirname(ARCHIVE_FILE))
-      File.write(ARCHIVE_FILE, JSON.pretty_generate(arch))
-      mem = load
+      atomic_write(path: ARCHIVE_FILE, body: JSON.pretty_generate(arch))
       rows.each_key { |k| mem.delete(k) }
       save(mem: mem, force: mem.empty?)
     rescue StandardError
@@ -590,6 +638,8 @@ module PWN
     # Compact overlong values and drop expired ephemeral session_* keys.
     # Never removes protected prefs/SOPs/fix lessons. Safe with empty-save guard.
     public_class_method def self.lean!(opts = {})
+      return transaction(path: MEMORY_FILE) { lean!(opts) } unless PWN::Memory.transaction_owned?(path: MEMORY_FILE)
+
       dry = opts[:dry_run] ? true : false
       vmax = (opts[:value_max_chars] || VALUE_MAX_CHARS).to_i
       ttl_secs = (opts[:ephemeral_ttl_secs] || EPHEMERAL_TTL_SECS).to_i
@@ -650,6 +700,12 @@ module PWN
     # Display Usage for this Module
     public_class_method def self.help
       puts "USAGE:
+        # Serialize a complete read-modify-write operation.
+        #{self}.transaction(path: 'optional - data store path, defaults to memory') { operation }
+
+        # Check current process and thread ownership.
+        #{self}.transaction_owned?(path: 'optional - data store path, defaults to memory')
+
         # Run load and return its result
         #{self}.load
 

data/lib/pwn/plugins/repl/ai.rb

@@ -129,7 +129,9 @@ module PWN
               case cmd
               when 'list', nil
                 output.puts('Session dependencies: referenced by these files; text mentions are not links.')
-                PWN::Plugins::REPL.pwn_ai_print_result(value: PWN::Sessions.list, output: output)
+                PWN::Plugins::REPL.pwn_ai_print_result(value: PWN::Sessions.catalog(offset: args[1], limit: args[2] || 25, current_session_id: pry_instance.config.pwn_ai_session_id), output: output)
+              when 'cleanup'
+                PWN::Plugins::REPL.pwn_ai_run_sessions(args: args)
               when 'resume'
                 sid = args[1]
                 hist = PWN::Sessions.to_response_history(session_id: sid)
@@ -262,7 +264,7 @@ module PWN
           '/mcp' => %w[list backends use current connect disconnect ping tools call status help],
           '/model' => %w[list],
           '/swarm' => %w[mission agents status create use spawn retire dm debate broadcast tail steer pause resume cancel help],
-          '/sessions' => %w[list resume delete stats],
+          '/sessions' => %w[list resume delete stats cleanup],
 
           '/skills' => %w[list recall],
           '/learning' => %w[list requeue]
@@ -599,6 +601,8 @@ module PWN
             end
             true
           rescue StandardError => e
+            raise if opts[:raise_errors]
+
             warn "[pwn-ai] #{cmd}: #{e.class}: #{e.message}"
             true
           end
@@ -1038,7 +1042,13 @@ module PWN
             case sub
             when 'list'
               puts('Session dependencies: referenced by these files; text mentions are not links.')
-              pwn_ai_print_result(value: PWN::Sessions.list)
+              pwn_ai_print_result(value: PWN::Sessions.catalog(offset: args[1], limit: args[2] || 25, current_session_id: opts[:pry]&.config&.pwn_ai_session_id))
+            when 'cleanup'
+              raise ArgumentError, 'usage: /sessions cleanup [--dry-run]' unless args.drop(1).empty? || args.drop(1) == ['--dry-run']
+
+              require File.expand_path('../../../../etc/default_cron/session_cleanup', __dir__)
+              result = PWN::SessionCleanup.maintain(dry_run: args.include?('--dry-run'), current_session_id: opts[:pry]&.config&.pwn_ai_session_id)
+              pwn_ai_print_result(value: PWN::SessionCleanup.summary(result))
             when 'resume'
               sid = PWN::Sessions.resolve(identifier: opts[:identifier] || args.drop(1).join(' '))
               lease = PWN::Sessions.activate(session_id: sid)

data/lib/pwn/plugins/repl/ai_console.rb

@@ -637,15 +637,14 @@ module PWN
                 finish_request_metrics
                 @running = false
                 @control = nil
-                queue_title_update(text) if text
+                queue_title_update(*text) if text
               when :session_title
                 @session_metadata = text if text && text[:id] == @pry.config.pwn_ai_session_id
               when :title_done
                 @title_worker.join
                 @title_worker = nil
-                pending = @title_pending
-                @title_pending = nil
-                queue_title_update(pending) if pending
+                pending = @title_pending&.shift
+                queue_title_update(*pending) if pending
               else
                 add(type, text)
               end
@@ -654,13 +653,16 @@ module PWN
             nil
           end
 
-          def queue_title_update(session_id)
+          def queue_title_update(session_id, ai_config = Marshal.load(Marshal.dump(PWN::Env[:ai])))
+            @title_pending ||= {}
             if @title_worker
-              @title_pending = session_id
+              @title_pending[session_id] = ai_config
               return
             end
             @title_worker = Thread.new do
-              @events << [:session_title, PWN::Sessions.refresh_title(session_id: session_id)]
+              @events << [:session_title, PWN::Sessions.refresh_title(session_id: session_id, ai_config: ai_config, on_error: lambda { |kind|
+                @events << [:warning, "Session title refresh unavailable for #{session_id} (#{kind}); previous title retained. Resume this session to retry."]
+              })]
             ensure
               @events << [:title_done, nil]
             end
@@ -689,8 +691,9 @@ module PWN
             PWN::Plugins::Log.mirror_tui!(msg: "#{type.to_s.upcase}\n#{clean}") if @pry.config.pwn_ai_debug && type != :notice
           end
 
-          def start_request(request, command: false)
+          def start_request(request, command: false, &operation)
             session_id = @pry.config.pwn_ai_session_id
+            title_config = Marshal.load(Marshal.dump(PWN::Env[:ai]))
             @locals = Thread.current.keys.select { |key| key.to_s.start_with?('pwn_') }.to_h { |key| [key, Thread.current[key]] }
             @thread_variables = Thread.current.thread_variables.select { |key| key.to_s.start_with?('pwn_') }.to_h { |key| [key, Thread.current.thread_variable_get(key)] }
             # A fresh forwarding pipe prevents unread input crossing requests.
@@ -725,16 +728,24 @@ module PWN
               end
               if command
                 control.checkpoint(messages: [], phase: :tool)
-                if request.match?(%r{\A/model(?:\s|$)})
+                if operation
+                  operation.call
+                elsif request.match?(%r{\A/model(?:\s|$)})
                   REPL.pwn_ai_run_model(args: request.split.drop(1), prompt: lambda { |selection|
                     control.checkpoint(messages: [])
                     @events << [:model_prompt, selection]
                     :deferred
                   })
                 else
-                  REPL.pwn_ai_dispatch_slash!(request: request, pry: @pry)
+                  REPL.pwn_ai_dispatch_slash!(request: request, pry: @pry, raise_errors: true)
+                end
+                # Maintenance is one safe transaction: never label its committed
+                # deletions cancelled merely because stop was requested mid-write.
+                if request.match?(%r{\A/sessions\s+cleanup(?:\s|$)})
+                  @events << [:notice, 'Session cleanup finished; completed work is not undone.']
+                else
+                  control.checkpoint(messages: [])
                 end
-                control.checkpoint(messages: [])
               else
                 workspace = File.realpath(Dir.pwd)
                 workspace_lock = File.open(File.join(Dir.tmpdir, "pwn-solve-#{Digest::SHA256.hexdigest(workspace)}.lock"), File::RDWR | File::CREAT | File::NOFOLLOW, 0o600) # rubocop:disable Style/FileOpen -- worker ensure owns the lease
@@ -757,7 +768,7 @@ module PWN
               @events << [:warning, "#{e.class}: #{e.message}"]
             ensure
               workspace_lock&.close
-              @events << [:done, command ? nil : session_id]
+              @events << [:done, command ? nil : [session_id, title_config]]
             end
             @worker.report_on_exception = false
             @control = ready.pop
@@ -810,7 +821,7 @@ module PWN
               clear_view
             elsif ['/sessions', '/sessions picker'].include?(line.strip)
               open_operator(:sessions)
-            elsif line.strip == '/sessions cleanup'
+            elsif line.strip == '/sessions cleanup --dry-run'
               open_operator(:cleanup)
             elsif line.strip == '/evidence'
               open_operator(:evidence)
@@ -837,7 +848,7 @@ module PWN
               open_vault_edit(line)
             elsif line.strip == '/system-role'
               open_system_role
-            elsif line.match?(%r{\A/(?:mcp(?:\s|$)|cron\s+run(?:\s|$)|model(?:\s|$))})
+            elsif line.match?(%r{\A/(?:mcp(?:\s|$)|cron\s+run(?:\s|$)|model(?:\s|$)|sessions\s+cleanup(?:\s|$))})
               start_request(line, command: true)
             elsif line.start_with?('/') || line.start_with?('ai.profile ', 'ai.memory ')
               if line.match?(%r{\A/sessions[[:space:]]+resume(?:[[:space:]]|$)})
@@ -845,6 +856,7 @@ module PWN
 
                 REPL.pwn_ai_dispatch_slash!(request: line, pry: @pry)
                 @session_metadata = PWN::Sessions.metadata(session_id: @pry.config.pwn_ai_session_id)
+                queue_title_update(@pry.config.pwn_ai_session_id)
               elsif !REPL.pwn_ai_dispatch_slash!(request: line, pry: @pry)
                 add(:warning, 'Unknown command. Use / or Tab for commands.')
               end
@@ -2027,7 +2039,7 @@ module PWN
             view[:rows] = PWN::Sessions.list.sort_by { |row| [row[:mtime].to_s, row[:id]] } if view[:kind] == :sessions
             if view[:kind] == :cleanup
               require File.expand_path('../../../../etc/default_cron/session_cleanup', __dir__)
-              view[:plan] = PWN::SessionCleanup.run(current_session_id: session_id)
+              view[:plan] = PWN::SessionCleanup.maintain(dry_run: true, current_session_id: session_id)
               view[:rows] = view[:plan][:records].map do |row|
                 category = row[:skip] || row[:apply_blocked_by] || (if row[:classification] == :named
                                                                       :summarized
@@ -2352,7 +2364,7 @@ module PWN
             ['START HERE · local guide; no work is launched here.',
              'Write a task in MISSION CONTROL. /readiness checks routes, tools and workspace locally.',
              'Ctrl+S opens the team workspace. v previews your exact mission draft before confirmation.',
-             '/evidence inspects actual checks and revisions. /sessions finds stable IDs; /sessions cleanup previews retention.',
+             '/evidence inspects actual checks and revisions. /sessions cleanup runs maintenance; add --dry-run to preview.',
              '/learning inbox reviews retained evidence. /steer queues guidance; Ctrl+C requests cancellation, not undo.',
              '1 Insert: Inspect this workspace and explain its entry points without changing files.',
              '2 Insert: Add a regression test for the reported bug, fix it, and execute the test.',
@@ -2390,13 +2402,17 @@ module PWN
           end
 
           def apply_operator_cleanup
+            return add(:warning, 'Maintenance waits until the active request or swarm finishes.') if busy?
+
             view = @operator_view
-            approved = view[:plan][:records].select { |row| view[:plan][:candidate_ids].include?(row[:id]) }.to_h { |row| [row[:id], row[:files]] }
-            result = PWN::SessionCleanup.run(dry_run: false, current_session_id: @pry.config.pwn_ai_session_id, approved_candidates: approved)
+            approved = view[:plan][:records].select { |row| view[:plan][:candidate_ids].include?(row[:id]) }.to_h { |row| [row[:id], { files: row[:files], dependency_records: row[:dependency_records] }] }
+            session_id = @pry.config.pwn_ai_session_id
             view.delete(:confirm)
-            view[:notice] = "Deleted: #{result[:deleted_ids].join(', ')}; backup: #{result[:archive_dir] || 'none'}; skipped: #{result[:skipped]}"
-            add(:command, REPL.pwn_ai_result_text(value: result))
-            refresh_operator
+            @operator_view = nil
+            start_request('/sessions cleanup (approved preview)', command: true) do
+              result = PWN::SessionCleanup.run(dry_run: false, current_session_id: session_id, approved_candidates: approved)
+              @events << [:command, REPL.pwn_ai_result_text(value: result)]
+            end
           end
 
           def operator_viewport(page)

data/lib/pwn/session_trace.rb

@@ -119,7 +119,7 @@ module PWN
       id = opts[:session_id].to_s
       raise ArgumentError, 'Invalid session id' unless id.match?(/\A[A-Za-z0-9][A-Za-z0-9_-]{0,127}\z/)
 
-      dir = File.join(PWN::Sessions.sessions_dir, id)
+      dir = File.dirname(PWN::Sessions.support_path(kind: :trace, session_id: id))
       raise ArgumentError, 'Symlinked trace directory' if File.symlink?(dir)
 
       File.join(dir, 'trace.jsonl')