diffbroker 0.9.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e54b099af52044a49465285a6e1c6433be4fbac0c9e2b76dade0717b42bb5cb
-  data.tar.gz: c27ba555b4cf84832fac018fabb0a32acbc13a2778a98f526db61304abd8f11f
+  metadata.gz: 5edf0d3084adb3e7b1e8a9f55dda5062efa3a5207d8f4ca7d7860141acef3ec7
+  data.tar.gz: 85899028c0a4d827e3df60c530298f9713e4a33e4ccf5ec4397fae0d58a6c37a
 SHA512:
-  metadata.gz: 71929768b4b9c14a10e969ab4ace0687849082ce27816f4e78a04593d3f177fe3f286ad007e800a7f22bd57f6798b244ba43559ccca864ffde00f89c6e9764f5
-  data.tar.gz: 437c9ee4dd4b481ede08fc5c080c60bdb366741d33f89da9ae2af4285ae7c8875c9dde3776683612c003dce2eb8eb7b01828a679cbcf8d82f2d1cd07d61d72da
+  metadata.gz: 7b7ca4efd11472c69863a386ebf10336402eac96f998a8665457f20a7f6b395af3a3814925915e1881d0f018c906344a0eccd45cdd0d9557fc4f44fc0a3891be
+  data.tar.gz: d763d542d2a6c27adad2bf78cf3b6f0bb1488b0f384bb90fef6990b27c142af472078409f5886be43c92fe6df7b158e847547720018f28ce0efe57ab7060b4dc

data/lib/diffbroker/agents/base.rb

@@ -16,6 +16,9 @@ module Diffbroker
       # The run's lines for the user's log: what the model said and the tools it called. Subclasses override.
       def parse_log(_line) = []
 
+      # Whether a chat message can continue this agent's earlier session (task["resume_session_id"]).
+      def resumes? = false
+
       def env(token, task_id) = { TOKEN_ENV => token, "DIFFBROKER_TASK_ID" => task_id }
 
       private

data/lib/diffbroker/agents/claude.rb

@@ -27,12 +27,17 @@ module Diffbroker
 
       def name = "claude_code"
 
+      def resumes? = true
+
       def autonomous_command(task, mcp_config:)
         args = task["read_only"] ? READ_ONLY_ARGS : @config.claude_args
-        [ @config.claude_command, "-p", task.fetch("prompt"), "--output-format", "stream-json", "--verbose", *args,
+        [ @config.claude_command, "-p", task.fetch("prompt"), *resume(task), "--output-format", "stream-json", "--verbose", *args,
           "--mcp-config", mcp_config, *strict(task), "--plugin-dir", @plugin_dir ]
       end
 
+      # The permissions above are passed again: a resumed session keeps its conversation, not its sandbox.
+      def resume(task) = task["resume_session_id"] ? [ "--resume", task["resume_session_id"] ] : []
+
       def terminal_command(task, mcp_config:)
         [ @config.claude_command, "--mcp-config", mcp_config, *strict(task), "--plugin-dir", @plugin_dir ]
       end

data/lib/diffbroker/daemon.rb

@@ -11,6 +11,7 @@ module Diffbroker
     class Rejected < Error; end
 
     RESCAN_EVERY = 300
+    USAGE_EVERY = 300
     MAX_BACKOFF = 60
     BATCH = 50
     # Spec §5.2 / main §18.4: nothing else about an observed agent ever leaves the machine.
@@ -26,6 +27,7 @@ module Diffbroker
       new(scanner: config.repo_scanner, roots_changed: roots_changed(config), device_roots: config.device_roots, ignored_roots: config.ignored_roots,
           client_factory: -> { CableClient.new(url: config.cable_url, token: config.device_token, origin: config.server) },
           task_runner_factory: ->(report) { TaskRunner.new(config:, report:, out:) }, out:, relay:, process_scanner:, agent: config.agent,
+          plan_usage: PlanUsage.new(agent: config.agent),
           lifecycle: Lifecycle.new(dir: config.dir, server: config.server), reaper: Reaper.new(root: config.worktree_root))
     end
 
@@ -54,7 +56,7 @@ module Diffbroker
 
     def initialize(scanner:, client_factory:, task_runner_factory:, out: $stdout, sleeper: ->(seconds) { sleep(seconds) },
                    clock: -> { Time.now }, spawner: ->(&block) { Thread.new(&block) }, relay: nil, process_scanner: nil, lifecycle: nil,
-                   maintenance: Maintenance.new, roots_changed: nil, device_roots: [], ignored_roots: [], agent: "claude", reaper: nil)
+                   maintenance: Maintenance.new, roots_changed: nil, device_roots: [], ignored_roots: [], agent: "claude", reaper: nil, plan_usage: nil)
       @scanner = scanner
       @device_roots = device_roots
       @ignored_roots = ignored_roots
@@ -71,6 +73,7 @@ module Diffbroker
       @maintenance = maintenance
       @agent = agent
       @reaper = reaper
+      @plan_usage = plan_usage
       @repositories = []
       @running = Set.new
       @running_lock = Mutex.new
@@ -123,6 +126,7 @@ module Diffbroker
         @backoff = 1
         @rejections = 0
         rescan(client)
+        @usage_at = nil
         client.perform("hello", "version" => VERSION, "platform" => Diffbroker.platform,
                                 "service" => @lifecycle ? @lifecycle.service_installed? : false, "agent" => @agent)
         @out.puts "Connected. #{@repositories.size} repositories reported."
@@ -131,6 +135,7 @@ module Diffbroker
         client.perform("heartbeat", "version" => VERSION)
         rescan(client) if @scanned_at.nil? || @clock.call - @scanned_at >= RESCAN_EVERY
         observe(client, @process_scanner.scan) if @process_scanner
+        report_usage(client)
       end
       client.on_poll { observe(client, @relay.drain) if @relay }
       client.on_message { |message| handle(client, message) }
@@ -143,6 +148,18 @@ module Diffbroker
       client.perform("repositories", "repositories" => @repositories)
     end
 
+    # The plan limits change slowly and reading them can wait on the network, so: every few minutes, off the tick's thread.
+    def report_usage(client)
+      return unless @plan_usage
+      return if @usage_at && @clock.call - @usage_at < USAGE_EVERY
+
+      @usage_at = @clock.call
+      @spawner.call do
+        usage = @plan_usage.read
+        client.perform("usage", usage) if usage
+      end
+    end
+
     def observe(client, events)
       clean = Array(events).filter_map { _1.is_a?(Hash) ? _1.slice(*OBSERVATION_FIELDS) : nil }
       clean.each_slice(BATCH) { client.perform("observe", "events" => _1) }

data/lib/diffbroker/plan_usage.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "time"
+
+module Diffbroker
+  # How much of the user's own plan limits the agent has used: Claude Code's 5-hour and weekly limits, Codex's rate-limit
+  # windows. Read on this machine with the user's own login and reported as plain percentages and reset times; no token,
+  # prompt or file ever leaves it. Every reader answers nil when it cannot tell (not logged in, no sessions, no network).
+  class PlanUsage
+    CLAUDE_URL = URI("https://api.anthropic.com/api/oauth/usage")
+    CLAUDE_KEYCHAIN_SERVICE = "Claude Code-credentials"
+    MAX_WINDOWS = 2
+    # A window's key by its length in minutes: the rings and bars name them.
+    KEYS = { 300 => "session", 10_080 => "weekly", 43_200 => "monthly" }.freeze
+    CODEX_TAIL_BYTES = 400_000
+
+    def initialize(agent:, home: Dir.home, http: nil, keychain: nil, clock: -> { Time.now })
+      @agent = agent
+      @home = home
+      @http = http || method(:fetch)
+      @keychain = keychain || method(:read_keychain)
+      @clock = clock
+    end
+
+    # => { "agent" => "claude", "windows" => [{ "key", "percent", "resets_at" }] } or nil
+    def read
+      windows = @agent == "codex" ? codex_windows : claude_windows
+      windows = Array(windows).first(MAX_WINDOWS)
+      { "agent" => @agent, "windows" => windows } unless windows.empty?
+    rescue StandardError
+      nil
+    end
+
+    private
+
+    def claude_windows
+      token = claude_token
+      return unless token
+
+      body = JSON.parse(@http.call(CLAUDE_URL, token))
+      [ [ "five_hour", "session" ], [ "seven_day", "weekly" ] ].filter_map do |field, key|
+        window = body[field]
+        next unless window.is_a?(Hash) && window["utilization"].is_a?(Numeric)
+
+        { "key" => key, "percent" => window["utilization"].clamp(0, 100).round(1), "resets_at" => Time.parse(window["resets_at"].to_s).to_i }
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    def claude_token
+      raw = @keychain.call || credentials_file
+      JSON.parse(raw.to_s).dig("claudeAiOauth", "accessToken")
+    rescue JSON::ParserError
+      nil
+    end
+
+    def credentials_file
+      path = File.join(@home, ".claude", ".credentials.json")
+      File.read(path) if File.file?(path)
+    end
+
+    def read_keychain
+      return unless RUBY_PLATFORM.include?("darwin")
+
+      out = IO.popen([ "security", "find-generic-password", "-s", CLAUDE_KEYCHAIN_SERVICE, "-w" ], err: File::NULL, &:read)
+      out.to_s.strip.then { _1.empty? ? nil : _1 }
+    rescue SystemCallError
+      nil
+    end
+
+    def fetch(uri, token)
+      request = Net::HTTP::Get.new(uri, "Authorization" => "Bearer #{token}", "anthropic-beta" => "oauth-2025-04-20", "Accept" => "application/json")
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: true, open_timeout: 5, read_timeout: 8) { _1.request(request) }
+      raise Error, "usage #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+
+      response.body
+    end
+
+    # Codex writes its limits into every session's log; the newest line of the newest session is the current state.
+    def codex_windows
+      file = Dir.glob(File.join(@home, ".codex", "sessions", "*", "*", "*", "rollout-*.jsonl")).max_by { File.mtime(_1) }
+      return unless file
+
+      line = tail(file).lines.reverse.find { _1.include?('"rate_limits"') }
+      limits = line && JSON.parse(line).dig("payload", "rate_limits")
+      return unless limits.is_a?(Hash)
+
+      now = @clock.call.to_i
+      windows = %w[primary secondary].filter_map { |name| codex_window(limits[name], now) }
+      windows.sort_by { _1["minutes"] }.map { _1.except("minutes") }
+    rescue JSON::ParserError
+      nil
+    end
+
+    def codex_window(window, now)
+      return unless window.is_a?(Hash) && window["used_percent"].is_a?(Numeric) && window["resets_at"].is_a?(Integer)
+
+      minutes = window["window_minutes"].to_i
+      # A window that already reset reports the old percentage until Codex runs again: it is empty now.
+      percent = window["resets_at"] <= now ? 0 : window["used_percent"].clamp(0, 100).round(1)
+      { "key" => KEYS.fetch(minutes, minutes >= 10_080 ? "weekly" : "session"), "percent" => percent, "resets_at" => window["resets_at"], "minutes" => minutes }
+    end
+
+    def tail(path)
+      File.open(path) do |file|
+        file.seek([ file.size - CODEX_TAIL_BYTES, 0 ].max)
+        file.read.to_s
+      end
+    end
+  end
+end

data/lib/diffbroker/session_ledger.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Diffbroker
+  # The agent sessions this companion started itself. The server offers to resume a chat's earlier session by id, but it is
+  # only ever resumed here when this machine made it: a server (or anyone who could fake its message) cannot make an agent
+  # continue another conversation of the user's, such as an interactive session in their own terminal.
+  class SessionLedger
+    FILE = "sessions.json"
+    LIMIT = 500
+    ID = /\A\w[\w-]{0,99}\z/
+
+    def initialize(state_dir:)
+      @path = File.join(state_dir, FILE)
+      @lock = Mutex.new
+    end
+
+    def remember(id)
+      return unless id.to_s.match?(ID)
+
+      @lock.synchronize do
+        ids = read
+        next if ids.include?(id)
+
+        write((ids + [ id ]).last(LIMIT))
+      end
+    end
+
+    def known?(id) = id.to_s.match?(ID) && @lock.synchronize { read.include?(id) }
+
+    private
+
+    def read
+      data = JSON.parse(File.read(@path))
+      data.is_a?(Array) ? data.grep(String) : []
+    rescue Errno::ENOENT, JSON::ParserError
+      []
+    end
+
+    def write(ids)
+      FileUtils.mkdir_p(File.dirname(@path), mode: 0o700)
+      File.write(@path, JSON.generate(ids), perm: 0o600)
+    end
+  end
+end

data/lib/diffbroker/task_runner.rb

@@ -12,12 +12,12 @@ module Diffbroker
     PRINT_OUTPUT = 120
 
     Handle = Struct.new(:pid, :cancelled)
-    Outcome = Struct.new(:status, :cost_usd, :error_code, :last_output)
+    Outcome = Struct.new(:status, :cost_usd, :error_code, :last_output, :no_result)
 
     def initialize(config:, report:, worktree: Worktree.new(root: config.worktree_root), neutralizer: Neutralizer.new,
                    gh_check: GhCheck.new, launcher: Launcher.new(name: config.terminal), out: $stdout, grace: CANCEL_GRACE,
                    progress_interval: PROGRESS_INTERVAL, run_script: RunScript.new(state_dir: config.state_dir),
-                   reaper: Reaper.new(root: config.worktree_root))
+                   reaper: Reaper.new(root: config.worktree_root), sessions: SessionLedger.new(state_dir: config.state_dir))
       @config = config
       @report = report
       @worktree = worktree
@@ -29,6 +29,7 @@ module Diffbroker
       @progress_interval = progress_interval
       @run_script = run_script
       @reaper = reaper
+      @sessions = sessions
       @handles = {}
       @running = Set.new
       @cancelled = Set.new
@@ -132,7 +133,7 @@ module Diffbroker
     def run_autonomous(task, agent, mcp_config, dir)
       id = task["task_id"]
       @lock.synchronize { @running << id }
-      outcome = run_process(task, agent, mcp_config, dir)
+      outcome = run_with_resume(task, agent, mcp_config, dir)
       outcome = verify_after_write(task, outcome, agent, mcp_config, dir) if ExplainVerifier.verified?(task) && outcome.status == "done"
       outcome = publish_branch(task, outcome, dir) if outcome.status == "done"
       finished(id, outcome.status, outcome.cost_usd, outcome.error_code, outcome.last_output)
@@ -143,6 +144,27 @@ module Diffbroker
       end
     end
 
+    # A chat message the server offered to resume (task["resume"]) continues the agent's earlier session, when this machine made it
+    # and this agent can: it gets only the new question and keeps what it read. A session that cannot be resumed (deleted, expired)
+    # makes the agent exit without a word: the message then runs again from scratch with the full prompt, which carries the chat.
+    def run_with_resume(task, agent, mcp_config, dir)
+      resume = resume_for(task, agent)
+      return run_process(task, agent, mcp_config, dir) unless resume
+
+      outcome = run_process(task.merge("prompt" => resume["prompt"], "resume_session_id" => resume["session_id"]), agent, mcp_config, dir)
+      return outcome unless outcome.status == "failed" && outcome.no_result
+
+      say(task["task_id"], "Could not resume the earlier session: starting this message from scratch")
+      run_process(task, agent, mcp_config, dir)
+    end
+
+    def resume_for(task, agent)
+      resume = task["resume"]
+      return unless resume.is_a?(Hash) && agent.resumes? && resume["agent"] == agent.name && resume["prompt"].to_s != ""
+
+      resume if @sessions.known?(resume["session_id"])
+    end
+
     # An update_branch task ends with a rebase the agent may not push (see BranchPublisher): the companion does, here.
     def publish_branch(task, outcome, dir)
       return outcome unless publishes_branch?(task)
@@ -197,7 +219,7 @@ module Diffbroker
 
       if handle.cancelled then Outcome.new("cancelled", result&.cost_usd, "cancelled", output)
       elsif status.success? && !result&.error then Outcome.new("done", result&.cost_usd, nil, output)
-      else Outcome.new("failed", result&.cost_usd, "agent_failed", output)
+      else Outcome.new("failed", result&.cost_usd, "agent_failed", output, result.nil?)
       end
     ensure
       writer.close if writer && !writer.closed?
@@ -221,6 +243,10 @@ module Diffbroker
         case (event = agent.parse_stream(line))
         when Agents::Result then result = event
         when Agents::Progress
+          if event.session_id
+            @sessions.remember(event.session_id)
+            progress(id, event.step, nil, nil, event.session_id)
+          end
           next if event.step == last_step || monotonic - last_sent < @progress_interval
 
           progress(id, event.step)
@@ -256,8 +282,8 @@ module Diffbroker
       end
     end
 
-    def progress(id, step, agent = nil, phase = nil)
-      @report.call("progress", { "task_id" => id, "step" => step, "agent" => agent, "phase" => phase }.compact)
+    def progress(id, step, agent = nil, phase = nil, session_id = nil)
+      @report.call("progress", { "task_id" => id, "step" => step, "agent" => agent, "phase" => phase, "session_id" => session_id }.compact)
       say(id, "progress: #{step}") unless step == "starting"
     end
 

data/lib/diffbroker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Diffbroker
-  VERSION = "0.9.0"
+  VERSION = "0.11.0"
 end

data/lib/diffbroker.rb

@@ -32,12 +32,14 @@ module Diffbroker
   autoload :LocalRelay, File.expand_path("diffbroker/local_relay", __dir__)
   autoload :Login, File.expand_path("diffbroker/login", __dir__)
   autoload :Neutralizer, File.expand_path("diffbroker/neutralizer", __dir__)
+  autoload :PlanUsage, File.expand_path("diffbroker/plan_usage", __dir__)
   autoload :ProcessScanner, File.expand_path("diffbroker/process_scanner", __dir__)
   autoload :Reaper, File.expand_path("diffbroker/reaper", __dir__)
   autoload :RepoScanner, File.expand_path("diffbroker/repo_scanner", __dir__)
   autoload :RunScript, File.expand_path("diffbroker/run_script", __dir__)
   autoload :Runner, File.expand_path("diffbroker/runner", __dir__)
   autoload :ServiceInstaller, File.expand_path("diffbroker/service_installer", __dir__)
+  autoload :SessionLedger, File.expand_path("diffbroker/session_ledger", __dir__)
   autoload :SkillInstaller, File.expand_path("diffbroker/skill_installer", __dir__)
   autoload :TaskFiles, File.expand_path("diffbroker/task_files", __dir__)
   autoload :TaskRunner, File.expand_path("diffbroker/task_runner", __dir__)

data/plugin/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "diffbroker",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Skills for working on Diff Broker agent tasks: the diffbroker MCP tools, write rules and report_task."
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: diffbroker
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Yuri Sidorov (@newstler)
@@ -56,12 +56,14 @@ files:
 - lib/diffbroker/login.rb
 - lib/diffbroker/maintenance.rb
 - lib/diffbroker/neutralizer.rb
+- lib/diffbroker/plan_usage.rb
 - lib/diffbroker/process_scanner.rb
 - lib/diffbroker/reaper.rb
 - lib/diffbroker/repo_scanner.rb
 - lib/diffbroker/run_script.rb
 - lib/diffbroker/runner.rb
 - lib/diffbroker/service_installer.rb
+- lib/diffbroker/session_ledger.rb
 - lib/diffbroker/skill_installer.rb
 - lib/diffbroker/task_files.rb
 - lib/diffbroker/task_runner.rb