daemon

type Daemon ¶

type Daemon interface {
	Snapshot() DaemonSnapshot
	Kill(ctx context.Context) error
	Output() string
}

Daemon is the polymorphic contract every kind of background unit satisfies. Three methods, one for each concern:

• Snapshot — read state without exposing internals.
• Kill — cooperative cancellation (kind-specific: ctx cancel for bash/monitor, abort signal for agent, ...).
• Output — kind-specific formatted text for daemon_output.

Implementations live next to their owning tool: bashDaemon in pkg/tools/shell, monitorDaemon in pkg/tools/monitor, agentDaemon in internal/agent. Each implementation owns its own goroutine and calls DaemonState.Emit on lifecycle transitions / stream lines.

type DaemonKind ¶

type DaemonKind string

DaemonKind identifies the variant of one daemon. Used for ID prefix allocation, filtering in daemon_list, and rendering hints in the TUI.

New kinds plug in by adding one constant here, one metadata struct in snapshot.go, and one file implementing Daemon. Tools / drain / store do not change.

const (
	// Implemented today.
	KindLocalBash  DaemonKind = "local_bash"
	KindLocalAgent DaemonKind = "local_agent"
	KindMonitor    DaemonKind = "monitor"
	KindLSP        DaemonKind = "lsp"

	// Reserved — enum entries only, no Daemon impl yet. Listed here so the
	// ID prefix table stays exhaustive and new kinds land as one-file diffs.
	KindRemoteAgent       DaemonKind = "remote_agent"
	KindInProcessTeammate DaemonKind = "in_process_teammate"
	KindLocalWorkflow     DaemonKind = "local_workflow"
	KindDream             DaemonKind = "dream"
)

type DaemonMetadata ¶

type DaemonMetadata interface {
	// contains filtered or unexported methods
}

DaemonMetadata is the marker interface every kind-specific payload implements. Renderers (TUI strips, daemon_output, daemon_list) switch on DaemonSnapshot.Kind and type-assert to the concrete struct.

type DaemonSnapshot ¶

type DaemonSnapshot struct {
	ID          string
	Kind        DaemonKind
	Status      DaemonStatus
	Description string
	AgentID     string // spawning agent's id; used by TUI to label rows by owner
	StartedAt   time.Time
	EndedAt     time.Time // zero until terminal

	Metadata DaemonMetadata
}

DaemonSnapshot is the immutable view of one daemon's state at a point in time. Stores hand out snapshots by value so observers don't race the goroutine holding the live struct.

Metadata carries kind-specific payload; renderers type-assert it on Kind. New kinds add a struct implementing DaemonMetadata and place it on the snapshot — tools / drain / store stay untouched.

type DaemonState ¶

type DaemonState struct {
	*observable.Observable
	// contains filtered or unexported fields
}

DaemonState is the single source of truth for one agent's daemons. Replaces the previous trio of BgTaskStore, MonitorTaskStore, and SpawnGroup. Holds:

• daemons map[id]Daemon — for lookup, kill, output.
• signals []Signal — unified queue (Lifecycle + Event), drained at each agent loop iter start.

Embeds *observable.Observable so TUI strips receive per-change notifications with domain="daemons".

func NewState(notify func()) *DaemonState

func (s *DaemonState) Domain() string

func (s *DaemonState) DrainSignals() []Signal

func (s *DaemonState) Emit(sig Signal)

func (s *DaemonState) Evict(id string)

func (s *DaemonState) Get(id string) (Daemon, bool)

func (s *DaemonState) HasPending() bool

func (s *DaemonState) Len() int

func (s *DaemonState) Register(d Daemon)

func (s *DaemonState) Snapshot() []DaemonSnapshot

func (s *DaemonState) SnapshotByKind(k DaemonKind) []DaemonSnapshot

func (s *DaemonState) Stop(ctx context.Context, id string) (DaemonSnapshot, error)

type DaemonStatus ¶

type DaemonStatus string

DaemonStatus is the lifecycle state of one daemon.

Transitions:

Pending  → Running                 (rare — typically a daemon is Running on Register)
Running  → Completed               (clean exit / agent reported success)
Running  → Failed                  (non-zero exit / agent crashed)
Running  → Killed                  (daemon_stop / root ctx cancel)

Terminal statuses (Completed / Failed / Killed) trigger a Lifecycle Signal that flows into the agent loop's drain, after which the entry is evicted from DaemonState.

const (
	StatusPending   DaemonStatus = "pending"
	StatusRunning   DaemonStatus = "running"
	StatusCompleted DaemonStatus = "completed"
	StatusFailed    DaemonStatus = "failed"
	StatusKilled    DaemonStatus = "killed"
)

type Event ¶

type Event struct {
	Line    string
	Closing bool
}

Event is the variant fired per stream line by daemons that stream (monitors). Closing marks the final event before the daemon's terminal Lifecycle — drain renders it as a distinct phrasing so the model knows no more events are coming.

type LSPMeta ¶

type LSPMeta struct {
	ServerName   string
	Command      string
	State        string // "running", "starting", "error", etc.
	ExitCode     *int
	RestartCount int
	MaxRestarts  int
}

LSPMeta is the payload for KindLSP snapshots.

type Lifecycle ¶

type Lifecycle struct {
	Status DaemonStatus
}

Lifecycle is the variant fired when a daemon enters a terminal status.

type ListTool ¶

type ListTool struct {
	// contains filtered or unexported fields
}

ListTool enumerates daemons in the agent's DaemonState. Optional kind filter; by default omits terminal entries since the drain evicts them shortly after lifecycle emission.

func NewList(state *DaemonState) *ListTool

func (t *ListTool) Description() string

func (t *ListTool) Execute(_ context.Context, logger *slog.Logger, raw json.RawMessage) (tools.Result, error)

func (t *ListTool) Name() string

func (t *ListTool) Schema() json.RawMessage

type LocalAgentMeta ¶

type LocalAgentMeta struct {
	AgentType string // "general-purpose" / "explore" / "plan" / ...
	Prompt    string
	Async     bool
	Phase     string
	Summary   string
	Err       string
}

LocalAgentMeta is the payload for KindLocalAgent snapshots.

Phase is the fine-grained sub-state ("thinking", "executing", "draining", ...) the child agent broadcasts as it works — orthogonal to the coarse DaemonStatus (running / completed / failed / killed). The TUI subagent strip renders both: DaemonStatus picks the chip color, Phase drives the inline glyph.

Summary is populated on terminal Lifecycle with the child agent's final response. Err is populated when the child crashed or was killed.

type LocalBashMeta ¶

type LocalBashMeta struct {
	Command  string
	ExitCode *int
	Output   string
}

LocalBashMeta is the payload for KindLocalBash snapshots.

Output is the captured stdout+stderr tail, capped at the size the bash goroutine enforces (64 KiB). ExitCode is nil while running; set on the terminal Lifecycle.

type MonitorMeta ¶

type MonitorMeta struct {
	Command     string
	EventCount  int
	Persistent  bool
	RecentLines []string
}

MonitorMeta is the payload for KindMonitor snapshots.

RecentLines is a ring buffer tail used by daemon_output; events have already been drained into the conversation by the time daemon_output reads, so we keep a small in-memory tail rather than asking the agent to scroll back.

type OutputTool ¶

type OutputTool struct {
	// contains filtered or unexported fields
}

OutputTool returns the kind-specific formatted output for one daemon.

func NewOutput(state *DaemonState) *OutputTool

func (t *OutputTool) Description() string

func (t *OutputTool) Execute(_ context.Context, logger *slog.Logger, raw json.RawMessage) (tools.Result, error)

func (t *OutputTool) Name() string

func (t *OutputTool) Schema() json.RawMessage

type Signal ¶

type Signal struct {
	DaemonID string
	Kind     DaemonKind
	At       time.Time
	Snapshot DaemonSnapshot

	Lifecycle *Lifecycle
	Event     *Event
}

Signal is the unit DaemonState's queue carries from per-daemon goroutines to the agent loop's drain. Exactly one of Lifecycle / Event is non-nil.

Lifecycle fires once per terminal transition (Completed / Failed / Killed) and triggers eviction. Event fires per stream line — used by monitors; kinds that don't stream (bash, local_agent) only emit Lifecycle.

Snapshot is captured at signal-emission time so drain readers see a consistent view even if the daemon is mutating concurrently.

func NewEventSignal(d Daemon, line string, closing bool) Signal

func NewLifecycleSignal(d Daemon, status DaemonStatus) Signal

func (s Signal) IsEvent() bool

func (s Signal) IsLifecycle() bool

type StopTool ¶

type StopTool struct {
	// contains filtered or unexported fields
}

StopTool terminates one daemon by id. Idempotent on already-terminal ids.

func NewStop(state *DaemonState) *StopTool

func (t *StopTool) Description() string

func (t *StopTool) Execute(ctx context.Context, logger *slog.Logger, raw json.RawMessage) (tools.Result, error)

func (t *StopTool) Name() string

func (t *StopTool) Schema() json.RawMessage