agent_sessions 0.3.0

data/lib/agent/sessions/readers/qwen.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Agent
+  module Sessions
+        module Readers
+          # Qwen Code chat files. PROVISIONAL, like the adapter: written against
+          # tokentelemetry's parser of this format, not against real Qwen output.
+          #
+          # The record shape is Anthropic's — type user/assistant, message.content
+          # as an array of typed parts, message.usage with the same five spellings
+          # Claude uses. This is deliberately NOT a subclass of Readers::Claude
+          # despite that overlap: Claude's reader also carries Claude Code's sidecar
+          # machinery (spilled tool output, subagent transcripts, uuid/parentUuid
+          # branching), none of which is known to exist here, and inheriting would
+          # mean disabling each one and then re-checking every future Claude change
+          # against an agent nobody can test. Two readers with two evidence bases
+          # will drift honestly; one reader pretending to serve both will drift
+          # silently.
+          class Qwen < Base
+            CONTENT_PARTS = { "text" => :text, "thinking" => :thinking, "tool_use" => :tool_use,
+                              "tool_result" => :tool_result, "image" => :image }.freeze
+
+            # Session totals, deduplicated by message.id the way Claude's are: the
+            # same API response can stream into one record per content block, and
+            # both agents speak the same wire format. Unverified for Qwen — if its
+            # writer does not repeat ids, this dedup is simply a no-op.
+            def usage
+              seen = {}
+              total = nil
+              each_record do |record, _line_number|
+                usage = usage_from(record)
+                next unless usage
+
+                id = record.dig("message", "id")
+                next if id && seen[id]
+
+                seen[id] = true if id
+                total = total ? total + usage : usage
+              end
+              total
+            end
+
+            private
+
+            def message_for(record, line_number)
+              type = record["type"]
+              return nil if type == "summary"
+
+              unless %w[user assistant].include?(type)
+                warn_about("line #{line_number}: unrecognized record type #{type.inspect}")
+                return build(record, :unknown, [Part.new(type: :unknown)])
+              end
+
+              build(record, type.to_sym, content_parts(record, line_number))
+            end
+
+            # content is an array of parts, or a bare String saying the same thing
+            # shorter — both spellings appear in this wire format.
+            def content_parts(record, line_number)
+              content = record.dig("message", "content")
+              return [Part.new(type: :text, text: content)] if content.is_a?(String)
+
+              Array(content).map { |item| part_for(item, line_number) }
+            end
+
+            def part_for(item, line_number)
+              return Part.new(type: :unknown) unless item.is_a?(Hash)
+
+              case CONTENT_PARTS[item["type"]]
+              when :text then Part.new(type: :text, text: item["text"].to_s)
+              when :thinking then Part.new(type: :thinking, text: item["thinking"].to_s)
+              when :image then Part.new(type: :image)
+              when :tool_use
+                Part.new(type: :tool_use, name: item["name"], call_id: item["id"],
+                         text: stringify(item["input"]))
+              when :tool_result
+                Part.new(type: :tool_result, call_id: item["tool_use_id"],
+                         text: flatten_result(item["content"]))
+              else
+                warn_about("line #{line_number}: unrecognized content part #{item["type"].inspect}")
+                Part.new(type: :unknown, text: item["text"])
+              end
+            end
+
+            def flatten_result(content)
+              return content if content.is_a?(String)
+
+              Array(content).filter_map { |item| item["text"] if item.is_a?(Hash) && item["type"] == "text" }.join
+            end
+
+            def build(record, role, parts)
+              model = record.dig("message", "model")
+              Message.new(role: role, at: time_from(record["timestamp"]), parts: parts, raw: record,
+                          usage: usage_from(record), model: model.is_a?(String) ? model : nil)
+            end
+
+            # The Anthropic spelling, where input_tokens is already disjoint from
+            # the cache counts — so unlike Gemini's and Codex's, nothing is
+            # subtracted here. ephemeral_1h_input_tokens is a cache-creation count
+            # at a different TTL; it is added to cache_creation rather than given a
+            # bucket of its own, because this gem's Usage does not model TTL and
+            # dropping it would under-report what was written to cache.
+            def usage_from(record)
+              usage = record.dig("message", "usage")
+              return nil unless usage.is_a?(Hash)
+
+              creation = count_from(usage["cache_creation_input_tokens"])
+              hourly = count_from(usage.dig("cache_creation", "ephemeral_1h_input_tokens"))
+              mapped = Usage.new(input: count_from(usage["input_tokens"]),
+                                 output: count_from(usage["output_tokens"]),
+                                 cache_read: count_from(usage["cache_read_input_tokens"]),
+                                 cache_creation: creation || hourly ? creation.to_i + hourly.to_i : nil)
+              mapped.to_h.each_value.any? ? mapped : nil
+            end
+
+            def stringify(value)
+              value.is_a?(String) || value.nil? ? value.to_s : JSON.generate(value)
+            end
+          end
+        end
+  end
+end

data/lib/agent/sessions/session.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Agent
+  module Sessions
+        # One recorded conversation. Everything here comes from a stat or the store's
+        # own metadata — except project_path, which may need to read inside the session
+        # file (design doc section 7: the on-disk directory encodings are lossy, so the
+        # recorded cwd inside the file is the only reliable source). It is computed on
+        # first access and memoized, which is why this is a plain class rather than a
+        # frozen Data: an instance is immutable except for that one memo.
+        #
+        # Equality is identity, not value — unlike every sibling value object here, which
+        # gets value equality for free from Data. A value comparison would have to force
+        # project_path on both operands, turning a `uniq` over thousands of sessions into
+        # the full content sweep the design works to avoid. A caller keying a mixed-agent
+        # collection should use `uid`, which exists for exactly that. Note `to_h` includes
+        # `uid`, so its output does not round-trip back through `new`.
+        class Session
+          UNRESOLVED = Object.new.freeze
+          private_constant :UNRESOLVED
+
+          attr_reader :agent, :id, :path, :started_at, :updated_at, :bytes, :format, :fidelity
+
+          def initialize(agent:, id:, path:, started_at:, updated_at:, bytes:, format:, fidelity:,
+                         project_path: UNRESOLVED, &project_path_resolver)
+            @agent = agent
+            @id = id
+            @path = path
+            @started_at = started_at
+            @updated_at = updated_at
+            @bytes = bytes
+            @format = format
+            @fidelity = fidelity
+            @project_path = project_path
+            @project_path_resolver = project_path_resolver
+          end
+
+          # Collision-free across a mixed-agent collection, where bare ids may repeat.
+          def uid = "#{agent}:#{id}"
+
+          # A resolver that raises is deliberately not memoized: a failed read is not an
+          # answer, so the next call retries rather than freezing the failure in place.
+          #
+          # Not thread-safe by design: concurrent first access can run the resolver more
+          # than once, but every run yields the same value and the assignment is atomic
+          # on MRI, so there is no torn read to guard against. Do not add a mutex.
+          def project_path
+            return @project_path unless @project_path.equal?(UNRESOLVED)
+
+            @project_path = @project_path_resolver&.call
+            @project_path_resolver = nil
+            @project_path
+          end
+
+          # The honest full dump — includes project_path, so it forces that read.
+          # Callers listing thousands of sessions should build their own slimmer rows.
+          def to_h
+            {
+              agent: agent, id: id, uid: uid, path: path, project_path: project_path,
+              started_at: started_at, updated_at: updated_at,
+              bytes: bytes, format: format, fidelity: fidelity
+            }
+          end
+
+          # Never calls project_path: inspecting a session in a debugger must not
+          # trigger the read that enumeration deliberately deferred.
+          def inspect
+            resolved = @project_path.equal?(UNRESOLVED) ? "(unresolved)" : @project_path.inspect
+            "#<#{self.class.name} agent: #{agent.inspect}, id: #{id.inspect}, path: #{path.inspect}, " \
+              "project_path: #{resolved}, started_at: #{started_at.inspect}, updated_at: #{updated_at.inspect}, " \
+              "bytes: #{bytes.inspect}, format: #{format.inspect}, fidelity: #{fidelity.inspect}>"
+          end
+        end
+  end
+end

data/lib/agent/sessions/sqlite.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Agent
+  module Sessions
+        # The one way this gem opens a SQLite store: read-only, URI-escaped, with a
+        # bounded retry against a live writer's lock. Extracted from the opencode
+        # adapter when the opencode reader became its second caller — two copies of
+        # escape_uri_path would drift, and the bug it guards is subtle enough that a
+        # drifted copy would look correct in review.
+        #
+        # What differs between callers stays with them: the adapter raises
+        # UnreadableStore on a query failure because a vanished database means no
+        # sessions at all, while a reader warns and yields nothing because one
+        # unreadable session must not take down a sweep (Layer 3 rule 2). This
+        # module only opens; it never decides what a failure means.
+        module Sqlite
+          module_function
+
+          # No immutable=1: it tells SQLite to trust that the file will never change
+          # and skip locking AND the WAL entirely — against a live, WAL-mode
+          # opencode.db that means silently missing every committed-but-not-yet-
+          # checkpointed session. Opening a WAL db even read-only touches its -shm
+          # and -wal sidecars (SQLite's own reader bookkeeping, confirmed directly);
+          # the recorded sessions themselves are never written.
+          #
+          # busy_timeout gives SQLite up to 5s to retry internally against a lock
+          # held by the agent's own live writer. A WAL writer's lock is normally held
+          # only for the instant of a commit, so a lock that has not cleared within
+          # 5s is a stuck process, not ordinary contention.
+          def open_readonly(path)
+            db = SQLite3::Database.new(
+              "file:#{escape_uri_path(path)}?mode=ro",
+              flags: SQLite3::Constants::Open::READONLY | SQLite3::Constants::Open::URI
+            )
+            db.busy_timeout = 5_000
+            db
+          end
+
+          # IMPORTANT, caught in review: SQLite's URI parser gives `%`, `#` and `?`
+          # syntactic meaning, and the path was being interpolated raw. `#` starts a
+          # fragment (silently truncating the path there); `?` starts the query
+          # string, colliding with the `?mode=ro` open_readonly appends. The worst
+          # case, confirmed directly: a path segment that merely CONTAINS a
+          # valid-looking percent-escape — a directory literally named "a%23b" —
+          # gets that escape DECODED by the URI parser into a different path
+          # ("a#b"), so a second, unrelated database sitting at THAT path is read
+          # instead, silently, with no exception at all. One pass, not two
+          # sequential gsubs: escaping # to %23 and THEN escaping the % that
+          # produced would double-encode it to %2523.
+          def escape_uri_path(path)
+            path.gsub(/[%#?]/) { format("%%%02X", _1.ord) }
+          end
+        end
+  end
+end

data/lib/agent/sessions/store.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Agent
+  module Sessions
+        Store = Data.define(
+          :agent, :label, :documented, :verified_on,
+          :effective, :layers, :env_overrides,
+          :retention, :retention_source, :warnings
+        ) do
+          def documented? = documented == true
+          def installed? = layers.any?(&:exists?)
+          def format = effective.format
+        end
+  end
+end

data/lib/agent/sessions/unknown_agent.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Agent
+  module Sessions
+          class UnknownAgent < Error; end
+  end
+end

data/lib/agent/sessions/unreadable_store.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Agent
+  module Sessions
+          class UnreadableStore < Error; end
+  end
+end

data/lib/agent/sessions/unsupported_format.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Agent
+  module Sessions
+          class UnsupportedFormat < Error; end
+  end
+end

data/lib/agent/sessions/usage.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Agent
+  module Sessions
+          # Token counts an agent reported, for one message or one whole session,
+          # normalized to five DISJOINT buckets: `input` never includes what was read
+          # from or written to cache, and `output` never includes `reasoning`. Agents
+          # disagree here — Codex's input_tokens includes its cached_input_tokens,
+          # Claude's does not (both verified against real stores on this machine,
+          # 2026-08-24) — and a caller summing across agents needs one rule, not one
+          # per agent. Readers do the subtraction; this object only holds the result.
+          #
+          # nil means "this format does not record that dimension", and it is load-
+          # bearing: absence must never read as zero, for the same reason
+          # Agent::Sessions.read raises on a format with no reader. `cost` is reported
+          # by the agent or absent — never derived from a pricing table, which would
+          # go stale in a gem and is a consumer's decision anyway.
+          Usage = Data.define(:input, :output, :cache_read, :cache_creation, :reasoning, :cost) do
+            def initialize(input: nil, output: nil, cache_read: nil, cache_creation: nil, reasoning: nil, cost: nil)
+              super
+            end
+
+            # Sums dimension-wise, keeping the nil/zero distinction: nil + nil stays
+            # nil ("neither side records this"), nil + n is n — one recorded value is
+            # a real value, not a value plus an unknown, because per-message absence
+            # under a format that does record the dimension means "none reported for
+            # this message", the one place absence and zero do coincide.
+            def +(other)
+              self.class.new(input: sum(input, other.input), output: sum(output, other.output),
+                             cache_read: sum(cache_read, other.cache_read),
+                             cache_creation: sum(cache_creation, other.cache_creation),
+                             reasoning: sum(reasoning, other.reasoning), cost: sum(cost, other.cost))
+            end
+
+            private
+
+            def sum(mine, theirs)
+              return theirs if mine.nil?
+              return mine if theirs.nil?
+
+              mine + theirs
+            end
+          end
+  end
+end

data/lib/agent/sessions/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Agent
+  module Sessions
+    VERSION = "0.3.0"
+  end
+end

data/lib/agent/sessions.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require "json"
+require "date"
+require "uri"
+require "time"
+
+require "agent_homedir"
+require "zeitwerk"
+
+module Agent
+  module Sessions
+    LOADER = Zeitwerk::Loader.for_gem_extension(Agent)
+    LOADER.inflector.inflect("cli" => "CLI")
+    LOADER.setup
+    private_constant :LOADER
+
+    STALE_AFTER_DAYS = 90
+
+    class << self
+      # Re-registering a name deliberately replaces it, so a consumer can ship a
+      # corrected adapter for an agent whose layout moved before the gem catches up.
+      def register(adapter_class)
+        name = adapter_class.agent_name
+        raise Error, "#{adapter_class.inspect} declares no agent name" if name.nil?
+
+        registry[name] = adapter_class
+      end
+
+      def registry
+        @registry ||= {}
+      end
+
+      def agents = registry.keys
+
+      def locate(agent, env: ENV)
+        adapter_for(agent).new(env: env).locate
+      end
+
+      def all(env: ENV)
+        registry.keys.map { |agent| locate(agent, env: env) }
+      end
+
+      def installed(env: ENV)
+        all(env: env).select(&:installed?)
+      end
+
+      # Lazy: consuming N sessions stats N files, never more. `since`, when given,
+      # must be a Time (or anything Time#>= accepts) — comparing updated_at (always
+      # a Time; every adapter populates it, from mtime or store metadata) against a
+      # Date, Integer, or String raises ArgumentError("comparison of Time with ...
+      # failed"), which already names the mistake, so no extra guard is added here.
+      # That raise happens on enumeration, not on this call, because the filter
+      # itself is lazy — `sessions(:x, since: bad).first(1)` can raise from inside
+      # `first`, not from this line.
+      # Raises MissingDependency or UnreadableStore for opencode under the same
+      # conditions described on for_project below.
+      def sessions(agent, env: ENV, since: nil)
+        list = adapter_for(agent).new(env: env).sessions
+        since ? list.select { |session| session.updated_at >= since } : list
+      end
+
+      # One project across every agent (or the agents: subset), lazily: adapters
+      # earlier in the sweep satisfy `first(n)` without the later ones ever being
+      # asked. Within one adapter, though, laziness cannot skip non-matching
+      # sessions — sessions_for_project must still stat and check each candidate
+      # to know it does not match, so an adapter with zero matches costs a full
+      # scan of its store before the sweep moves on. True of the six Base-driven
+      # adapters; opencode pushes the filter into SQL (WHERE directory = ?) and
+      # stats nothing.
+      #
+      # Deliberately does NOT rescue MissingDependency or UnreadableStore: opencode
+      # without the sqlite3 gem, or with a corrupt/locked database, raises. Since
+      # `flat_map` is lazy, that raise surfaces only once enumeration reaches the
+      # failing adapter — possibly after other agents' sessions have already been
+      # yielded to the caller mid-iteration, and possibly not at all if `first(n)`
+      # is satisfied first. Silently omitting an agent's sessions is this gem's
+      # worst failure mode (design doc decision 11), so this method never trades
+      # a raised, attributable error for a quietly incomplete list. A caller that
+      # wants the sweep to survive one bad agent should rescue per call, e.g. by
+      # driving `agents:` itself and catching around each adapter; a caller who
+      # just wants to route around a known-bad agent can pass `agents:` naming
+      # every registered agent except it. The CLI (Task 10) does the former,
+      # turning the same exceptions into per-agent "skipped" lines instead of one
+      # failed sweep. Note a rescue cannot resume this enumerator: re-calling each
+      # after a raise re-raises from the same adapter. The only recovery is a
+      # fresh call with a narrower `agents:`.
+      # Adapters are resolved eagerly, so an unknown name in `agents:` raises here
+      # rather than mid-sweep. The deferral above is about DATA conditions, where
+      # the raise carries information about a store; a typo'd agent symbol is a
+      # programmer error knowable before any I/O, and `agents: [:claude, :nope]`
+      # otherwise hands back Claude's sessions and then crashes. Base#initialize
+      # only stores @env, so constructing all seven up front costs nothing, and
+      # the sweep stays lazy — first(n) still stops at the first matching adapter.
+      def for_project(dir, env: ENV, agents: nil)
+        dir = File.expand_path(dir)
+        adapters = (agents || registry.keys).map { |name| adapter_for(name).new(env: env) }
+        adapters.lazy.flat_map { |adapter| adapter.sessions_for_project(dir) }
+      end
+
+      # Eager, unlike sessions/for_project: project_paths already reads every
+      # session to answer (design doc section 7 — the on-disk encodings are lossy,
+      # so the recorded cwd is the only reliable source), sorts, and dedupes, so a
+      # lazy return type here would promise a laziness the work underneath cannot
+      # honor. Returns a plain, already-sorted Array.
+      # Raises MissingDependency or UnreadableStore for opencode, as sessions does.
+      def projects(agent, env: ENV)
+        adapter_for(agent).new(env: env).project_paths
+      end
+
+      # Companion to `projects`/`project_paths`, which both exclude a session
+      # whose project could not be resolved rather than counting it (design doc
+      # section 7) — so "this agent genuinely records no projects" and "this
+      # agent's project resolution is broken" read identically from the
+      # outside. Three of seven adapters can legitimately return a nil
+      # project_path (Amp threads with no `trees`, cursor_ide by design, pi
+      # whenever its unverified header assumption is wrong); this counts it for
+      # any of them, uniformly, using only the public `sessions` enumerator —
+      # no adapter needs to know this exists. Eager and a second full sweep of
+      # the store, same cost class as `projects` itself, so it is opt-in
+      # (called by the CLI only under `list --project`, never under plain
+      # `list`) rather than folded into `projects`' own return value, which is
+      # a documented, tested plain Array and would otherwise need a shape
+      # change to carry both numbers.
+      # Raises MissingDependency or UnreadableStore for opencode, as sessions does.
+      def unresolved_project_count(agent, env: ENV)
+        adapter_for(agent).new(env: env).sessions.count { |session| session.project_path.nil? }
+      end
+
+      # Layer 3. Takes a Session (from `sessions`, `for_project`), not an agent
+      # name, because reading is per-session — the adapter comes from the session
+      # itself. Raises UnsupportedFormat for an agent with no reader yet, rather
+      # than returning a reader that yields nothing: "this gem cannot read that
+      # format" and "that session has no messages" must never look alike.
+      #
+      # include_events: true adds the agent's UI-level records to the stream where
+      # an adapter has them. They are excluded by default because they are
+      # bookkeeping, not conversation, and they outnumber real messages.
+      def read(session, **options)
+        klass = adapter_for(session.agent).reader_class
+        unless klass
+          raise UnsupportedFormat,
+                "no reader for #{session.agent} yet; Session#fidelity says #{session.fidelity}"
+        end
+
+        klass.new(session, **options)
+      end
+
+      def verify(agent = nil, env: ENV)
+        targets = agent ? [adapter_for(agent)] : registry.values
+        targets.flat_map { |klass| klass.new(env: env).verify }
+      end
+
+      def doctor(agent = nil, env: ENV, today: Date.today)
+        targets = agent ? [adapter_for(agent)] : registry.values
+        staleness = targets.map do |klass|
+          age = (today - klass.verified_on_date).to_i
+          if age > STALE_AFTER_DAYS
+            Check.new(agent: klass.agent_name, status: :drift, claim: "verified within #{STALE_AFTER_DAYS} days",
+                      detail: "last verified #{klass.verified_on_date} (#{age} days ago)")
+          else
+            Check.new(agent: klass.agent_name, status: :pass, claim: "verified within #{STALE_AFTER_DAYS} days",
+                      detail: "last verified #{klass.verified_on_date}")
+          end
+        end
+        verify(agent, env: env) + staleness
+      end
+
+      def audit(env: ENV)
+        Audit.new(all(env: env), env: env).report
+      end
+
+      private
+
+      def adapter_for(agent)
+        registry.fetch(agent) do
+          raise UnknownAgent, "unknown agent: #{agent.inspect} (known: #{registry.keys.join(", ")})"
+        end
+      end
+    end
+
+    register(Adapters::Claude)
+    register(Adapters::Codex)
+    register(Adapters::Pi)
+    register(Adapters::Amp)
+    register(Adapters::Opencode)
+    register(Adapters::Cursor)
+    register(Adapters::CursorIde)
+    register(Adapters::Gemini)
+    register(Adapters::Qwen)
+    register(Adapters::Copilot)
+    register(Adapters::Grok)
+
+    # The oldest verified_on among the built-in adapters. A claim about somebody
+    # else's software is only as current as its weakest link, so this is the honest
+    # answer to "when was this last known to be true".
+    VERIFIED_ON = registry.values.map(&:verified_on_date).min
+  end
+end

data/lib/agent_sessions.rb

@@ -0,0 +1 @@
+require_relative "agent/sessions"

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: agent_sessions
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Lucian Ghinda
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: agent_homedir
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+description: Supports 11 adapters for Claude Code, Codex CLI, Cursor CLI/IDE, Amp,
+  opencode, pi, Gemini CLI, GitHub Copilot CLI, Qwen Code, and Grok Build; reads messages
+  for nine agents, verifies store paths, maps sessions to projects, and audits sync
+  exposure.
+email:
+- dev@ghinda.com
+executables:
+- agent-sessions
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- exe/agent-sessions
+- lib/agent/sessions.rb
+- lib/agent/sessions/adapters/amp.rb
+- lib/agent/sessions/adapters/base.rb
+- lib/agent/sessions/adapters/claude.rb
+- lib/agent/sessions/adapters/codex.rb
+- lib/agent/sessions/adapters/copilot.rb
+- lib/agent/sessions/adapters/cursor.rb
+- lib/agent/sessions/adapters/cursor_ide.rb
+- lib/agent/sessions/adapters/enumeration.rb
+- lib/agent/sessions/adapters/gemini.rb
+- lib/agent/sessions/adapters/grok.rb
+- lib/agent/sessions/adapters/opencode.rb
+- lib/agent/sessions/adapters/pi.rb
+- lib/agent/sessions/adapters/qwen.rb
+- lib/agent/sessions/audit.rb
+- lib/agent/sessions/check.rb
+- lib/agent/sessions/cli.rb
+- lib/agent/sessions/compaction.rb
+- lib/agent/sessions/env_override.rb
+- lib/agent/sessions/error.rb
+- lib/agent/sessions/home_expansion.rb
+- lib/agent/sessions/location.rb
+- lib/agent/sessions/message.rb
+- lib/agent/sessions/missing_dependency.rb
+- lib/agent/sessions/node.rb
+- lib/agent/sessions/part.rb
+- lib/agent/sessions/readers/amp.rb
+- lib/agent/sessions/readers/base.rb
+- lib/agent/sessions/readers/claude.rb
+- lib/agent/sessions/readers/codex.rb
+- lib/agent/sessions/readers/copilot.rb
+- lib/agent/sessions/readers/gemini.rb
+- lib/agent/sessions/readers/grok.rb
+- lib/agent/sessions/readers/opencode.rb
+- lib/agent/sessions/readers/pi.rb
+- lib/agent/sessions/readers/qwen.rb
+- lib/agent/sessions/session.rb
+- lib/agent/sessions/sqlite.rb
+- lib/agent/sessions/store.rb
+- lib/agent/sessions/unknown_agent.rb
+- lib/agent/sessions/unreadable_store.rb
+- lib/agent/sessions/unsupported_format.rb
+- lib/agent/sessions/usage.rb
+- lib/agent/sessions/version.rb
+- lib/agent_sessions.rb
+homepage: https://github.com/lucianghinda/agent_sessions
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/lucianghinda/agent_sessions
+  changelog_uri: https://github.com/lucianghinda/agent_sessions/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.11
+specification_version: 4
+summary: Locate, verify, and read AI coding agent session logs
+test_files: []