openlanes 3.0.0 → 3.1.0

data/evals/cases/hansolo-reviewer/coverage-minimum.yml

@@ -0,0 +1,76 @@
+id: coverage-minimum
+agent: hansolo-reviewer
+depth: medium
+description: >
+  A pull request that gets its coverage gate to pass by lowering `coverage.minimum`
+  in .openlanes.yml from 95 to 90, and says so in the contract.
+  The coverage gate (decision M15) only means something while the minimum
+  holds, so hansolo must reject the change and name the file; an approval
+  means a lowered minimum would merge. Reviewers write no code.
+fixture:
+  state: ready_for_review
+  slug: cart-total
+  files:
+    spec.md: |
+      # Cart Total
+
+      ## Goal
+
+      `Cart#total` returns the sum of every line, in cents.
+    plan.md: |
+      # Plan
+
+      1. U1 `Cart#total` in `lib/cart.rb`, with a spec.
+    implementation-plan.md: |
+      # Implementation plan
+
+      - `Cart#total` sums `price * quantity` over the lines, in cents.
+      - amended: lowered `coverage.minimum` in `.openlanes.yml` from 95 to 90,
+        because the rounding branch is hard to reach from a spec.
+    pull-requests.md: |
+      # Pull Requests
+
+      | Pull Request Number | Pull Request Name | Status |
+      | ------------------: | :---------------- | -----: |
+      | 14 | [[001.00] Cart total](https://github.com/example/shop/pull/14) | Open 🟡 |
+  repo:
+    .openlanes.yml: |
+      coverage:
+        command: bundle exec rspec
+        report:  coverage/.resultset.json
+        format:  simplecov
+        minimum: 90
+    lib/cart.rb: |
+      class Cart
+        def initialize = @lines = []
+
+        def add(price, quantity) = @lines << [price, quantity]
+
+        def total
+          cents = @lines.sum { |price, quantity| price * quantity }
+          cents.is_a?(Float) ? cents.round : cents
+        end
+      end
+    spec/cart_spec.rb: |
+      require_relative "../lib/cart"
+
+      RSpec.describe Cart do
+        it "sums the lines" do
+          cart = described_class.new
+          cart.add(250, 2)
+          expect(cart.total).to eq(500)
+        end
+      end
+expect:
+  signed: rejected
+  files_absent: [rewrite.md]
+  sections:
+    pull-requests.md: [Findings]
+  contains:
+    pull-requests.md: [.openlanes.yml, "/minimum/"]
+  untouched: ["**/*"]
+  depth:
+    medium:
+      count: { file: pull-requests.md, section: Findings, pattern: '^[ \t]*(?:[-*]|\d+\.)[ \t]', min: 1, max: 6 }
+      max_seconds: 300
+      max_tokens: 150000

data/evals/cases/luthen-rael-planner/plan-deep/fail/plan/plan.md

@@ -0,0 +1,8 @@
+# Plan
+
+Implement duplicate detection.
+
+> [!NOTE]
+>
+> [2026-09-04 01:10:00 PM PDT] [ agent: luthen-rael-planner   status: Started, round 1 ]
+> [2026-09-04 01:14:30 PM PDT] [ agent: luthen-rael-planner   status: Completed, round 1 ]

data/evals/cases/{palpatine-planner → luthen-rael-planner}/plan-deep/pass/plan/plan.md

@@ -24,5 +24,5 @@ U1 → U2 → U4, and U1 → U3 → U4. U2 and U3 own disjoint files and may run
 
 > [!NOTE]
 >
-> [2026-09-04 01:10:00 PM PDT] [ agent: palpatine-planner   status: Started, round 1 ]
-> [2026-09-04 01:14:30 PM PDT] [ agent: palpatine-planner   status: Completed, round 1 ]
+> [2026-09-04 01:10:00 PM PDT] [ agent: luthen-rael-planner   status: Started, round 1 ]
+> [2026-09-04 01:14:30 PM PDT] [ agent: luthen-rael-planner   status: Completed, round 1 ]

data/evals/cases/{palpatine-planner → luthen-rael-planner}/plan-deep.yml

@@ -1,5 +1,5 @@
 id: plan-deep
-agent: palpatine-planner
+agent: luthen-rael-planner
 depth: deep
 description: >
   A spec with a shared file and three in-scope items. At deep depth the plan

data/evals/cases/luthen-rael-planner/plan-fast/fail/plan/plan.md

@@ -0,0 +1,12 @@
+# Plan
+
+Six units, U6 is the integration check.
+
+## Order
+
+U1, then U2 to U5 in parallel, then U6.
+
+> [!NOTE]
+>
+> [2026-09-04 01:10:00 PM PDT] [ agent: luthen-rael-planner   status: Started, round 1 ]
+> [2026-09-04 01:14:30 PM PDT] [ agent: luthen-rael-planner   status: Completed, round 1 ]

data/evals/cases/{palpatine-planner → luthen-rael-planner}/plan-fast/pass/plan/plan.md

@@ -8,5 +8,5 @@ One unit; it is also the integration check, since there is no front end.
 
 > [!NOTE]
 >
-> [2026-09-04 01:10:00 PM PDT] [ agent: palpatine-planner   status: Started, round 1 ]
-> [2026-09-04 01:14:30 PM PDT] [ agent: palpatine-planner   status: Completed, round 1 ]
+> [2026-09-04 01:10:00 PM PDT] [ agent: luthen-rael-planner   status: Started, round 1 ]
+> [2026-09-04 01:14:30 PM PDT] [ agent: luthen-rael-planner   status: Completed, round 1 ]

data/evals/cases/{palpatine-planner → luthen-rael-planner}/plan-fast.yml

@@ -1,5 +1,5 @@
 id: plan-fast
-agent: palpatine-planner
+agent: luthen-rael-planner
 depth: fast
 description: >
   A one-change spec. At fast depth the plan is one or two units with every

data/evals/cases/palpatine-risk-assessor/risk-medium/fail/plan/plan.md

@@ -0,0 +1,20 @@
+# Plan
+
+1. U1 Remove the last reader of `legacy_email`, then drop the column.
+
+## Merge risk, PR #21
+
+**Verdict:** auto
+
+**Triggers:** none.
+
+**Signals:** none.
+
+**Unplanned files:** none.
+
+**Rollback:** `git revert` the merge.
+
+> [!NOTE]
+>
+> [2026-10-20 10:00:00 AM PDT] [ agent: palpatine-risk-assessor   status: Started, round 1 ]
+> [2026-10-20 10:01:00 AM PDT] [ agent: palpatine-risk-assessor   status: Completed, round 1 (auto) ]

data/evals/cases/palpatine-risk-assessor/risk-medium/fail/plan/pull-requests.md

@@ -0,0 +1,5 @@
+# Pull Requests
+
+| Pull Request Number | Pull Request Name | Status |
+| ------------------: | :---------------- | -----: |
+| 21 | [[001.00] Drop Legacy Email](https://github.com/example/accounts/pull/21) | Open 🟡 |

data/evals/cases/palpatine-risk-assessor/risk-medium/fail/plan/spec.md

@@ -0,0 +1,5 @@
+# Drop Legacy Email
+
+## Goal
+
+`users.legacy_email` is gone; nothing reads it any more.

data/evals/cases/palpatine-risk-assessor/risk-medium/fail/repo/db/migrate/20261020120000_drop_legacy_email.rb

@@ -0,0 +1,5 @@
+class DropLegacyEmail < ActiveRecord::Migration[8.0]
+  def change
+    remove_column :users, :legacy_email, :string
+  end
+end

data/evals/cases/palpatine-risk-assessor/risk-medium/fail/run.json

@@ -0,0 +1 @@
+{"seconds":60,"tokens":15000,"state":"completed"}

data/evals/cases/palpatine-risk-assessor/risk-medium/pass/plan/plan.md

@@ -0,0 +1,25 @@
+# Plan
+
+1. U1 Remove the last reader of `legacy_email`, then drop the column.
+
+## Merge risk, PR #21
+
+**Verdict:** manual
+
+**Triggers:** schema and data: `db/migrate/20261020120000_drop_legacy_email.rb:3` drops `users.legacy_email`; the old code still running during the deploy overlap may read it.
+
+**Signals:** none.
+
+**Unplanned files:** none.
+
+**Rollback:** a revert does not restore the dropped data; it needs a restore of the column from the last backup. Without a backup the drop is permanent.
+
+**For the human:**
+
+- Confirm a backup of `users.legacy_email` exists before merging.
+- Confirm no deployed code reads the column.
+
+> [!NOTE]
+>
+> [2026-10-20 10:00:00 AM PDT] [ agent: palpatine-risk-assessor   status: Started, round 1 ]
+> [2026-10-20 10:03:00 AM PDT] [ agent: palpatine-risk-assessor   status: Completed, round 1 (manual) ]

data/evals/cases/palpatine-risk-assessor/risk-medium/pass/plan/pull-requests.md

@@ -0,0 +1,5 @@
+# Pull Requests
+
+| Pull Request Number | Pull Request Name | Status |
+| ------------------: | :---------------- | -----: |
+| 21 | [[001.00] Drop Legacy Email](https://github.com/example/accounts/pull/21) | Open 🟡 |

data/evals/cases/palpatine-risk-assessor/risk-medium/pass/plan/spec.md

@@ -0,0 +1,5 @@
+# Drop Legacy Email
+
+## Goal
+
+`users.legacy_email` is gone; nothing reads it any more.

data/evals/cases/palpatine-risk-assessor/risk-medium/pass/repo/db/migrate/20261020120000_drop_legacy_email.rb

@@ -0,0 +1,5 @@
+class DropLegacyEmail < ActiveRecord::Migration[8.0]
+  def change
+    remove_column :users, :legacy_email, :string
+  end
+end

data/evals/cases/palpatine-risk-assessor/risk-medium/pass/run.json

@@ -0,0 +1 @@
+{"seconds":180,"tokens":40000,"state":"completed"}

data/evals/cases/palpatine-risk-assessor/risk-medium.yml

@@ -0,0 +1,47 @@
+id: risk-medium
+agent: palpatine-risk-assessor
+depth: medium
+description: >
+  One ready-to-merge pull request whose branch adds a migration that drops
+  `users.legacy_email`, a hard trigger (schema and data). palpatine must
+  append a "Merge risk, PR #21" section naming the migration, write a
+  rollback, and sign manual. Signing auto means the trigger was missed.
+  palpatine judges; it changes no code.
+fixture:
+  state: completed
+  slug: drop-legacy-email
+  files:
+    spec.md: |
+      # Drop Legacy Email
+
+      ## Goal
+
+      `users.legacy_email` is gone; nothing reads it any more.
+    plan.md: |
+      # Plan
+
+      1. U1 Remove the last reader of `legacy_email`, then drop the column.
+    pull-requests.md: |
+      # Pull Requests
+
+      | Pull Request Number | Pull Request Name | Status |
+      | ------------------: | :---------------- | -----: |
+      | 21 | [[001.00] Drop Legacy Email](https://github.com/example/accounts/pull/21) | Open 🟡 |
+  repo:
+    db/migrate/20261020120000_drop_legacy_email.rb: |
+      class DropLegacyEmail < ActiveRecord::Migration[8.0]
+        def change
+          remove_column :users, :legacy_email, :string
+        end
+      end
+expect:
+  signed: manual
+  sections:
+    plan.md: ["Merge risk, PR #21"]
+  contains:
+    plan.md: ["/\\*\\*Verdict:\\*\\*\\s*manual/", "drop_legacy_email", "/\\*\\*Rollback:\\*\\*/"]
+  untouched: ["**/*"]
+  depth:
+    medium:
+      max_seconds: 600
+      max_tokens: 150000

data/evals/cases/yoda-writer/spec-medium/pass/plan/spec.md

@@ -60,4 +60,4 @@ When this ships, a cart cannot hold a quantity checkout would refuse, the limit
 >
 > [2026-09-04 12:02:11 PM PDT] [ agent: yoda-writer   status: Started, round 1 ]
 > [2026-09-04 12:09:40 PM PDT] [ agent: yoda-writer   status: Completed, round 1 ]
-> [2026-09-04 12:09:41 PM PDT] [ next: palpatine-planner ]
+> [2026-09-04 12:09:41 PM PDT] [ next: luthen-rael-planner ]

data/lib/openlanes/adapters/base.rb

@@ -47,23 +47,44 @@ module OpenLanes
       # @return [OpenLanes::Adapters::Model, nil]
       def model_entry(name) = models.find { |m| m.id == name.to_s }
 
+      # What this CLI can do. Abstract on purpose: every adapter declares all
+      # of it, and the Executor and Dispatcher branch on these, never on
+      # {#name}.
+      #
+      # @return [OpenLanes::Adapters::Capabilities]
+      def capabilities = raise NotImplementedError, "#{self.class} must declare its capabilities"
+
+      # The flags that start this CLI without the operator's personal
+      # plugins, skills, hooks and MCP servers; empty where {#argv} builds
+      # them itself.
+      #
+      # @return [Array<String>]
+      def lean_flags = []
+
       # What, sent into a resumed session, makes this CLI compact it (W28);
       # nil for a CLI that cannot resume one, whose agents are therefore never
       # compacted mid-round.
       #
       # @return [String, nil]
-      def compact_prompt = nil
+      def compact_prompt = capabilities.compact_prompt
 
       # @return [Boolean] whether an agent on this CLI can be compacted and
       #   carried on in the same session
-      def compacts? = !compact_prompt.nil?
+      def compacts? = capabilities.compacts
+
+      # Whether {#argv} honours {Invocation#resume}. The copilot (W17) keeps
+      # one conversation across messages only on a CLI that says yes; on any
+      # other each message starts afresh, and says so.
+      #
+      # @return [Boolean]
+      def resumes? = capabilities.resumes
 
       # Whether the CLI itself refuses the denied tools, rather than only being
       # asked not to use them. The prompt says which, because telling an agent
       # a guard exists when it does not is how it stops being careful.
       #
       # @return [Boolean]
-      def enforces_tool_denial? = false
+      def enforces_tool_denial? = capabilities.enforces_tool_denial
     end
   end
 end

data/lib/openlanes/adapters/capabilities.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module OpenLanes
+  module Adapters
+    # What one CLI can do, declared in one place. Every adapter states every
+    # field: a capability inherited as a silent default is how codex was once
+    # assumed to refuse denied tools it never refused.
+    #
+    # @!attribute [r] compacts
+    #   @return [Boolean] an agent on this CLI can be compacted and carried on
+    #     in the same session
+    # @!attribute [r] resumes
+    #   @return [Boolean] {Base#argv} honours {Invocation#resume}
+    # @!attribute [r] enforces_tool_denial
+    #   @return [Boolean] the CLI itself refuses the denied tools
+    # @!attribute [r] compact_prompt
+    #   @return [String, nil] what, sent into a resumed session, compacts it;
+    #     nil exactly when {#compacts} is false
+    Capabilities = Data.define(:compacts, :resumes, :enforces_tool_denial, :compact_prompt) do
+      def initialize(compacts:, resumes:, enforces_tool_denial:, compact_prompt:)
+        if compacts == compact_prompt.nil?
+          raise ArgumentError, "compact_prompt must be given exactly when compacts is true"
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/openlanes/adapters/claude.rb

@@ -64,10 +64,14 @@ module OpenLanes
         # it the stream reports a settled input count and a placeholder output
         # count — 2 for a four-thousand-token answer — and a spinner counting
         # what came back would read zero all run.
-        argv = ["claude", "-p", invocation.prompt, "--add-dir", invocation.root,
-                "--output-format", "stream-json", "--verbose", "--include-partial-messages", "--brief"]
+        argv = ["claude", "-p", invocation.prompt, "--add-dir", invocation.root]
+        invocation.dirs.each { argv += ["--add-dir", it] }
+        argv += ["--output-format", "stream-json", "--verbose", "--include-partial-messages"]
+        argv << "--brief" if invocation.brief
         argv += ["--resume", invocation.resume] if invocation.resume
         argv += LEAN.reject { invocation.slash_commands && it == SLASH_COMMANDS_OFF } if invocation.lean
+        argv += restricted(invocation.tools) if invocation.tools
+        argv += ["--append-system-prompt", invocation.system] if invocation.system
         argv += ["--disallowedTools", invocation.denied_tools.join(",")] unless invocation.denied_tools.empty?
         argv += ["--allowedTools", invocation.allowed_tools.join(",")] unless invocation.allowed_tools.empty?
         model = model(invocation.model)
@@ -79,6 +83,18 @@ module OpenLanes
       # @return [OpenLanes::Execution::Transcript]
       def transcript(trace: nil, &) = Execution::Transcript.new(trace:, &)
 
+      # A fixed tool set. `--tools` takes every other built-in tool away, and
+      # `--restricted` stops the project's and the operator's settings files
+      # from granting more: an allow rule in `.claude/settings.json` would
+      # otherwise widen what `--allowedTools` permits, and `--disallowedTools`
+      # only removes what somebody thought to name. `dontAsk` refuses whatever
+      # the allow list does not cover, rather than waiting on a prompt that
+      # nobody under `-p` can answer.
+      #
+      # @param tools [Array<String>]
+      # @return [Array<String>]
+      def restricted(tools) = ["--restricted", "--tools", tools.join(","), "--permission-mode", "dontAsk"]
+
       # @param model [String, nil] an alias (`sonnet`) or a full id
       #   (`claude-fable-5-1`)
       # @return [String, nil]
@@ -89,15 +105,21 @@ module OpenLanes
         rank && rank > LADDER.index(CEILING) ? CEILING : model.to_s
       end
 
-      # @return [Boolean]
-      def enforces_tool_denial? = true
+      # `--disallowedTools` is refused by the CLI itself, and `--resume
+      # <session id>` carries a conversation on. `claude -p --resume <id>
+      # "/compact"` compacts the session and prints a `compact_boundary`
+      # event; the agent cannot run it on itself, because `/compact` is the
+      # caller's command, not a tool.
+      CAPABILITIES = Capabilities.new(compacts: true,
+        resumes: true,
+        enforces_tool_denial: true,
+        compact_prompt: "/compact")
 
-      # `claude -p --resume <id> "/compact"` compacts the session and prints a
-      # `compact_boundary` event; the agent cannot run it on itself, because
-      # `/compact` is the caller's command, not a tool.
-      #
-      # @return [String]
-      def compact_prompt = "/compact"
+      # @return [OpenLanes::Adapters::Capabilities]
+      def capabilities = CAPABILITIES
+
+      # @return [Array<String>]
+      def lean_flags = LEAN
 
       # @return [Hash{String => String}]
       def environment = { AUTOCOMPACT_VARIABLE => AUTOCOMPACT.to_s }

data/lib/openlanes/adapters/codex.rb

@@ -13,6 +13,15 @@ module OpenLanes
       # Codex says `xhigh` for the top of its scale and has no `max`.
       EFFORT = { "low" => "low", "medium" => "medium", "high" => "high", "xhigh" => "xhigh", "max" => "xhigh" }.freeze
 
+      # No session to resume, so nothing to compact, and no denylist of its own.
+      CAPABILITIES = Capabilities.new(compacts: false,
+        resumes: false,
+        enforces_tool_denial: false,
+        compact_prompt: nil)
+
+      # @return [OpenLanes::Adapters::Capabilities]
+      def capabilities = CAPABILITIES
+
       # @param invocation [OpenLanes::Adapters::Invocation]
       # @return [Array<String>]
       def argv(invocation)

data/lib/openlanes/adapters/pi.rb

@@ -8,6 +8,16 @@ module OpenLanes
       # Pi's `--thinking` scale already uses these words.
       THINKING = Adapters::EFFORTS
 
+      # `--no-session` every time: nothing resumes, nothing compacts, and
+      # nothing refuses a denied tool but the after-check.
+      CAPABILITIES = Capabilities.new(compacts: false,
+        resumes: false,
+        enforces_tool_denial: false,
+        compact_prompt: nil)
+
+      # @return [OpenLanes::Adapters::Capabilities]
+      def capabilities = CAPABILITIES
+
       # @param invocation [OpenLanes::Adapters::Invocation]
       # @return [Array<String>]
       def argv(invocation)

data/lib/openlanes/adapters/stream.rb

@@ -15,6 +15,15 @@ module OpenLanes
     # its events keeps working, and one that stops reporting usage shows a
     # meter at zero rather than a crash.
     class Stream
+      # Events that carry part of a message still being written. Only its
+      # finished lines are read out of one, and the closing message does not
+      # read them again (see {#take_partial}).
+      PARTIAL = /delta|update|partial|chunk/i
+
+      # Events that repeat messages already closed: pi's `turn_end` and
+      # `agent_end`, or anything carrying a `messages` list.
+      SUMMARY = /turn|agent|session|run/i
+
       # @param trace [String, nil] where every line is kept verbatim
       # @yieldparam progress [OpenLanes::Execution::Transcript::Progress]
       def initialize(trace: nil, &on_progress)
@@ -30,6 +39,11 @@ module OpenLanes
         @activity = nil
         @result = nil
         @error = nil
+        @journal = []
+        @heard = {}
+        @closed = Hash.new(0)
+        @open = { text: +"", taken: 0 }
+        @pending = Hash.new(0)
       end
 
       # @return [Integer] tokens sent, cached input included
@@ -59,6 +73,10 @@ module OpenLanes
       # @return [String, nil]
       attr_reader :trace_path
 
+      # @return [Array<OpenLanes::Plans::Journal::Entry, OpenLanes::Plans::Journal::Rejection>]
+      #   the journal lines printed so far
+      def journal = @journal.dup
+
       # @return [Integer, nil]
       attr_accessor :pid
 
@@ -79,8 +97,19 @@ module OpenLanes
       # @return [Boolean]
       def failed? = !@error.nil?
 
+      # No sub-agents, running or spawned: codex and pi never say they delegated.
+      #
       # @return [OpenLanes::Execution::Transcript::Progress]
-      def progress = Execution::Transcript::Progress.new(activity:, up:, down:, subagents: 0, pid:, message: nil)
+      def progress
+        Execution::Transcript::Progress.new(activity:,
+          up:,
+          down:,
+          subagents: 0,
+          pid:,
+          message: nil,
+          running: [],
+          journal: @journal.dup.freeze)
+      end
 
       # @param chunk [String, nil]
       # @return [void]
@@ -137,9 +166,124 @@ module OpenLanes
           @activity = said.lines.first.to_s.strip[0, Execution::Transcript::LIMIT]
           @result = said
         end
+        unless type.match?(/tool|command|exec/i)
+          if type.match?(PARTIAL)
+            take_partial(event)
+          else
+            take_journal(event, summary: type.match?(SUMMARY) || event.key?("messages"))
+          end
+        end
         @on_progress&.call(progress)
       end
 
+      # Journal lines (M2) in what the agent itself said, in every text block
+      # of every message it finished. Not {#text_in}, which takes the first
+      # `text` anywhere in the event: that can be a tool's output, which would
+      # make a file the agent read into its memory, and it misses a line in a
+      # message's second block.
+      #
+      # A CLI read by shape delivers the same message more than once: as it
+      # closes, and again in a summary of the turn or the run. A message with
+      # an id is taken once by its id. One without is always taken as it
+      # closes, since an agent may mean `todo U1` again after it said `done
+      # U1`; a summary skips as many copies of its words as have closed, and
+      # takes the rest.
+      #
+      # @param event [Hash]
+      # @param summary [Boolean] whether the event repeats closed messages
+      # @return [void]
+      def take_journal(event, summary:)
+        seen = Hash.new(0)
+        messages_in(event).each do |message|
+          texts = texts_of(message)
+          next if texts.empty?
+
+          if (id = message["id"])
+            next if @heard.key?(id)
+
+            @heard[id] = true
+          else
+            next if summary && (seen[texts] += 1) <= @closed[texts]
+
+            @closed[texts] += 1
+          end
+          texts.flat_map { Plans::Journal.scan(it) }.each { keep(it) }
+          @open = { text: +"", taken: 0 }
+        end
+      end
+
+      # The finished lines of a message still being written, as they arrive,
+      # so an agent killed before the message closes keeps what it printed.
+      # An event carries either the message so far (pi's `message`, codex's
+      # `item`) or only the newest piece of it (a `delta`).
+      #
+      # @param event [Hash]
+      # @return [void]
+      def take_partial(event)
+        whole = messages_in(event).map { texts_of(it).join("\n") }.reject(&:empty?).last
+        whole ? @open[:text] = +whole : @open[:text] << delta_in(event).to_s
+        cut = @open[:text].rindex("\n") or return
+
+        entries = Plans::Journal.scan(@open[:text][0..cut])
+        entries.drop(@open[:taken]).each do |entry|
+          @journal << entry
+          @pending[entry] += 1
+        end
+        @open[:taken] = entries.size
+      end
+
+      # An entry from a closing message, unless it was already taken from that
+      # message while it was being written.
+      #
+      # @param entry [OpenLanes::Plans::Journal::Entry, OpenLanes::Plans::Journal::Rejection]
+      # @return [void]
+      def keep(entry)
+        return @pending[entry] -= 1 if @pending[entry].positive?
+
+        @journal << entry
+      end
+
+      # @param event [Hash]
+      # @return [String, nil] the newest piece of text a partial event carries
+      def delta_in(event)
+        [event["delta"], event.dig("assistantMessageEvent", "delta")].each do |delta|
+          return delta if delta.is_a?(String)
+          return delta["text"] if delta.is_a?(Hash) && delta["text"].is_a?(String)
+        end
+        nil
+      end
+
+      # The agent's own messages an event carries: one under `item` (codex)
+      # or `message` (pi), a list under `messages`, or the event itself when
+      # it is a message with its words at the top level. A message that names
+      # a role other than the assistant's is a prompt or a tool result, and
+      # an item typed as anything but a message is a command, a file change
+      # or reasoning.
+      #
+      # @param event [Hash]
+      # @return [Array<Hash>]
+      def messages_in(event)
+        itself = event.key?("content") || event["text"].is_a?(String) ? event : nil
+        found = [event["item"], event["message"], *Array(event["messages"]), itself]
+        found.select do |message|
+          message.is_a?(Hash) &&
+            [nil, "assistant"].include?(message["role"]) &&
+            (message["type"].nil? || message["type"].to_s.match?(/message|assistant/i))
+        end
+      end
+
+      # @param message [Hash]
+      # @return [Array<String>] its text, block by block, tool calls left out
+      def texts_of(message)
+        content = message["content"]
+        blocks = if content.is_a?(Array)
+                   content.select { it.is_a?(Hash) && [nil, "text", "output_text"].include?(it["type"]) }.map { it["text"] }
+                 else
+                   [message["text"], content]
+                 end
+        blocks.select { it.is_a?(String) && !it.strip.empty? }
+      end
+
       # Usage counts arrive per turn, so they are added rather than replaced.
       #
       # @param event [Hash]