samagotchi 0.2.0

data/lib/samagotchi/context_note.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Samagotchi
+  # A context note: background text pushed into a session from outside (the
+  # user's `chi note`, or another session's send_note). It is kept in the
+  # conversation as a tail system message marked kind: "note", framed so the
+  # model reads it as information, not as a request.
+  module ContextNote
+    KIND = "note"
+    # The message keys a note carries besides role and content; everything
+    # that copies messages field by field must keep them.
+    KEYS = %i[kind note_id source from_session from_cwd].freeze
+
+    module_function
+
+    # Takes SessionManager.read_note's keys.
+    # @return [Hash] the conversation message
+    def message(note_id:, text:, source:, created_at: nil, from_session: nil, from_cwd: nil, **)
+      { role: "system", kind: KIND, note_id: note_id, source: source, from_session: from_session,
+        from_cwd: from_cwd, content: frame(text, source: source, created_at: created_at,
+                                                 from_session: from_session, from_cwd: from_cwd) }.compact
+    end
+
+    def frame(text, source:, created_at: nil, from_session: nil, from_cwd: nil)
+      time = clock(created_at)
+      from = label(source: source, from_session: from_session, from_cwd: from_cwd)
+      "[CONTEXT NOTE from #{from}#{", #{time}" if time}]\n#{text}\n[END NOTE]"
+    end
+
+    # Who sent a note: its source, or the sending session and its folder.
+    def label(source:, from_session: nil, from_cwd: nil)
+      return source.to_s unless from_session
+
+      "session #{from_session.to_s[0, 6]}#{" (#{home_relative(from_cwd)})" if from_cwd}"
+    end
+
+    def label_of(message)
+      label(source: fetch(message, :source), from_session: fetch(message, :from_session), from_cwd: fetch(message, :from_cwd))
+    end
+
+    # The note's own text, without its frame.
+    def text_of(message)
+      fetch(message, :content).to_s.sub(/\A\[CONTEXT NOTE[^\n]*\n/, "").sub(/\n\[END NOTE\]\z/, "")
+    end
+
+    def fetch(message, key)
+      message.key?(key) ? message[key] : message[key.to_s]
+    end
+
+    def note?(message)
+      fetch(message, :kind).to_s == KIND
+    end
+
+    # The conversation with +system_message+ at its head: an old system
+    # prompt there (a system message of no kind) is replaced, anything else
+    # (a note that arrived before the first turn, a turn note left by a
+    # failed first turn) stays and the prompt goes before it.
+    def with_system_head(messages, system_message)
+      first = messages.first
+      replace = first && fetch(first, :role).to_s == "system" && fetch(first, :kind).to_s.empty?
+      [system_message] + (replace ? messages.drop(1) : messages)
+    end
+
+    def clock(created_at)
+      created_at && Time.iso8601(created_at.to_s).localtime.strftime("%H:%M")
+    rescue ArgumentError
+      nil
+    end
+
+    def home_relative(path)
+      home = Dir.home
+      path.to_s.start_with?("#{home}/") || path.to_s == home ? path.to_s.sub(home, "~") : path.to_s
+    end
+  end
+end

data/lib/samagotchi/context_quote.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # Context shown to the model as a quote above the user's own words, the
+  # shape the web annotations use (annotations.js quoteBlock), minus their
+  # source label: `pbpaste | chi send -m "same bug?" ID`.
+  module ContextQuote
+    # @param text [String, nil]
+    # @return [String, nil] each line as "> line" ("> " dropped for an empty
+    #   one), ending in a blank line so the message follows as is; nil when
+    #   the text is blank
+    def self.block(text)
+      lines = text.to_s.gsub(/\r\n?/, "\n").split("\n", -1).map { |line| line.sub(/[[:space:]]+\z/, "") }
+      lines.shift while lines.first&.empty?
+      lines.pop while lines.last&.empty?
+      return nil if lines.empty?
+
+      "#{lines.map { |line| line.empty? ? ">" : "> #{line}" }.join("\n")}\n\n"
+    end
+  end
+end

data/lib/samagotchi/context_usage.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "token_usage"
+
+module Samagotchi
+  # Normalizes raw model-server stream payloads into a uniform context-usage
+  # snapshot. Shared by the kernel loop (to inform the model of real token
+  # usage) and the terminal UI (to render the status line) so both agree on
+  # token accounting instead of duplicating the parsing logic.
+  module ContextUsage
+    module_function
+
+    # Numbers read like TokenUsage's: integers, floats and numeric strings,
+    # decimal ("010" is 10).
+    def first_positive_integer(*values)
+      TokenUsage.first_positive(*values)
+    end
+
+    # `window_tokens` is the caller's resolved context window; a window the
+    # payload reports itself (n_ctx / context_window) wins over it. Without
+    # either, context_window_tokens and ctx_pct stay nil: the parser does not
+    # invent a default.
+    def normalize(payload, window_tokens: nil)
+      payload_hash = payload.is_a?(Hash) ? payload : {}
+      usage = payload_hash["usage"] || payload_hash[:usage]
+      usage = {} unless usage.is_a?(Hash)
+
+      # The token counts come from the same parser SessionMetrics uses.
+      counts = TokenUsage.from_payload(payload_hash) || {}
+      prompt_tokens = counts[:prompt_tokens]
+      completion_tokens = counts[:completion_tokens]
+
+      total_tokens = first_positive_integer(
+        usage["total_tokens"], usage[:total_tokens],
+        payload_hash["total_tokens"], payload_hash[:total_tokens],
+        payload_hash["n_past"], payload_hash[:n_past]
+      )
+      total_tokens ||= prompt_tokens.to_i + completion_tokens.to_i if prompt_tokens || completion_tokens
+
+      context_window_tokens = first_positive_integer(
+        payload_hash["n_ctx"], payload_hash[:n_ctx],
+        payload_hash["context_window"], payload_hash[:context_window],
+        window_tokens
+      )
+
+      context_used_tokens = first_positive_integer(
+        payload_hash["n_past"], payload_hash[:n_past],
+        total_tokens
+      )
+
+      ctx_pct = if context_window_tokens && context_used_tokens
+                  (context_used_tokens.to_f / context_window_tokens) * 100.0
+                end
+
+      return nil unless prompt_tokens || completion_tokens || total_tokens || ctx_pct
+
+      {
+        prompt_tokens: prompt_tokens,
+        completion_tokens: completion_tokens,
+        total_tokens: total_tokens,
+        context_window_tokens: context_window_tokens,
+        ctx_pct: ctx_pct
+      }
+    end
+  end
+end

data/lib/samagotchi/context_window.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "config"
+
+module Samagotchi
+  # The model's context window in tokens, and where that number came from.
+  #
+  # Lookup order:
+  #   1. the running server (Client#context_window, e.g. llama.cpp's n_ctx)
+  #   2. the host's model list (a chat adapter's #context_window, e.g. a
+  #      provider's context_length)
+  #   3. context.window_tokens (CLI, SAMAGOTCHI_CONTEXT_WINDOW_TOKENS or the
+  #      config file); it only fills in when the server reports nothing
+  #   4. DEFAULT_TOKENS
+  #
+  # Sources: :server, :model_list, :config (CLI or file), :env, :default.
+  module ContextWindow
+    DEFAULT_TOKENS = 256_000
+
+    Resolved = Struct.new(:tokens, :source, keyword_init: true)
+
+    module_function
+
+    # @param adapter [#context_window, nil] the host's chat adapter
+    def resolve(client: nil, model: nil, adapter: nil)
+      server_tokens = client.context_window(model: model) if client.respond_to?(:context_window)
+      if positive_integer?(server_tokens)
+        @last_server = Resolved.new(tokens: server_tokens, source: :server)
+        return @last_server
+      end
+
+      listed = adapter.context_window(model: model) if adapter.respond_to?(:context_window)
+      if positive_integer?(listed)
+        @last_server = Resolved.new(tokens: listed, source: :model_list)
+        return @last_server
+      end
+
+      configured
+    end
+
+    # The window without asking a server: config, env, then the default.
+    # `env` resolves against that env's config file instead of the live
+    # process config (for `chi self`).
+    def configured(env: nil)
+      value, origin = begin
+        if env
+          file_data = ConfigFile.read_yaml(path: ConfigFile.global_path(env: env))
+          Config.resolve_with_origin("context.window_tokens", file_data: file_data, env: env)
+        else
+          Config.get_with_origin("context.window_tokens")
+        end
+      rescue StandardError
+        [nil, :default]
+      end
+      return Resolved.new(tokens: DEFAULT_TOKENS, source: :default) unless positive_integer?(value)
+
+      Resolved.new(tokens: value, source: origin == :env ? :env : :config)
+    end
+
+    # For callers with no client at hand (tool output guardrails): the last
+    # window a server reported in this process, else #configured. With
+    # several hosts in one process this can be another host's window, which
+    # is good enough for a size heuristic.
+    def current
+      @last_server || configured
+    end
+
+    def reset!
+      @last_server = nil
+    end
+
+    def positive_integer?(value)
+      value.is_a?(Integer) && value.positive?
+    end
+  end
+end

data/lib/samagotchi/debug_log.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Samagotchi
+  # The debug log file (Log's writer). One #write per record, so records
+  # from concurrent processes appending to the same file (O_APPEND) don't
+  # interleave. Failures never break the caller: an IO error (a full disk,
+  # a lost permission) pauses writing for RETRY_SECONDS, then it tries again.
+  #
+  # Rotation: a file over MAX_BYTES becomes <file>.1 (one kept), whichever
+  # process notices first. It takes <file>.lock without waiting (busy: the
+  # next write checks again) and looks again under it, so two processes
+  # never both rotate. Every write stats the path: a writer whose file was
+  # rotated away (another inode) reopens the new one.
+  class DebugLog
+    RETRY_SECONDS = 60
+    MAX_BYTES = 5 * 1024 * 1024
+
+    attr_reader :path
+
+    def initialize(path:, clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }, max_bytes: MAX_BYTES)
+      @path = path.nil? || path.to_s.strip.empty? ? nil : path.to_s
+      @clock = clock
+      @max_bytes = max_bytes
+      @io = nil
+      @ino = nil
+      @paused_until = nil
+      @mutex = Mutex.new
+    end
+
+    def enabled?
+      !@path.nil?
+    end
+
+    # @param record [String] one formatted record, newline-terminated
+    # @return [Boolean] whether it was written
+    def write(record)
+      return false unless @path
+
+      @mutex.synchronize do
+        return false if @paused_until && @clock.call < @paused_until
+
+        @paused_until = nil
+        begin
+          ensure_io
+          follow_rotation
+          ensure_io.write(record)
+          true
+        rescue StandardError
+          pause
+          false
+        end
+      end
+    end
+
+    def close
+      @mutex.synchronize { close_io }
+    end
+
+    private
+
+    def ensure_io
+      return @io if @io
+
+      dir = File.dirname(@path)
+      FileUtils.mkdir_p(dir) unless dir.empty?
+      @io = File.open(@path, File::WRONLY | File::APPEND | File::CREAT)
+      @io.sync = true
+      @ino = @io.stat.ino
+      @io
+    end
+
+    # Reopen when the path is another file now (rotated by someone else, or
+    # deleted); rotate when it grew over the cap. Regular files only: a
+    # FIFO or /dev/stderr is left alone.
+    def follow_rotation
+      stat = File.stat(@path)
+      return close_io unless stat.ino == @ino
+      return unless stat.file? && stat.size >= @max_bytes
+
+      rotate
+    rescue Errno::ENOENT
+      close_io
+    end
+
+    def rotate
+      File.open("#{@path}.lock", File::RDWR | File::CREAT, 0o600) do |lock|
+        return unless lock.flock(File::LOCK_EX | File::LOCK_NB)
+
+        stat = File.stat(@path)
+        File.rename(@path, "#{@path}.1") if stat.ino == @ino && stat.size >= @max_bytes
+        close_io
+      end
+    end
+
+    def pause
+      @paused_until = @clock.call + RETRY_SECONDS
+      close_io
+    end
+
+    def close_io
+      @io&.close
+    rescue StandardError
+      nil
+    ensure
+      @io = nil
+    end
+  end
+end

data/lib/samagotchi/desktop/macos/App.swift

@@ -0,0 +1,102 @@
+// Chi Helper: the "Send to chi" Service opens the panel with the selection,
+// the hotkey with the clipboard. No Dock icon (LSUIElement); it stays
+// running after the first launch. `ChiHelper --login on|off|status` (run
+// directly by chi desktop) manages the login item and exits.
+import AppKit
+import ServiceManagement
+
+final class ServiceProvider: NSObject {
+  weak var app: AppDelegate?
+
+  // Info.plist NSServices: NSMessage = sendToChi.
+  @objc func sendToChi(_ pboard: NSPasteboard, userData: String?, error: AutoreleasingUnsafeMutablePointer<NSString>) {
+    guard let text = pboard.string(forType: .string) else {
+      error.pointee = "No text in the selection" as NSString
+      return
+    }
+    app?.open(text: text)
+  }
+}
+
+final class AppDelegate: NSObject, NSApplicationDelegate {
+  let panel = PanelController()
+  let provider = ServiceProvider()
+  private var hotkey: Hotkey?
+  /// A Service activates this app before the handler runs, so the app the
+  /// text came from is the last other app that was frontmost.
+  private var lastOtherApp: NSRunningApplication?
+
+  func applicationDidFinishLaunching(_ notification: Notification) {
+    provider.app = self
+    NSApp.servicesProvider = provider
+    NSUpdateDynamicServices()
+    hotkey = Hotkey { [weak self] in self?.openFromClipboard() }
+    hotkey?.register()
+
+    lastOtherApp = otherApp(NSWorkspace.shared.frontmostApplication)
+    NSWorkspace.shared.notificationCenter.addObserver(
+      forName: NSWorkspace.didActivateApplicationNotification, object: nil, queue: .main
+    ) { [weak self] note in
+      if let app = self?.otherApp(note.userInfo?[NSWorkspace.applicationUserInfoKey] as? NSRunningApplication) {
+        self?.lastOtherApp = app
+      }
+    }
+  }
+
+  private func otherApp(_ app: NSRunningApplication?) -> NSRunningApplication? {
+    app?.processIdentifier == getpid() ? nil : app
+  }
+
+  /// The app the text comes from: frontmost unless that is us.
+  var sourceApp: NSRunningApplication? {
+    otherApp(NSWorkspace.shared.frontmostApplication) ?? lastOtherApp
+  }
+
+  /// The hotkey doesn't activate us, so the frontmost app is the source.
+  func openFromClipboard() {
+    open(text: NSPasteboard.general.string(forType: .string) ?? "")
+  }
+
+  func open(text: String) {
+    let from = sourceApp
+    panel.show(text: text, source: from?.localizedName?.lowercased() ?? "desktop", returnTo: from)
+  }
+}
+
+/// SMAppService only lets an app register itself, so chi desktop runs the
+/// binary with --login. Prints the status name; exit 1 on failure.
+func loginCommand(_ arg: String) -> Int32 {
+  let service = SMAppService.mainApp
+  do {
+    switch arg {
+    case "on": if service.status != .enabled { try service.register() }
+    case "off": if service.status == .enabled || service.status == .requiresApproval { try service.unregister() }
+    case "status": break
+    default:
+      FileHandle.standardError.write("usage: ChiHelper --login on|off|status\n".data(using: .utf8)!)
+      return 2
+    }
+  } catch {
+    FileHandle.standardError.write("\(error.localizedDescription)\n".data(using: .utf8)!)
+    return 1
+  }
+  let names: [SMAppService.Status: String] = [.notRegistered: "notRegistered", .enabled: "enabled",
+                                              .requiresApproval: "requiresApproval", .notFound: "notFound"]
+  print(names[service.status] ?? "unknown")
+  return 0
+}
+
+@main
+struct ChiHelperMain {
+  static func main() {
+    let args = CommandLine.arguments
+    if args.count >= 2, args[1] == "--login" {
+      exit(loginCommand(args.count >= 3 ? args[2] : ""))
+    }
+    let app = NSApplication.shared
+    let delegate = AppDelegate()
+    app.delegate = delegate
+    app.setActivationPolicy(.accessory)
+    app.run()
+  }
+}

data/lib/samagotchi/desktop/macos/ChiRunner.swift

@@ -0,0 +1,201 @@
+// Runs chi the way `chi desktop install` wrote down in launch.json: an
+// absolute ruby + bin/chi and a few env vars, since an app started by
+// launchd has none of the shell's setup. Talks to chi only through its CLI.
+import Foundation
+
+struct LaunchConfig: Decodable {
+  let version: String?
+  let argv: [String]
+  let env: [String: String]?
+}
+
+struct ChiResult {
+  let status: Int32
+  let stdout: String
+  let stderr: String
+  let timedOut: Bool
+}
+
+enum ChiError: Error, CustomStringConvertible {
+  case noLaunchFile(String)
+  case missing(String)
+  case failed(String)
+
+  var description: String {
+    switch self {
+    case .noLaunchFile(let path): return "No launch file at \(path). Run `chi desktop upgrade` in a terminal."
+    case .missing(let path): return "chi not found at \(path). Run `chi desktop upgrade` in a terminal."
+    case .failed(let message): return message
+    }
+  }
+}
+
+/// One session from `chi sessions list --format json`: a live one, or a
+/// recent stopped one (listed below the live ones; a message wakes it).
+struct LiveSession: Decodable, Identifiable, Equatable {
+  let id: String
+  let desc: String?
+  let cwd: String?
+  let busy: Bool?
+  let owner: String?
+  let updatedAt: String?
+  var recent = false
+
+  enum CodingKeys: String, CodingKey {
+    case id, desc, cwd, busy, owner
+    case updatedAt = "updated_at"
+  }
+
+  /// Only UUID-shaped ids go into chi's argv, so nothing can turn into a flag.
+  var valid: Bool { UUID(uuidString: id) != nil }
+
+  var shortCwd: String {
+    guard let cwd else { return "" }
+    let home = NSHomeDirectory()
+    return cwd.hasPrefix(home) ? "~" + cwd.dropFirst(home.count) : cwd
+  }
+
+  /// "just now", "5m ago", "2h ago", "yesterday", "3d ago", or "".
+  func age(now: Date = Date()) -> String {
+    guard let updatedAt else { return "" }
+    let precise = ISO8601DateFormatter()
+    precise.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+    guard let date = precise.date(from: updatedAt) ?? ISO8601DateFormatter().date(from: updatedAt) else { return "" }
+    let seconds = max(0, now.timeIntervalSince(date))
+    switch seconds {
+    case ..<60: return "just now"
+    case ..<3600: return "\(Int(seconds / 60))m ago"
+    case ..<86_400: return "\(Int(seconds / 3600))h ago"
+    case ..<172_800: return "yesterday"
+    default: return "\(Int(seconds / 86_400))d ago"
+    }
+  }
+}
+
+final class ChiRunner {
+  static let supportDir = NSString(string: "~/Library/Application Support/Chi Helper").expandingTildeInPath
+  static let launchPath = supportDir + "/launch.json"
+
+  let timeout: TimeInterval
+
+  init(timeout: TimeInterval = 10) {
+    self.timeout = timeout
+  }
+
+  func loadLaunch() throws -> LaunchConfig {
+    guard let data = FileManager.default.contents(atPath: Self.launchPath) else {
+      throw ChiError.noLaunchFile(Self.launchPath)
+    }
+    let config: LaunchConfig
+    do { config = try JSONDecoder().decode(LaunchConfig.self, from: data) } catch {
+      throw ChiError.failed("Unreadable launch file \(Self.launchPath): \(error.localizedDescription)")
+    }
+    guard !config.argv.isEmpty else { throw ChiError.failed("Empty argv in \(Self.launchPath)") }
+    for path in config.argv where path.hasPrefix("/") && !FileManager.default.fileExists(atPath: path) {
+      throw ChiError.missing(path)
+    }
+    return config
+  }
+
+  /// Runs `chi <args>`, with stdin written from a background queue and
+  /// stdout/stderr drained as they come (no pipe deadlock near the 16 KiB
+  /// note cap). Calls back on the main queue.
+  func run(_ args: [String], stdin: Data? = nil, completion: @escaping (Result<ChiResult, ChiError>) -> Void) {
+    let config: LaunchConfig
+    do { config = try loadLaunch() } catch let error as ChiError {
+      completion(.failure(error)); return
+    } catch {
+      completion(.failure(.failed("\(error)"))); return
+    }
+
+    let process = Process()
+    process.executableURL = URL(fileURLWithPath: config.argv[0])
+    process.arguments = Array(config.argv.dropFirst()) + args
+    process.environment = ProcessInfo.processInfo.environment.merging(config.env ?? [:]) { _, baked in baked }
+    process.currentDirectoryURL = URL(fileURLWithPath: NSHomeDirectory())
+    let out = Pipe(), err = Pipe(), input = Pipe()
+    process.standardOutput = out
+    process.standardError = err
+    process.standardInput = stdin == nil ? FileHandle.nullDevice : input
+
+    let lock = NSLock()
+    var outData = Data(), errData = Data()
+    out.fileHandleForReading.readabilityHandler = { handle in
+      let chunk = handle.availableData
+      lock.lock(); outData.append(chunk); lock.unlock()
+    }
+    err.fileHandleForReading.readabilityHandler = { handle in
+      let chunk = handle.availableData
+      lock.lock(); errData.append(chunk); lock.unlock()
+    }
+
+    var timedOut = false
+    process.terminationHandler = { proc in
+      out.fileHandleForReading.readabilityHandler = nil
+      err.fileHandleForReading.readabilityHandler = nil
+      let restOut = out.fileHandleForReading.readDataToEndOfFile()
+      let restErr = err.fileHandleForReading.readDataToEndOfFile()
+      lock.lock()
+      outData.append(restOut); errData.append(restErr)
+      let result = ChiResult(status: proc.terminationStatus,
+                             stdout: String(decoding: outData, as: UTF8.self),
+                             stderr: String(decoding: errData, as: UTF8.self),
+                             timedOut: timedOut)
+      lock.unlock()
+      DispatchQueue.main.async { completion(.success(result)) }
+    }
+
+    do { try process.run() } catch {
+      completion(.failure(.failed("Could not start \(config.argv[0]): \(error.localizedDescription)")))
+      return
+    }
+    if let stdin {
+      DispatchQueue.global().async {
+        try? input.fileHandleForWriting.write(contentsOf: stdin)
+        try? input.fileHandleForWriting.close()
+      }
+    }
+    DispatchQueue.global().asyncAfter(deadline: .now() + timeout) {
+      if process.isRunning {
+        lock.lock(); timedOut = true; lock.unlock()
+        process.terminate()
+      }
+    }
+  }
+
+  /// The live sessions, then up to +recentCount+ stopped ones, newest
+  /// first. A session a chi REPL holds is in neither: it takes no notes or
+  /// messages. A failed second call just leaves "recent" empty.
+  func sessions(recentCount: Int = 3, completion: @escaping (Result<[LiveSession], ChiError>) -> Void) {
+    list(["--live"]) { result in
+      guard case .success(let live) = result else { completion(result); return }
+      self.list(["--limit", "20"]) { recent in
+        let liveIds = Set(live.map(\.id))
+        let stopped = ((try? recent.get()) ?? [])
+          .filter { $0.owner == nil && !liveIds.contains($0.id) }
+          .prefix(recentCount)
+          .map { session -> LiveSession in var session = session; session.recent = true; return session }
+        completion(.success(live + stopped))
+      }
+    }
+  }
+
+  private func list(_ flags: [String], completion: @escaping (Result<[LiveSession], ChiError>) -> Void) {
+    // Every project's sessions: the helper isn't in any one project (an
+    // older chi ignores the flag).
+    run(["sessions", "list"] + flags + ["--scope=all", "--format", "json"]) { result in
+      switch result {
+      case .failure(let error): completion(.failure(error))
+      case .success(let r):
+        if r.timedOut { completion(.failure(.failed("chi sessions list took over \(Int(self.timeout)) s"))); return }
+        guard r.status == 0, let data = r.stdout.data(using: .utf8),
+              let sessions = try? JSONDecoder().decode([LiveSession].self, from: data) else {
+          let detail = r.stderr.isEmpty ? r.stdout : r.stderr
+          completion(.failure(.failed("chi sessions list failed (exit \(r.status)): \(detail.prefix(400))")))
+          return
+        }
+        completion(.success(sessions.filter(\.valid)))
+      }
+    }
+  }
+}