Struct AgentProcessRegistry 

pub struct AgentProcessRegistry {
    inner: Mutex<HashMap<String, RegistryEntry>>,
    broker: Option<Arc<Broker>>,
    config: Mutex<Option<Arc<ConfigState>>>,
}

Fields

inner: Mutex<HashMap<String, RegistryEntry>>

broker: Option<Arc<Broker>>

config: Mutex<Option<Arc<ConfigState>>>

Live settings, read per spawn so a settings.json change applies to the next agent spawn. None in tests and before bootstrap wires it.

Implementations

impl AgentProcessRegistry

pub fn new(broker: Option<Arc<Broker>>) -> Self

pub fn set_config(&self, config: Arc<ConfigState>)

Attach the live settings (bootstrap).

pub fn agent_below_normal_priority(&self) -> bool

The agent:belownormalpriority setting; true when unset or when no settings are attached.

pub fn set_below_normal_priority( &self, block_id: &str, on: bool, ) -> Result<(), String>

Apply (or lift) the below-normal priority limit on block_id’s tree.

pub fn ensure_tracker(&self, block_id: &str) -> Arc<dyn TrackerHandle>

Ensure a tracker exists for this block. Idempotent — calling twice for the same block returns the existing tracker so the job survives controller re-creation (e.g. on /clear).

pub fn ensure_tracker_kind( &self, block_id: &str, agent: bool, ) -> Arc<dyn TrackerHandle>

ensure_tracker for an agent’s block (agent) or a terminal a person types in. The kind matters on every Unix, where an agent gets a cgroup or the best-effort scan tracker (its whole tree ends with it) and a terminal keeps Unix semantics: what the user nohups outlives it.

pub fn assign_kind( &self, block_id: &str, pid: u32, agent: bool, ) -> Result<(), String>

Assign a freshly-spawned agent/shell PID to block_id’s tracker (creating it if needed) and remember it as a root. The tracker is an agent’s or a terminal’s (see ensure_tracker_kind).

pub fn adopt(&self, block_id: &str, pid: u32) -> Result<bool, String>

Add pid to block_id’s tracker if it has one, without marking it a root. Ok(false) when the block has no tracker.

pub fn remove(&self, block_id: &str)

Drop a block’s tracker — call when the pane closes. The tracker’s Drop impl kills the whole process tree (KILL_ON_JOB_CLOSE on Windows, cgroup.kill on Linux; nothing on the stub).

pub fn list_block(&self, block_id: &str) -> Vec<TrackedProcess>

Processes the agent started through its tools (see agent_started) — for the RPC endpoint, Swarm and the pane-close confirmation. Excludes the CLI itself, conhost and MCP servers; kill_tree still takes all of them.

pub fn members_by_block(&self) -> Vec<BlockMembers>

Every tracked block’s members for Tower: PIDs (plumbing included), the roots, the tracker’s confidence and the tree’s CPU account. The trackers are queried outside the registry lock.

pub fn confidence_of(&self, block_id: &str) -> TrackingConfidence

Confidence of a block’s tracker — drives the “tracking is best-effort on macOS” badge in the swarm UI.

pub fn terminate(&self, block_id: &str) -> bool

Ask everything in block_id’s tree to exit (SIGTERM on Linux), the graceful step before remove kills what’s left. false when nothing was asked (no tracker, or no graceful signal).

pub fn member_count(&self, block_id: &str) -> usize

Every process in block_id’s tree, plumbing included; 0 without a tracker.

pub fn kill_tree(&self, block_id: &str) -> bool

Kill the entire process tree for a given block. Returns true if a tracker was found (the kill was dispatched). Does NOT synchronously wait for descendants to actually exit — the poller’s next tick will pick up the state changes and emit agent:process-exited events the frontend can react to.

pub fn kill_pid(&self, block_id: &str, pid: u32) -> bool

Kill a single PID if it’s a member of the given block’s tree. Returns true if the tracker was found and the PID matched.

pub fn poll_and_emit(&self)

Poll every tracked block’s membership and diff against the last-known set. Emits agent:process-added / -exited events for each delta.

Called by a background Tokio task on a ~2s interval.