GameCult/Huginn
Watch
9
0
Fork
You've already forked Huginn
 0
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity Actions
Huginn/crates/mind-body/tests/public_surface.txt
Meta Vens aa64049255 A Persona session's first line carries her whole machine; every later line only what is new 
Told, one per process in PersonaInbox, is the one owner of what this session has been told. Every
render still selects the whole machine; it prints what Told lacks. Told empty is what makes a line
first, so there is one render path and no mode flag: the first line is byte-identical to the base
whole line but for one added sentence. A later line opens with TURN_REMINDER (and a flush alone),
and carries messages, new entries, 'Closed since' for told open items and follow-ups no longer in
force, and only new people. Keys are ids, never rendered lines. Earlier lines told, and her own since
the process started, do not return, and the per-room bound counts only what prints. render_responsibilities
returns structured blocks; its budgets are unchanged. recall::select and fill do not read Told.

Cut tell-delta, commit 3.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 17:40:41 +01:00

284 lines
25 KiB
Text
Raw Blame History

mind_body: mod chat_client
mind_body: mod chat_rudp
mind_body: mod cli
mind_body: mod connector
mind_body: mod control
mind_body: mod heartbeat
mind_body: mod launch
mind_body: mod lease_client
mind_body: mod persona
mind_body: mod queue
mind_body: mod self_run
mind_body: mod tempo
mind_body::chat_client: # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum Refusal { Brake , PersonaMismatch , UnknownRoom , EmptyText , SendFailed , UnknownPersona , }
mind_body::chat_client: const ACK : & str
mind_body::chat_client: const PENDING : & str
mind_body::chat_client: const PENDING_REQUEST : & str
mind_body::chat_client: const REFUSAL : & str
mind_body::chat_client: const SEND_RECEIPT : & str
mind_body::chat_client: const SEND_REQUEST : & str
mind_body::chat_client: fn decode < T : DeserializeOwned > (bytes : & [u8]) -> Result < T >
mind_body::chat_client: fn encode < T : Serialize > (document : & T) -> Result < Vec < u8 > >
mind_body::chat_client: impl Refusal
mind_body::chat_client: impl Refusal: fn name (self) -> & 'static str
mind_body::chat_client: impl Serialize for Refusal
mind_body::chat_client: impl< 'de > Deserialize < 'de > for Refusal
mind_body::chat_client: pub trait Chat { fn pending (& self , after_seq : u64) -> Result < Vec < ChatDelivery > > ; fn send (& self , request : & ChatSendRequest) -> Result < ChatSendReceipt > ; fn ack (& self , through_seq : u64) -> Result < () > ; }
mind_body::chat_client: struct ChatAck # [derive (Clone , Debug , PartialEq , Eq , Serialize , Deserialize)] pub-fields[persona: String, through_seq: u64]
mind_body::chat_client: struct ChatDelivery # [derive (Clone , Debug , PartialEq , Eq , Serialize , Deserialize)] pub-fields[seq: u64, room_alias: String, room_id: String, event_id: String, sender: String, sender_display: String, text: String, at_unix_ms: u64, context: Vec < ContextLine >, mentions: Vec < String >, is_direct: bool]
mind_body::chat_client: struct ChatPending # [derive (Clone , Debug , PartialEq , Eq , Serialize , Deserialize)] pub-fields[persona: String, deliveries: Vec < ChatDelivery >]
mind_body::chat_client: struct ChatPendingRequest # [derive (Clone , Debug , PartialEq , Eq , Serialize , Deserialize)] pub-fields[persona: String, after_seq: u64]
mind_body::chat_client: struct ChatRefusal # [derive (Clone , Debug , PartialEq , Eq , Serialize , Deserialize)] pub-fields[persona: String, refusal: Refusal]
mind_body::chat_client: struct ChatSendReceipt # [derive (Clone , Debug , PartialEq , Eq , Serialize , Deserialize)] pub-fields[request_id: String, event_id: Option < String >, refusal: Option < String >]
mind_body::chat_client: struct ChatSendRequest # [derive (Clone , Debug , PartialEq , Eq , Serialize , Deserialize)] pub-fields[request_id: String, persona: String, room_alias: String, text: String]
mind_body::chat_client: struct ContextLine # [derive (Clone , Debug , PartialEq , Eq , Serialize , Deserialize)] pub-fields[sender: String, text: String, at_unix_ms: u64]
mind_body::chat_rudp: fn connection_id (key_file_text : & str) -> u32
mind_body::chat_rudp: impl Chat for RudpChat
mind_body::chat_rudp: impl Drop for RudpChat
mind_body::chat_rudp: impl RudpChat
mind_body::chat_rudp: impl RudpChat: fn new (remote : SocketAddr , connection_id : u32 , persona : impl Into < String > , reply_timeout : Duration) -> Self
mind_body::chat_rudp: struct RudpChat pub-fields[]
mind_body::cli: fn instance_and_endpoint (args : & [String] , env_endpoint : Option < String > , usage : & str) -> Result < (Slug , SocketAddr) >
mind_body::cli: fn operator_name (sudo_user : Option < String > , user : Option < String >) -> String
mind_body::cli: fn run (args : & [String] , root : & Path , set_by : & str , now : DateTime < Utc > , out : & mut impl Write , stop_units : & mut dyn FnMut (StopScope < '_ >) -> Result < () > ,) -> Result < () >
mind_body::connector: fn render_plan (windows : & [PlanQuota] , now_ms : u64) -> String
mind_body::control: # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum HeldReason { BrakeAbsent , BrakeHeld , Undecodable , }
mind_body::control: # [derive (Debug , PartialEq , Eq)] pub enum Effective { Held { reason : HeldReason } , Released (Grant) , }
mind_body::control: # [derive (Debug , PartialEq , Eq)] pub enum SwarmEffective { Held (HeldReason) , Released , }
mind_body::control: const BRAKE_KEY : & str
mind_body::control: const CONTROL_ROOT : & str
mind_body::control: const SWARM_FILE : & str
mind_body::control: fn control_path (root : & Path , instance : & Slug) -> Result < PathBuf >
mind_body::control: fn load_state (source : & impl ControlSource) -> Result < ControlState >
mind_body::control: fn load_swarm_state (source : & impl ControlSource) -> Result < SwarmState >
mind_body::control: fn read_effective (instance : & Slug) -> Effective
mind_body::control: fn read_envelope () -> SwarmEffective
mind_body::control: fn swarm_path (root : & Path) -> PathBuf
mind_body::control: impl ControlSource for FileSource
mind_body::control: impl ControlState
mind_body::control: impl ControlWriter
mind_body::control: impl ControlWriter: fn open (path : impl Into < PathBuf >) -> Result < Self >
mind_body::control: impl ControlWriter: fn set_brake (& mut self , released : bool , set_at : DateTime < Utc > , set_by : & str) -> Result < () >
mind_body::control: impl FileSource
mind_body::control: impl FileSource: fn new (path : impl Into < PathBuf >) -> Self
mind_body::control: impl Grant
mind_body::control: impl Grant: fn instance (& self) -> & Slug
mind_body::control: impl SwarmState
mind_body::control: impl SwarmWriter
mind_body::control: impl SwarmWriter: fn open (path : impl Into < PathBuf >) -> Result < Self >
mind_body::control: impl SwarmWriter: fn set_brake (& mut self , released : bool , set_at : DateTime < Utc > , set_by : & str) -> Result < () >
mind_body::control: impl std :: error :: Error for UnsafeStore
mind_body::control: impl std :: fmt :: Display for UnsafeStore
mind_body::control: pub trait ControlSource { fn snapshot (& self) -> Result < Vec < CultCacheEnvelope > > ; }
mind_body::control: struct Brake # [derive (Clone , Debug , PartialEq , Eq , DatabaseEntry)] pub-fields[released: bool, set_at: DateTime < Utc >, set_by: String]
mind_body::control: struct ControlState # [derive (Clone , Debug , PartialEq , Eq , Default)] pub-fields[brake: Option < Brake >]
mind_body::control: struct ControlWriter pub-fields[]
mind_body::control: struct FileSource pub-fields[]
mind_body::control: struct Grant # [derive (Debug , PartialEq , Eq)] pub-fields[]
mind_body::control: struct SwarmState # [derive (Clone , Debug , PartialEq , Eq , Default)] pub-fields[brake: Option < Brake >]
mind_body::control: struct SwarmWriter pub-fields[]
mind_body::control: struct UnsafeStore # [derive (Debug)] pub-fields[path: PathBuf, mode: u32, uid: u32]
mind_body::heartbeat: # [derive (Clone , Debug , PartialEq , Eq)] pub enum Outcome { Held (HeldReason) , Polled { launched : Vec < Slug > , } , }
mind_body::heartbeat: const AGENT : & str
mind_body::heartbeat: fn poll (organs : & Organs , config : & Config) -> Result < Outcome >
mind_body::heartbeat: impl Config
mind_body::heartbeat: impl Config: fn new (personas : Vec < PersonaId > , operators : Vec < String >) -> Result < Self >
mind_body::heartbeat: impl Control for FileControl
mind_body::heartbeat: impl FileStore
mind_body::heartbeat: impl FileStore: fn check (& self) -> Result < () >
mind_body::heartbeat: impl FileStore: fn new (path : impl Into < PathBuf >) -> Self
mind_body::heartbeat: impl PersonaId
mind_body::heartbeat: impl PersonaId: fn parse (spec : & str) -> Result < Self >
mind_body::heartbeat: impl Row < '_ >
mind_body::heartbeat: impl Store for FileStore
mind_body::heartbeat: impl TempoView for FileStore
mind_body::heartbeat: impl fmt :: Display for Outcome
mind_body::heartbeat: impl fmt :: Display for PollTrace
mind_body::heartbeat: pub trait Control { fn envelope (& self) -> SwarmEffective ; fn effective (& self , instance : & Slug) -> Effective ; }
mind_body::heartbeat: pub trait Store { fn load (& self) -> Result < Option < HeartbeatState > > ; fn save (& self , state : & HeartbeatState) -> Result < () > ; fn record (& self , trace : & PollTrace) -> Result < () > ; }
mind_body::heartbeat: pub trait TempoView { fn latest (& self) -> Result < Option < PollTrace > > ; }
mind_body::heartbeat: struct Config # [derive (Clone , Debug , PartialEq , Eq)] pub-fields[personas: Vec < PersonaId >, operators: Vec < String >]
mind_body::heartbeat: struct FileControl pub-fields[]
mind_body::heartbeat: struct FileStore pub-fields[]
mind_body::heartbeat: struct HeartbeatState # [derive (Clone , Debug , PartialEq , Eq , DatabaseEntry)] pub-fields[last_beat_at: DateTime < Utc >, handled_mentions: Vec < String >]
mind_body::heartbeat: struct InstanceTrace # [derive (Clone , Debug , PartialEq , Eq , serde :: Serialize , serde :: Deserialize)] pub-fields[instance: String, vote_beat_s: Option < u32 >, urgency_permille: u16, addressed: bool, busy: bool, released: bool, idle_s: i64, score: String, note: String]
mind_body::heartbeat: struct Organs< 'a > pub-fields[seats: & 'a [Seat < 'a >], control: & 'a dyn Control, launcher: & 'a dyn Launcher, clock: & 'a dyn Clock, host: & 'a str, store: & 'a dyn Store]
mind_body::heartbeat: struct PersonaId # [derive (Clone , Debug , PartialEq , Eq)] pub-fields[slug: Slug, public_name: String, handle: String, matrix_id: String, huginn: SocketAddr]
mind_body::heartbeat: struct PollTrace # [derive (Clone , Debug , PartialEq , Eq , DatabaseEntry)] pub-fields[at: DateTime < Utc >, tempo_s: u32, instances: Vec < InstanceTrace >, launches: Vec < String >]
mind_body::heartbeat: struct Seat< 'a > pub-fields[who: PersonaId, mind: & 'a dyn MindPort, chat: & 'a dyn Chat]
mind_body::launch: # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum StopScope < 'a > { Mind (& 'a Slug) , Swarm , }
mind_body::launch: # [derive (Clone , Debug , PartialEq , Eq)] pub enum Declined { Admission (MindRefusal) , Conflict , AlreadyAdmitted , StartFailed , GrantForOtherInstance , PersonaRunTakesNoClaims , }
mind_body::launch: # [derive (Clone , Debug , PartialEq , Eq)] pub enum LaunchOutcome { Launched { run : PipelineRef , } , NotQueued { item : PipelineRef , } , Tripped { run : PipelineRef , question : PipelineRef , } , Busy { run : PipelineRef , } , Refused (Declined) , }
mind_body::launch: const START_GRACE_S : i64
mind_body::launch: fn open_and_launch (ports : & Ports , request : LaunchRequest) -> Result < LaunchOutcome >
mind_body::launch: fn run_label (now : DateTime < Utc >) -> Label
mind_body::launch: impl Clock for SystemClock
mind_body::launch: impl Default for SystemdLauncher
mind_body::launch: impl Launcher for SystemdLauncher
mind_body::launch: impl Systemctl for RealSystemctl
mind_body::launch: impl SystemdLauncher
mind_body::launch: impl SystemdLauncher: fn new () -> Self
mind_body::launch: impl SystemdLauncher: fn stop (& self , scope : StopScope < '_ >) -> Result < () >
mind_body::launch: pub trait Clock { fn now (& self) -> DateTime < Utc > ; }
mind_body::launch: pub trait Launcher { fn start (& self , instance : & Slug , turn : RunTurn) -> Result < () > ; fn alive (& self , instance : & Slug , turn : RunTurn) -> bool ; }
mind_body::launch: pub trait Systemctl { fn run (& self , args : & [& str]) -> Result < SystemctlReply > ; }
mind_body::launch: struct LaunchRequest pub-fields[turn: RunTurn, claims: Vec < PipelineRef >, agent: String, grant: Grant]
mind_body::launch: struct Ports< 'a > pub-fields[mind: & 'a dyn MindPort, launcher: & 'a dyn Launcher, clock: & 'a dyn Clock, host: & 'a str]
mind_body::launch: struct SystemClock pub-fields[]
mind_body::launch: struct SystemctlReply pub-fields[success: bool, code: Option < i32 >, stdout: String]
mind_body::launch: struct SystemdLauncher pub-fields[]
mind_body::lease_client: # [derive (Clone , Copy , Debug , PartialEq , Eq , Serialize , Deserialize)] pub enum LeaseRefusalKind { UnknownCaller , Expired , Busy , ProviderRejected , }
mind_body::lease_client: const LEASE_SOCKET_VARIABLE : & str
mind_body::lease_client: const MAX_LEASE_FRAME_BYTES : usize
mind_body::lease_client: impl Inheritable
mind_body::lease_client: impl Inheritable: fn number (& self) -> i32
mind_body::lease_client: impl Lender for SocketLender
mind_body::lease_client: impl SocketLender
mind_body::lease_client: impl SocketLender: fn new (path : impl Into < PathBuf >) -> Self
mind_body::lease_client: impl TokenFd
mind_body::lease_client: impl TokenFd: fn inheritable (& self) -> Result < Inheritable >
mind_body::lease_client: impl std :: fmt :: Debug for TokenFd
mind_body::lease_client: pub enum Lent { Granted (Box < dyn Lease >) , Refused (LeaseRefused) , }
mind_body::lease_client: pub trait Lease { fn token (& self) -> & TokenFd ; fn plan_quota (& self) -> & [PlanQuota] ; }
mind_body::lease_client: pub trait Lender { fn lend (& self , request : & LeaseRequest) -> Result < Lent > ; }
mind_body::lease_client: struct Inheritable pub-fields[]
mind_body::lease_client: struct LeaseRefused # [derive (Clone , Debug , PartialEq , Eq , Serialize , Deserialize)] pub-fields[kind: LeaseRefusalKind, detail: String]
mind_body::lease_client: struct LeaseRequest # [derive (Clone , Debug , PartialEq , Eq , Serialize , Deserialize)] pub-fields[expires_at_unix_ms: u64]
mind_body::lease_client: struct SocketLender pub-fields[]
mind_body::lease_client: struct TokenFd pub-fields[]
mind_body::lease_client::socket: impl Lease for Granted
mind_body::persona: # [derive (Clone , Copy , Debug , PartialEq , Eq , Serialize , Deserialize)] # [serde (rename_all = "lowercase")] pub enum SettleOutcome { Done , Declined , Wrong , }
mind_body::persona: # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum Failure { Held (HeldReason) , Chat , Persona , Doctrine , DoctrineTooLarge , Lease , Session , Undecodable , OutOfBounds (& 'static str) , RoomNotAllowed , Send , SelfRun , Memory , Ack , }
mind_body::persona: # [derive (Debug , PartialEq , Eq)] pub enum Outcome { Dead (HeldReason) , NoRun , Served { run : PipelineRef , answered : u32 , failure : Option < Failure > , self_run : Option < PipelineRef > } , }
mind_body::persona: const AGENT : & str
mind_body::persona: const DOCTRINE_MAX_BYTES : usize
mind_body::persona: const ENV_CONFIG_SEED : & str
mind_body::persona: const ENV_DOCTRINE : & str
mind_body::persona: const ENV_MINDS : & str
mind_body::persona: const ENV_MODEL : & str
mind_body::persona: const ENV_OPERATOR : & str
mind_body::persona: const ENV_ROOMS : & str
mind_body::persona: const ENV_RUN_CAP : & str
mind_body::persona: const ENV_SELF_SENDER : & str
mind_body::persona: const PERSONA_POLL_S : i64
mind_body::persona: const SANDBOX_DIR : & str
mind_body::persona: fn carry (organs : & Organs , control : & impl ControlSource , swarm : & impl ControlSource , config : & Config) -> Result < Outcome >
mind_body::persona: fn reply_schema (rooms : & [String] , campaigns : & [String]) -> String
mind_body::persona: impl Config
mind_body::persona: impl Config: fn from_args (args : & [String] , usage : & str) -> Result < (Self , Vec < String >) >
mind_body::persona: impl Config: fn from_args_and_env (args : & [String] , lookup : impl Fn (& str) -> Option < String > , usage : & str) -> Result < (Self , Vec < String >) >
mind_body::persona: impl Conversation
mind_body::persona: impl FileTrace
mind_body::persona: impl FileTrace: fn new (path : impl Into < PathBuf >) -> Self
mind_body::persona: impl GoalBlock
mind_body::persona: impl GoalEntry
mind_body::persona: impl HuginnPersona
mind_body::persona: impl HuginnPersona: fn new (client : HuginnClient) -> Self
mind_body::persona: impl PersonaState for HuginnPersona
mind_body::persona: impl Responsibilities
mind_body::persona: impl Sender
mind_body::persona: impl Shown
mind_body::persona: impl Told
mind_body::persona: impl Trace for FileTrace
mind_body::persona: impl Trace for Noted < '_ >
mind_body::persona: impl fmt :: Display for Failure
mind_body::persona: impl fmt :: Display for Outcome
mind_body::persona: impl< C : ControlSource , S : ControlSource > PersonaInbox < '_ , C , S >
mind_body::persona: impl< C : ControlSource , S : ControlSource > SessionInbox for PersonaInbox < '_ , C , S >
mind_body::persona: pub trait PersonaState { fn instructions (& self) -> Result < String > ; }
mind_body::persona: pub trait Trace { fn record (& self , trace : & TurnTrace) -> Result < () > ; }
mind_body::persona: pub use model_connector :: PlanQuota ;
mind_body::persona: struct Config # [derive (Clone , Debug , PartialEq , Eq)] pub-fields[rooms: Vec < String >, operators: Vec < String >, minds: Vec < String >, own_sender: String, model: String, doctrine: Vec < PathBuf >]
mind_body::persona: struct FileTrace pub-fields[]
mind_body::persona: struct HuginnPersona pub-fields[]
mind_body::persona: struct Organs< 'a > pub-fields[mind: & 'a dyn MindPort, launcher: & 'a dyn Launcher, clock: & 'a dyn Clock, host: & 'a str, chat: & 'a dyn Chat, persona: & 'a dyn PersonaState, trace: & 'a dyn Trace, tempo: Option < & 'a dyn TempoView >, lender: & 'a dyn Lender, spawner: & 'a dyn Spawner, run_cap_s: u64, sandbox: & 'a Path, scratch: & 'a Path]
mind_body::persona: struct PersonaReply # [derive (Clone , Debug , PartialEq , Eq , Serialize , Deserialize)] pub-fields[intent: String, say: Vec < Say >, start_self_run: Option < StartSelfRun >, remember: Vec < Remember >, settle: Vec < Settle >, tempo_vote_beat_s: Option < Option < u32 > >, urgency_permille: Option < u16 >]
mind_body::persona: struct Remember # [derive (Clone , Debug , PartialEq , Eq , Serialize , Deserialize)] pub-fields[sort: MemorySort, text: String, about: Vec < String >, salience_permille: u16]
mind_body::persona: struct Say # [derive (Clone , Debug , PartialEq , Eq , Serialize , Deserialize)] pub-fields[room: String, text: String]
mind_body::persona: struct Settle # [derive (Clone , Debug , PartialEq , Eq , Serialize , Deserialize)] pub-fields[item: String, outcome: SettleOutcome, why: String]
mind_body::persona: struct StartSelfRun # [derive (Clone , Debug , PartialEq , Eq , Serialize , Deserialize)] pub-fields[brief: String, repo: String, campaign: String, for_item: Option < String >]
mind_body::persona: struct TraceItem # [derive (Clone , Debug , PartialEq , Eq , Serialize , Deserialize)] pub-fields[provenance: String, room: String, text: String]
mind_body::persona: struct TurnTrace # [derive (Clone , Debug , PartialEq , Eq , DatabaseEntry)] pub-fields[run: String, turn: u32, at: DateTime < Utc >, inputs: Vec < TraceItem >, outputs: Vec < TraceItem >, outcome: String]
mind_body::queue: # [derive (Clone , Debug , PartialEq , Eq)] pub enum Breaker { Clear , Trip { run : PipelineRef } , }
mind_body::queue: const CONSECUTIVE : usize
mind_body::queue: const EMPTY_SHARE : usize
mind_body::queue: const WINDOW : usize
mind_body::queue: fn breaker (mind : & dyn MindPort , item : & PipelineRef , ending : & [PipelineRef]) -> Result < Breaker >
mind_body::queue: fn on_hold (mind : & dyn MindPort) -> Result < Held >
mind_body::queue: fn queue (mind : & dyn MindPort , instance : & Slug , ending : & [PipelineRef] , held : & Held ,) -> Result < Vec < PipelineRef > >
mind_body::queue: impl Held
mind_body::queue: impl Held: fn contains (& self , item : & PipelineRef) -> bool
mind_body::queue: impl Held: fn items (& self) -> & [PipelineRef]
mind_body::queue: impl HuginnMind < 'static >
mind_body::queue: impl HuginnMind < 'static >: fn new (client : HuginnClient) -> Self
mind_body::queue: impl MindPort for HuginnMind < '_ >
mind_body::queue: impl< 'a > HuginnMind < 'a >
mind_body::queue: pub trait MindPort { fn instance (& self) -> & Slug ; fn query (& self , selection : & Selection) -> Result < PipelineSelectionPage > ; fn query_near (& self , _selection : & Selection , _text : & str , _top_k : u32) -> Result < PipelineSelectionPage > { bail ! ("this mind port has no semantic index") } fn admit (& self , agent : & str , session : & str , documents : Vec < PipelineDocument >) -> Result < PipelineAdmissionOutcome > ; }
mind_body::queue: struct Held # [derive (Clone , Debug , PartialEq , Eq)] pub-fields[]
mind_body::queue: struct HuginnMind< 'a > pub-fields[]
mind_body::recall: impl Lane
mind_body::recall: impl Recalled
mind_body::self_run: # [derive (Clone , Copy , Debug , PartialEq , Eq , PartialOrd , Ord)] pub enum Stop { Interrupt , Terminate , Kill , }
mind_body::self_run: # [derive (Clone , Copy , Debug , PartialEq , Eq)] pub enum Cause { Own , FlushRequested , Signalled (Stop) , Unstoppable , }
mind_body::self_run: # [derive (Clone , Debug , PartialEq , Eq)] pub enum Read { Line (String) , Timeout , Eof , Exited (Option < i32 >) , }
mind_body::self_run: # [derive (Clone , Debug , PartialEq , Eq)] pub enum SelfRunOutcome { NoRun , LeaseRefused { kind : LeaseRefusalKind } , Ended { cause : Cause , code : Option < i32 > , requests : u64 , prefix : u64 } , }
mind_body::self_run: # [derive (Clone , Debug , PartialEq , Eq)] pub enum Usage { Request { id : String , prefix : u64 } , Echo , Result { ok : bool , blocked : bool } , Other , Unreadable , }
mind_body::self_run: const AGENT : & str
mind_body::self_run: const CEILING_TOKENS : u64
mind_body::self_run: const ESCALATE_AFTER_S : i64
mind_body::self_run: const EXIT_DRAIN_S : i64
mind_body::self_run: const FLUSH_GRACE_S : i64
mind_body::self_run: const FLUSH_HEADROOM_TOKENS : u64
mind_body::self_run: const FLUSH_MESSAGE : & str
mind_body::self_run: const INBOX_POLL_S : i64
mind_body::self_run: const LADDER_S : i64
mind_body::self_run: const MAX_TURNS : u32
mind_body::self_run: const ROTATE_MARGIN_S : i64
mind_body::self_run: const RUN_CAP_VARIABLE : & str
mind_body::self_run: const SCRATCH_VARIABLE : & str
mind_body::self_run: const SEED_VARIABLE : & str
mind_body::self_run: const SESSION_NAMESPACE : Uuid
mind_body::self_run: const TTL_1H_S : i64
mind_body::self_run: const TTL_5M_S : i64
mind_body::self_run: const TTL_MARGIN_S : i64
mind_body::self_run: fn carry (mind : & dyn MindPort , clock : & dyn Clock , lender : & dyn Lender , spawner : & dyn Spawner , run_cap_s : u64 , out : & mut dyn Write) -> Result < SelfRunOutcome >
mind_body::self_run: fn claude_args (session : Uuid) -> Vec < String >
mind_body::self_run: fn read_usage (line : & str) -> Usage
mind_body::self_run: fn session_id (run : & PipelineRef) -> Uuid
mind_body::self_run: fn start_message (instance : & Slug , run : & PipelineRef , plan_quota : & [PlanQuota] , now_ms : u64) -> String
mind_body::self_run: fn writes_hour_cache (line : & str) -> Option < bool >
mind_body::self_run: impl Child for ClaudeProcess
mind_body::self_run: impl ClaudeSpawner
mind_body::self_run: impl ClaudeSpawner: fn in_sandbox (unit_environment : impl IntoIterator < Item = (OsString , OsString) > , seed_variable : & str , sandbox : Option < PathBuf >) -> Result < Self >
mind_body::self_run: impl ClaudeSpawner: fn new (unit_environment : impl IntoIterator < Item = (OsString , OsString) >) -> Result < Self >
mind_body::self_run: impl Drop for FreshConfig
mind_body::self_run: impl FreshConfig
mind_body::self_run: impl Heard
mind_body::self_run: impl SelfRunOutcome
mind_body::self_run: impl SelfRunOutcome: fn exit_status (& self) -> i32
mind_body::self_run: impl SessionInbox for SelfInbox < '_ >
mind_body::self_run: impl Spawner for ClaudeSpawner
mind_body::self_run: impl Stop
mind_body::self_run: impl fmt :: Display for SeedLinkRefused
mind_body::self_run: impl fmt :: Display for SelfRunOutcome
mind_body::self_run: impl std :: error :: Error for SeedLinkRefused
mind_body::self_run: impl< 'a > SelfInbox < 'a >
mind_body::self_run: mod inbox
mind_body::self_run: pub trait Child { fn write_line (& mut self , line : & str) ; fn close_input (& mut self) ; fn next (& mut self , timeout : StdDuration) -> Read ; fn stop (& mut self , how : Stop) -> bool ; }
mind_body::self_run: pub trait Spawner { fn spawn (& self , args : & [String] , token : & TokenFd) -> Result < Box < dyn Child > > ; }
mind_body::self_run: struct ClaudeSpawner pub-fields[]
mind_body::self_run::decide: impl State
mind_body::self_run::inbox: const OWNER : & str
mind_body::self_run::inbox: fn backlog (mind : & dyn MindPort) -> Result < Vec < (Brief , String) > >
mind_body::self_run::inbox: fn derive (mind : & dyn MindPort , told : & HashSet < String >) -> Result < Vec < Brief > >
mind_body::self_run::inbox: fn derive_counting_held (mind : & dyn MindPort , holds : & Held , told : & HashSet < String >) -> Result < (Vec < Brief > , usize) >
mind_body::self_run::inbox: fn render (briefs : & [Brief] , plan : & str) -> String
mind_body::self_run::inbox: fn resolving_sentence (id : & str) -> String
mind_body::self_run::inbox: struct Brief # [derive (Clone , Debug , PartialEq , Eq)] pub-fields[id: String, campaign: String, repo: String, item: String, ordinal: u64]
mind_body::tempo: const DEFAULT_BEAT_S : u32
mind_body::tempo: const LOG_BOUND_ORDERS : f64
mind_body::tempo: fn pick (rows : & [Standing] , beat_s : u32) -> Option < usize >
mind_body::tempo: fn score (standing : & Standing , beat_s : u32) -> f64
mind_body::tempo: fn tally (votes : & [Option < u32 >]) -> u32
mind_body::tempo: fn urgency_permille (standing : & Standing) -> u16
mind_body::tempo: struct Standing # [derive (Clone , Debug , PartialEq , Eq)] pub-fields[slug: String, eligible: bool, waited_s: Option < u64 >, last_turn_ms: Option < i64 >, self_permille: u16, topic_permille: u16, addressed_by_member: bool]
Reference in a new issue View git blame Copy permalink