Struct SubagentRegistry 

pub struct SubagentRegistry { /* private fields */ }

Implementations

impl SubagentRegistry

pub fn reload_carry( &self, undelivered_wakes: &HashSet<String>, ) -> Vec<CarriedWorker>

Every worker this registry knows, for a daemon reload: live handles (stopped by the checkpoint beforehand) and reaped ids with an archive. Collected handles and reaped ids only carry their archive path, so a later subagent_resume/subagent_collect by the old id still works. undelivered_wakes: handle ids whose completion event is still queued.

pub fn adopt_carried(&mut self, worker: &CarriedWorker)

Re-register a worker carried over a daemon reload: its id resolves to its archive (subagent_status/collect/resume). Never shadows a live handle.

pub fn note_reload_wake(&mut self, worker: &CarriedWorker)

This image posted the parent’s wake for a carried worker (AdoptWorkers): see Self::reload_carry.

pub fn rewake_after_failed_exec( &self, carried: Vec<CarriedWorker>, ) -> Vec<CarriedWorker>

A reload that did not exec: what of its record still owes the parent a wake in THIS image. Only the workers the reload stopped — their finalizers withheld the completion wake, expecting the next image to post one. A completion it carried as wake_lost is still queued here (or still coming from its finalizer), and a reload wake an earlier image posted is still queued too: re-posting either would wake the parent twice. Everything else keeps its record, wake off.

pub fn was_stopped_by_reload(&self, id: &str) -> bool

Whether a daemon reload (not the user) stopped id’s run.

pub fn lift_reload_fence(&mut self)

The reload did not exec: launches work again, under the launch fence that was there before the reload (a revoked driver’s stays). A no-op without a reload fence.

pub fn stop_for_reload(&mut self) -> Vec<(String, Arc<RwLock<SubagentState>>)>

Stop every running worker for a daemon reload: cancel it, flagged so the carried record and the next image say “stopped by reload”, not “cancelled by user”. Returns every worker whose finalizer has not settled, to await before the exec: the ones stopped here, one whose user cancel is already in flight, and one finishing on its own (its completion wake must reach the queue the reload carries).

Installs the reload fence (idempotent): a worker registered from now until Self::lift_reload_fence is stopped at birth, flagged the same way. Call again after the turn cancel to collect those too.

impl SubagentRegistry

pub fn new() -> SubagentRegistry

pub fn watch_page(&mut self, id: &str, since: u64) -> Option<WatchPage>

One page of worker id’s watch journal (SessionQuery::SubagentWatch): live or recently reaped (until FINISHED_HANDLE_TTL after it finished). None for an unknown or expired worker.

pub fn begin_turn(&mut self) -> u64

A foreground turn is starting: advance the generation that new registrations are stamped with, and return it so the caller can later cancel exactly this turn’s workers.

pub fn cancel_running(&mut self, scope: WorkerCancelScope) -> Vec<String>

Cancel running workers in scope; returns the newly cancelled handle ids (sorted, for stable reporting). Finished handles, and handles whose cancel is already in flight, are not touched.

pub fn archive_path(&self, id: &str) -> Option<PathBuf>

Resume archive of id, whether its handle is still live or was reaped.

pub fn register(&mut self, handle: SubagentHandle) -> String

Register a handle and return its id.

pub fn register_with_cancellation( &mut self, handle: SubagentHandle, origin: Option<&CancellationToken>, ) -> String

pub fn set_spawn_cancellation( &mut self, cancel: Option<CancellationToken>, ) -> u64

Frontend-owned launch fence. Model tools cannot clear or replace it.

pub fn cancel_spawn_epoch(&mut self, epoch: u64)

A stale deadline/Drop must not cancel workers belonging to newer work.

pub fn get(&self, id: &str) -> Option<&SubagentHandle>

pub fn get_mut(&mut self, id: &str) -> Option<&mut SubagentHandle>

pub fn remove(&mut self, id: &str) -> Option<SubagentHandle>

pub fn release_finished_resources(&mut self, id: &str)

Drop finished execution transports and resumable context while retaining bounded terminal diagnostics and output under normal session retention.

pub fn holds_park(&self) -> bool

Whether parking the session now would cost a worker. Parking drops this registry: a running worker’s handle takes its shutdown channel with it (the worker is killed and reads as a truncated completion), and a finished one’s result is no longer collectable by id. So: any worker still running, or one that finished on its own within FINISHED_HANDLE_TTL (the registry’s own retention) and whose result the parent has not collected yet. A cancelled worker owes no result.

pub fn list_active(&self) -> Vec<(String, String, SubagentStatus)>

Returns (id, agent_name, status) for every tracked handle.

pub fn display_rows(&self) -> Vec<SubagentDisplayRow>

Snapshot of every tracked handle for TUI reconcile. Reads all state under the lock POISON-SAFE; exposes cancel_requested which list_active() does not.

pub fn iter_mut_handles(&mut self) -> impl Iterator<Item = &mut SubagentHandle>

Drop handles that are no longer running. Iterate over all handles mutably (for bulk operations like cancel-all).

pub fn cleanup_finished_with_ttl(&mut self, ttl: Duration)

Reap a finished handle iff: (a) its result was collected via subagent_collect, OR (b) it has been finished longer than ttl (abandoned). Finished-but-uncollected handles inside the TTL are RETAINED so the completion event can wake the parent and collect still succeeds.

Additionally, handles whose OS thread is still running (e.g. still in the finalizer path) are deferred — joining a live thread blocks the TUI loop. They will be reaped on the next cleanup pass once the thread exits. Orchestration-required expired handles become bounded tombstones instead of being removed; a later collect/reconcile makes them normally reapable.

pub fn cleanup_finished_with_ttl_and_retention( &mut self, ttl: Duration, retain_unreconciled: impl Fn(&str) -> bool, )

Reap normally, except that an expired uncollected handle still required by orchestration is downgraded to a bounded, collectible tombstone.

pub fn cleanup_finished(&mut self)

Reap finished handles using the production TTL. Finished-but-uncollected handles within the TTL window are retained.

Trait Implementations

impl Default for SubagentRegistry

fn default() -> SubagentRegistry

Returns the “default value” for a type.