little_ghost 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6ec454a6085af7b0e2519eb0137e2f70115f0c00197d9f1914ac336c9fe4810
-  data.tar.gz: bde8feed25fc76a6e0290ec8462b12eb5b2df90c368214850caaa705a3da75d2
+  metadata.gz: f7e4df5249569e4b93c22c44929064ad12632ca6119667429004ffc3bc4b7f7a
+  data.tar.gz: 6ad9b9d7252c1e0749f8d4503ba820259257fb4b0e46bc638ff3bd426ed191d9
 SHA512:
-  metadata.gz: 0c7081dc35068d5e3e3e0d917e4f024657cbecc117a0952b4ccfa329a9a4be2de77a96c87d9d7cf1eb3f9092219ed108d07422fa501e427542fdfb400aaf3e4a
-  data.tar.gz: 939d5fac29d8a1607225185f09784e2fe014d7ef20c20ba856ebda0b30c8e6634a79a9ff94725287f924576caecb2080204dec5fa7b36af3b801d02c3d9de93c
+  metadata.gz: 0a1e7fdc5cfe228456703b0d8b383f67461f5a465f962f010cacbee5ef55a90881f7e7135c5107745f1442a0803ddbe865b4d50912485e738b21566282404c34
+  data.tar.gz: db5f637104b9c42a8d470b80079b29a877fddf8a41c1a5c110d8a4b926c136b36933ffe234870a0ab1a53f98083d5f856f2fd1c44ea967ae9852f5d7abebc878

data/docs/guides/code_mode.md

@@ -260,10 +260,11 @@ contains model-written code. An engine may request named runtime paths for its
 interpreter libraries. Those paths are visible to the child process, but they
 never become filesystem grants available through Tools.
 
-The session owns every Workspace, Sandbox, child process, thread, and
+The session owns every Workspace, Sandbox, child process, background task, and
 communication channel it creates. It closes those resources in reverse order.
-LittleGhost may use one registered engine instance for concurrent Agent Runs,
-so the engine must keep each program's mutable state inside its session.
+One registered engine can open several sessions concurrently on threads or
+fibers. Keep each program's mutable state inside the returned session, and
+synchronize any state the engine shares across sessions.
 
 A sandboxed engine must use a backend that owns the complete child process tree
 or can prevent child processes. An explicitly unrestricted backend may run an

data/docs/guides/integrations.md

@@ -170,8 +170,8 @@ events.each { |event| websocket.write(JSON.generate(event)) }
 
 The adapter translates text, reasoning, Tool activity, usage, retries, trace
 context, subagent activity, and terminal outcomes. It is stateless between
-calls. Your application still owns the connection, thread storage,
-backpressure, and disconnect behavior.
+calls. Your application still owns the connection, backpressure, disconnect
+behavior, and any request state its callbacks need.
 
 LittleGhost also emits namespaced custom events. Consumers should preserve or
 deliberately ignore event types they don't recognize. See the [AG-UI event
@@ -182,8 +182,8 @@ client.
 > results, errors, and participant activity. Check that the connected user may
 > see the complete Run, then filter fields before sending or storing events.
 
-Enumeration drives the source stream on the current thread. When a client
-disconnects, stop enumerating and apply the cancellation behavior your
+Calling `each` drives the source stream on the caller's fiber or thread. When a
+client disconnects, stop enumerating and apply the cancellation behavior your
 application needs. Closing the socket can't undo Tool work that already ran.
 
 ## Trace Runs with OpenTelemetry

data/docs/guides/production.md

@@ -75,6 +75,103 @@ The controller supplies identity and account access from authenticated applicati
 
 Configure LittleGhost before the first Agent or Assembly call. Once application services start successfully, the configuration is locked so every request sees one stable setup.
 
+## Use an existing fiber scheduler
+
+If your application already runs inside a Ruby Fiber scheduler, LittleGhost
+uses it for parallel Tool calls, Workflow and Graph branches, subagent turns,
+background Executions, and nested code-mode Tool calls. LittleGhost does not
+install or run a scheduler. Your scheduler must support `Fiber.schedule`. The
+optional `async` gem used below does.
+
+For example, an application using the optional `async` gem can let several
+requests make progress on one thread while each request waits for network I/O.
+Add `gem "async"` to the application's bundle, then start the calls inside an
+Async task:
+
+```ruby
+require "async"
+
+questions = [
+  "How long do refunds take?",
+  "Can I update my delivery address?"
+]
+
+answers = Async do |task|
+  questions.map do |question|
+    task.async { CustomerSupportAgent.ask(question).response }
+  end.map(&:wait)
+end.wait
+```
+
+The default `:auto` setting uses fibers when a call begins inside a scheduled
+fiber and worker threads everywhere else. Set `concurrency_backend` to `:fiber`
+when calling outside a scheduled fiber should be an application error.
+LittleGhost then raises `LittleGhost::ConfigurationError` instead of quietly
+starting a thread.
+
+### Keep one blocking call from pausing other fibers
+
+Fiber scheduling helps while work waits for I/O; it does not make CPU-heavy
+Ruby code run in parallel. Whether an I/O call lets other fibers run depends on
+the Ruby version, scheduler, and library. Call libraries normally at first. If
+documentation or measurement shows that one call pauses the other fibers—and
+the work can continue on another Ruby thread—wrap that call:
+
+```ruby
+article = LittleGhost.offload_blocking do
+  HelpCenterSearch.lookup(question)
+end
+```
+
+Outside a scheduled fiber, `offload_blocking` runs the block inline. Inside one,
+it uses LittleGhost's shared pool of reusable threads so the other fibers can
+continue. If the caller is cancelled after the pool accepts the block,
+LittleGhost waits for the block to finish before reporting the cancellation.
+The helper does not add a timeout or cancellation mechanism to the underlying
+call, so use the library's controls when available.
+
+If most of your Tool or extension code prevents other fibers from running, use
+worker threads for all LittleGhost concurrency instead:
+
+```ruby
+LittleGhost.configure do |config|
+  config.concurrency_backend = :thread
+end
+```
+
+LittleGhost also keeps a few jobs on threads so it can finish or clean them up
+reliably. Provider and subprocess streams may use dedicated threads. Inside a
+scheduled fiber, certificate generation and Filesystem SessionStore
+transactions use the same shared pool as `offload_blocking`. A Run may
+therefore still create or use threads when its concurrency backend is `:fiber`.
+
+The blocking pool allows two operations at a time by default. Applications
+that observe calls waiting for a pool worker can increase its process-wide
+capacity during startup, before any call can start the pool:
+
+```ruby
+LittleGhost.configure do |config|
+  config.blocking_pool_capacity 4
+end
+```
+
+Increasing this value permits more operating-system threads. It does not
+change Tool, Workflow, Graph, or subagent concurrency. The value is
+process-wide; every `Configuration` reads and writes the same setting.
+
+### Protect state shared by concurrent calls
+
+LittleGhost may call a shared Tool, provider, SessionStore, hook, or callback
+from different threads. Fibers can also take turns entering the same object on
+one thread. Protect shared mutable state, keep lock scope narrow, and do not
+call application callbacks while holding a lock.
+
+Pass request-specific values through the Invocation context or another explicit
+argument. Do not use `thread_variable_set` for request state because every
+fiber on the thread shares those values. `Thread.current[:key]` is fiber-local,
+but LittleGhost does not copy application-defined entries into each worker
+task.
+
 ## Preserve conversation with Sessions
 
 A **Session** lets one request continue an earlier conversation. Pass the same session ID and trusted actor ID with each related call:
@@ -106,7 +203,8 @@ Every Run has a session ID so LittleGhost can checkpoint its progress. If you do
 
 ## Stream or supervise long-running work
 
-`.stream_ask` runs on the caller's thread and yields `StreamEvent` values as the answer arrives:
+`.stream_ask` runs on the caller's fiber or thread and yields `StreamEvent`
+values as the answer arrives:
 
 ```ruby
 stream = CustomerSupportAgent.stream_ask(question)
@@ -138,7 +236,13 @@ execution.wait(deadline: Time.now + 30)
 execution.run.completed?
 ```
 
-The event block runs on the worker thread, so keep it quick. Cancellation, deadlines, and `close` ask the work to stop; they cannot forcibly end arbitrary provider or tool code. They also cannot undo actions that already happened.
+The event block runs on the same fiber or thread as the Execution. With `:auto`,
+`start_execution` uses a fiber when its caller is already in a scheduled fiber;
+otherwise, it uses a worker thread. Keep the block quick because it slows event
+delivery while it runs. Cancellation, deadlines, and `close` ask the work to
+stop; they cannot forcibly end arbitrary provider or Tool code or undo actions
+that already happened. Keep the application's scheduler running until an
+Execution using it finishes or closes.
 
 ## Keep Tool permission checks in application code
 
@@ -239,14 +343,17 @@ agent = CustomerSupportAgent.new(runtime: runtime)
 An explicit Runtime has its own independent configuration. It does not replace
 LittleGhost's shared default.
 
-One Runtime can serve independent calls from several threads. Each call gets
-its own Run, participants, Tools, and Runtime-created Workspace and Sandbox. An
-Agent or Assembly already bound to an active Run must stay with that Run.
+One Runtime can serve independent calls from several threads and fibers. Each
+call gets its own Run, participants, Tools, and Runtime-created Workspace and
+Sandbox. An Agent or Assembly already bound to an active Run must stay with
+that Run.
 
 Within one SessionStore instance, LittleGhost serializes calls sharing a
 Session. Multi-process deployments need coordination from their store. Custom
-stores and other shared extension objects may receive concurrent calls and
-must be thread-safe.
+stores and other shared extension objects may receive concurrent calls. Calls
+can overlap on different threads, or fibers can take turns entering the same
+object on one thread. Protect shared mutable state without relying on thread
+identity.
 
 Runtime has no shutdown step. Shared services supplied by the application keep their own lifecycle. Shut those services down with the rest of your application. If you installed process-wide instrumentation subscribers, flush or shut down `LittleGhost::Instrumentation` during application shutdown.
 

data/docs/guides/tools.md

@@ -220,6 +220,32 @@ class UpdateDraftTool < LittleGhost::Tool
 end
 ```
 
+When LittleGhost selects the fiber backend, concurrent Tool calls can run as
+fibers on one thread. If a Tool calls a library that blocks that thread, every
+other fiber on it must wait too. Suppose the help center lookup later moves to
+a client whose `lookup` method is documented to behave this way. Change only
+the Tool method:
+
+```ruby
+def call(input)
+  LittleGhost.offload_blocking do
+    HelpCenterClient.lookup(input.fetch("topic"))
+  end
+end
+```
+
+Many Ruby I/O calls already let the scheduler run other fibers. Keep those
+calls unchanged. Use `offload_blocking` only when documentation or measurement
+shows that the exact call pauses other fibers and the work can continue on
+another Ruby thread. Configure the call's own timeout or cancellation when it
+provides one.
+
+If most of a Tool's implementation blocks, configure LittleGhost to use the
+`:thread` backend instead of wrapping each call. `exclusive true` prevents
+overlap with another exclusive Tool; it does not change where the Tool runs.
+[Running in Production](production.md#use-an-existing-fiber-scheduler) explains
+the concurrency settings and when to adjust the shared thread pool.
+
 Retries can repeat a Tool call. Prefer read-only operations, idempotency keys,
 or writes that are safe to apply more than once. Do not rely on the prompt to
 prevent duplicate side effects.

data/lib/little_ghost/agent.rb

@@ -547,7 +547,7 @@ module LittleGhost
       template_resolver: nil,
       template_paths: [],
       run: nil,
-      executor: Support::Executor.new,
+      executor: nil,
       delegation_activity: nil,
       agent_path: Subagents::AgentPath::ROOT,
       max_turns: 100,
@@ -591,7 +591,7 @@ module LittleGhost
       )
       @model_settings = model_settings.to_h.freeze
       @template_resolver = template_resolver || default_template_resolver(template_paths)
-      @executor = executor
+      @executor = executor || Support::Executor.new(runner: task_runner)
       @delegation_activity = delegation_activity
       @agent_path = Subagents::AgentPath.validate!(agent_path)
       @max_turns = Integer(max_turns)
@@ -609,8 +609,8 @@ module LittleGhost
       raise ArgumentError, "max_turns must be at least 1" if @max_turns < 1
       raise ArgumentError, "max_tool_calls must be at least 1" if @max_tool_calls < 1
       raise ArgumentError, "max_tool_result_tokens must be at least 1" if @max_tool_result_tokens < 1
-      @artifact_lifecycle = if runtime&.respond_to?(:runtime_hooks)
-        runtime.runtime_hooks.find { |hook| hook.is_a?(Runtime::Hooks::Artifacts) }
+      @artifact_lifecycle = @runtime&.then do |resolved_runtime|
+        resolved_runtime.runtime_hooks.find { |hook| hook.is_a?(Runtime::Hooks::Artifacts) }
       end
       apply_cancellation_decision!(run_callbacks(:after_initialize, self))
     rescue
@@ -2126,7 +2126,7 @@ module LittleGhost
       declaration = self.class.code_mode_configuration
       return unless declaration
 
-      defaults = @runtime.respond_to?(:code_mode_configuration) ? @runtime.code_mode_configuration : nil
+      defaults = @runtime&.code_mode_configuration
       @code_mode_declaration = (defaults || {}).merge(declaration).transform_keys(&:to_sym).freeze
       unknown = @code_mode_declaration.keys - %i[engine except sandbox limits]
       raise ConfigurationError, "Unknown code-mode option: #{unknown.first.inspect}" unless unknown.empty?

data/lib/little_ghost/assembly.rb

@@ -155,8 +155,8 @@ module LittleGhost
     def initialize(run: nil, runtime: nil, workspace: nil, sandbox: nil, standalone: run.nil?) # :nodoc:
       @run = run
       @runtime = runtime || run&.runtime || LittleGhost.runtime
-      @workspace = workspace || (run.workspace if run&.respond_to?(:workspace))
-      @sandbox = sandbox || (run.sandbox if run&.respond_to?(:sandbox))
+      @workspace = workspace || run&.workspace
+      @sandbox = sandbox || run&.sandbox
       @standalone = standalone
       @assembly_mutex = Mutex.new
       @assembly_closed = false
@@ -187,7 +187,7 @@ module LittleGhost
       runtime.build_run(payload, **options)
     end
 
-    # Starts +payload+ on a supervised worker and returns an Execution.
+    # Starts +payload+ in the background and returns an Execution.
     # Composite assemblies include contextual +:agent_stream+ events in the
     # consumer by default. Set +include_agent_events+ to +false+ in +payload+
     # to keep only the ordinary public stream.
@@ -341,6 +341,10 @@ module LittleGhost
 
     def standalone? = @standalone # :nodoc:
 
+    def task_runner # :nodoc:
+      @task_runner ||= runtime ? runtime.task_runner : Support::TaskRunner.new
+    end
+
     def with_active_assembly(assembly) # :nodoc:
       @assembly_mutex.synchronize do
         raise Error, "assembly is already closed" if @assembly_closed
@@ -373,14 +377,8 @@ module LittleGhost
     end
 
     def build_tool_assembly
-      builder = runtime.method(:build_assembly)
-      accepts_path = builder.parameters.any? do |kind, name|
-        kind == :keyrest || (%i[key keyreq].include?(kind) && name == :agent_stream_path)
-      end
-      options = {run:}
-      options[:agent_stream_path] = agent_stream_path if accepts_path
-      child = builder.call(self.class, **options)
-      child.bind_agent_stream_path(agent_stream_path) if child.respond_to?(:bind_agent_stream_path)
+      child = runtime.build_assembly(self.class, run:, agent_stream_path:)
+      child.bind_agent_stream_path(agent_stream_path)
       child
     end
 

data/lib/little_ghost/assembly_execution.rb

@@ -206,7 +206,7 @@ module LittleGhost
       (policy.fetch(:retries) + 1).times do |index|
         attempt_number = index + 1
         started_at = Time.now
-        child = if build_options.any? && runtime.respond_to?(:build_agent)
+        child = if build_options.any?
           build_stream_participant(:build_agent, reference, stream_path, **build_options)
         else
           build_stream_participant(:build_assembly, reference, stream_path, **build_options)
@@ -254,8 +254,8 @@ module LittleGhost
             predecessor_ids:,
             branch_id:,
             participant:,
-            assembly_id: child.class.respond_to?(:assembly_id) ? child.class.assembly_id : participant,
-            assembly_kind: child.class.respond_to?(:assembly_kind) ? child.class.assembly_kind : :assembly,
+            assembly_id: child.class.assembly_id,
+            assembly_kind: child.class.assembly_kind,
             status: :completed,
             attempts:,
             usage:,
@@ -339,14 +339,8 @@ module LittleGhost
     end
 
     def build_stream_participant(builder_name, reference, stream_path, **options)
-      builder = runtime.method(builder_name)
-      parameters = builder.parameters
-      accepts_path = parameters.any? do |kind, name|
-        kind == :keyrest || (%i[key keyreq].include?(kind) && name == :agent_stream_path)
-      end
-      options[:agent_stream_path] = stream_path if accepts_path
-      child = builder.call(reference, run:, **options)
-      child.bind_agent_stream_path(stream_path) if child.respond_to?(:bind_agent_stream_path)
+      child = runtime.public_send(builder_name, reference, run:, agent_stream_path: stream_path, **options)
+      child.bind_agent_stream_path(stream_path)
       child
     end
 
@@ -420,11 +414,11 @@ module LittleGhost
       error.instance_variable_set(:@little_ghost_step_usage, usage)
       error.instance_variable_set(
         :@little_ghost_step_assembly_id,
-        child.class.respond_to?(:assembly_id) ? child.class.assembly_id : participant.to_s
+        child.class.assembly_id
       )
       error.instance_variable_set(
         :@little_ghost_step_assembly_kind,
-        child.class.respond_to?(:assembly_kind) ? child.class.assembly_kind : :assembly
+        child.class.assembly_kind
       )
     end
 
@@ -539,10 +533,7 @@ module LittleGhost
     def enqueue_assembly_event(queue, value, cancellation_token)
       loop do
         cancellation_token.raise_if_cancelled!
-        queue.push(value, true)
-        return
-      rescue ThreadError
-        cancellation_token.wait(0.01)
+        return if queue.push(value, timeout: 0.01)
       end
     end
 

data/lib/little_ghost/code_mode/broker.rb

@@ -14,6 +14,8 @@ module LittleGhost
       def initialize(agent: nil, registry: nil, context: RunContext.new, events: [],
         parent_operation_id: nil, parent_trace_context: nil, except: nil, dispatch: nil, max_calls: nil)
         @agent = agent
+        runtime = agent&.runtime
+        @task_runner = runtime ? runtime.task_runner : Support::TaskRunner.new
         @registry = registry || agent&.tool_registry
         @context = context
         @events = events
@@ -45,6 +47,8 @@ module LittleGhost
 
       attr_writer :context # :nodoc:
 
+      attr_reader :task_runner # :nodoc:
+
       def bind(context:, events:, parent_operation_id:, parent_trace_context: nil) # :nodoc:
         @context = context
         @events = events

data/lib/little_ghost/code_mode/javascript/session.rb

@@ -14,11 +14,12 @@ module LittleGhost
 
       ToolCall = Data.define(:program_id, :call_id, :name, :arguments)
       ToolBatch = Data.define(:calls)
-      Deadline = Struct.new(:thread, :cancelled, :expiring, :finished, :error)
+      Deadline = Struct.new(:task, :cancelled, :expiring, :finished, :error)
 
       def initialize(broker:, client:, sandbox: nil, workspace: nil, max_concurrency: 8,
         wall_seconds: 3_600, observation_seconds: OBSERVATION_SECONDS, cleanup_timeout: CLEANUP_TIMEOUT)
         @broker = broker
+        @task_runner = broker.task_runner
         @client = client
         @sandbox = sandbox
         @workspace = workspace
@@ -82,8 +83,12 @@ module LittleGhost
         begin
           @client.close_owner(self)
           wait_for_dispatches(program_ids)
-          unless !worker || worker.join(@cleanup_timeout)
-            raise LittleGhost::CleanupError, "Code-mode dispatch worker cleanup timed out"
+          if worker
+            begin
+              worker.wait(deadline: Time.now + @cleanup_timeout)
+            rescue LittleGhost::DeadlineExceededError
+              raise LittleGhost::CleanupError, "Code-mode dispatch worker cleanup timed out"
+            end
           end
         ensure
           @client.close
@@ -126,6 +131,7 @@ module LittleGhost
           @frames[program_id] = javascript_catalog
           @current_program_id = program_id
         end
+        ensure_worker if @task_runner.uses_current_scheduler?
         @client.start_program(
           owner: self, dispatcher: self, source:, tools: javascript_catalog.host_definitions, program_id:
         )
@@ -264,8 +270,7 @@ module LittleGhost
       def ensure_worker
         return if @worker&.alive?
 
-        @worker = Thread.new { dispatch }
-        @worker.report_on_exception = false
+        @worker = @task_runner.spawn { dispatch }
       end
 
       def drain_dispatch_queue
@@ -317,17 +322,12 @@ module LittleGhost
           invalid.each { |call| reject(call, "Unknown or invalid code-mode tool call: #{call.name}") }
           next if valid.empty?
 
-          results = valid.each_slice(@max_concurrency).flat_map do |slice|
-            threads = slice.map do |call|
-              Thread.new do
-                definition = catalog.fetch(call.name)
-                @broker.call(
-                  definition.fetch("canonical_name"), call.arguments,
-                  id: "code-mode-#{call.program_id}-#{call.call_id}"
-                )
-              end.tap { |thread| thread.report_on_exception = false }
-            end
-            threads.map(&:value)
+          results = Support::Executor.new(max_concurrency: @max_concurrency, runner: @task_runner).map(valid) do |call|
+            definition = catalog.fetch(call.name)
+            @broker.call(
+              definition.fetch("canonical_name"), call.arguments,
+              id: "code-mode-#{call.program_id}-#{call.call_id}"
+            )
           end
           valid.zip(results).each do |call, result|
             if result.error.nil?
@@ -455,7 +455,7 @@ module LittleGhost
         state = Deadline.new(nil, false, false, false, nil)
         @deadline_mutex.synchronize do
           @deadlines[program_id] = state
-          state.thread = Thread.new do
+          state.task = @task_runner.spawn do
             expired = @deadline_mutex.synchronize do
               loop do
                 break false if state.cancelled
@@ -470,7 +470,6 @@ module LittleGhost
           rescue => error
             finish_deadline(program_id, state, error)
           end
-          state.thread.report_on_exception = false
         end
       end
 
@@ -509,7 +508,7 @@ module LittleGhost
       end
 
       def cancel_deadline(program_id)
-        thread = @deadline_mutex.synchronize do
+        task = @deadline_mutex.synchronize do
           state = @deadlines[program_id]
           return unless state
 
@@ -520,9 +519,9 @@ module LittleGhost
             @deadline_condition.broadcast
           end
           @deadlines.delete(program_id)
-          state.thread
+          state.task
         end
-        thread&.join unless thread.equal?(Thread.current)
+        task&.wait unless task&.current?
       end
 
       def cancel_all_deadlines
@@ -541,12 +540,12 @@ module LittleGhost
       end
 
       def raise_pending_deadline_error!
-        error, thread = @deadline_mutex.synchronize do
+        error, task = @deadline_mutex.synchronize do
           pair = @pending_deadline_errors.shift
           state = @deadlines.delete(pair&.first)
-          [pair&.last, state&.thread]
+          [pair&.last, state&.task]
         end
-        thread&.join unless thread.equal?(Thread.current)
+        task&.wait unless task&.current?
         raise error if error
       end
 

data/lib/little_ghost/code_mode/ruby/session.rb

@@ -14,6 +14,7 @@ module LittleGhost
 
         def initialize(broker:, sandbox_factory:, subprocess_policy:, limits:, observation_seconds: OBSERVATION_SECONDS)
           @broker = broker
+          @task_runner = broker.task_runner
           @sandbox_factory = sandbox_factory
           @subprocess_policy = subprocess_policy
           @limits = limits
@@ -28,7 +29,7 @@ module LittleGhost
           @control_mutex = Mutex.new
           @programs = 0
           @call_mutex = Mutex.new
-          @call_threads = []
+          @call_tasks = []
           @call_errors = []
           @closing_marker = {closing: false}
           @lifecycle_mutex = Mutex.new
@@ -268,20 +269,18 @@ module LittleGhost
         end
 
         def dispatch_call(message, process)
-          thread = @call_mutex.synchronize do
-            active = @call_threads.count(&:alive?)
+          @call_mutex.synchronize do
+            active = @call_tasks.count(&:alive?)
             raise ProtocolError, "code-mode concurrent tool call limit exceeded" if active >= @limits.fetch(:concurrency)
 
             call_errors = @call_errors
             closing_marker = @closing_marker
-            Thread.new do
+            @call_tasks << @task_runner.spawn do
               answer_call(message, process, closing_marker)
             rescue => error
               @call_mutex.synchronize { call_errors << error }
             end
           end
-          thread.report_on_exception = false
-          @call_mutex.synchronize { @call_threads << thread }
         end
 
         def append_output(value)
@@ -342,14 +341,14 @@ module LittleGhost
           end
           target, session, sandbox, workspace, directory = claimed
           watchdog = cancel_watchdog(target)
-          threads, call_errors = @call_mutex.synchronize do
-            current_threads = @call_threads
+          tasks, call_errors = @call_mutex.synchronize do
+            current_tasks = @call_tasks
             current_errors = @call_errors
             @closing_marker[:closing] = true
-            @call_threads = []
+            @call_tasks = []
             @call_errors = []
             @closing_marker = {closing: false}
-            [current_threads, current_errors]
+            [current_tasks, current_errors]
           end
           first_error = nil
           begin
@@ -358,17 +357,19 @@ module LittleGhost
             first_error ||= error
           end
           deadline = monotonic_time + @limits.fetch(:cleanup_seconds)
-          threads.each do |thread|
+          tasks.each do |task|
             remaining = deadline - monotonic_time
             break unless remaining.positive?
 
             begin
-              thread.join(remaining)
+              task.wait(deadline: Time.now + remaining)
+            rescue DeadlineExceededError
+              break
             rescue => error
               first_error ||= error
             end
           end
-          if threads.any?(&:alive?)
+          if tasks.any?(&:alive?)
             @closed = true
             first_error ||= CleanupError.new("Code-mode nested tool cleanup timed out")
           end
@@ -389,14 +390,14 @@ module LittleGhost
           rescue => error
             first_error ||= error
           end
-          watchdog&.join unless watchdog.equal?(Thread.current)
+          watchdog&.wait unless watchdog&.current?
           raise first_error if first_error
         end
 
         def start_watchdog(generation, deadline)
           @watchdog_mutex.synchronize do
             @watchdog_generation = generation
-            @watchdog = Thread.new do
+            @watchdog = @task_runner.spawn do
               expired = @watchdog_mutex.synchronize do
                 loop do
                   break false unless @watchdog_generation.equal?(generation)
@@ -411,7 +412,6 @@ module LittleGhost
             rescue => error
               record_program_error(generation, error)
             end
-            @watchdog.report_on_exception = false
           end
         end
 
@@ -419,11 +419,11 @@ module LittleGhost
           @watchdog_mutex.synchronize do
             return unless !generation || @watchdog_generation.equal?(generation)
 
-            thread = @watchdog
+            task = @watchdog
             @watchdog_generation = nil
             @watchdog = nil
             @watchdog_condition.broadcast
-            thread
+            task
           end
         end