daemon

package
v0.7.6 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 19, 2026 License: MIT Imports: 158 Imported by: 0

Documentation ¶

Overview ¶

Package daemon wires the Compozy runtime packages into a single long-lived process.

Index ¶

Constants ¶

View Source
const (
	DrainStateActive   = contract.DrainStateActive
	DrainStateDraining = contract.DrainStateDraining
)
View Source
const (
	// RestartPreflightCommand is the hidden `compozy daemon` subcommand a daemon runs on the
	// replacement binary before it signals itself for a restart.
	RestartPreflightCommand = "preflight"
	// RestartPreflightSchema identifies the single-line report RestartPreflightCommand prints.
	RestartPreflightSchema = "compozy.daemon.preflight/v1"
	// RestartPreflightStageConfig names a configuration the replacement cannot load or validate.
	RestartPreflightStageConfig = "config"
	// RestartPreflightStageMigrations names a global database the replacement refuses to migrate.
	RestartPreflightStageMigrations = "migration_plan"
)
View Source
const (
	// RestartOperationEnvKey carries the restart operation id from the helper to the replacement daemon.
	RestartOperationEnvKey = "COMPOZY_INTERNAL_RESTART_OPERATION_ID"
)
View Source
const RestartPhaseMigrating = "migrating"

RestartPhaseMigrating marks a replacement daemon that is upgrading persisted data before readiness.

Variables ¶

View Source
var (
	// ErrAlreadyRunning reports that another daemon process currently owns the singleton lock.
	ErrAlreadyRunning = errors.New("daemon: already running")
)
View Source
var ErrRestartInProgress = errors.New("daemon: restart already in progress")

ErrRestartInProgress reports a restart request made while another one is still running.

View Source
var (
	// ErrRestartOperationNotFound reports a missing persisted restart operation.
	ErrRestartOperationNotFound = errors.New("daemon: restart operation not found")
)
View Source
var ErrRestartPreflightFailed = errors.New("replacement runtime cannot boot; the running daemon was kept")

ErrRestartPreflightFailed reports a replacement binary that positively cannot boot this home. The restart is refused before the running daemon is signaled.

View Source
var ErrRuntimeMutationInProgress = errors.New("daemon: runtime mutation in progress")

ErrRuntimeMutationInProgress reports that another process owns update.lock.

Functions ¶

func GracefulShutdownTimeout ¶

func GracefulShutdownTimeout(cfg *compozyconfig.Config) time.Duration

GracefulShutdownTimeout returns the daemon's complete shutdown budget for a config.

func RemoveInfo ¶

func RemoveInfo(path string) error

RemoveInfo removes daemon.json if it exists.

func RunRelaunchHelper ¶

func RunRelaunchHelper(ctx context.Context, cfg *RelaunchHelperConfig) error

RunRelaunchHelper runs the detached helper that waits for daemon shutdown resources to release and then launches the replacement daemon.

func WriteInfo ¶

func WriteInfo(path string, info Info) (returnErr error)

WriteInfo writes daemon.json atomically via temp file and rename.

Types ¶

type ClarifyKeepalive ¶

type ClarifyKeepalive interface {
	Ping(ctx context.Context, ping ClarifyPingParams) error
}

ClarifyKeepalive delivers one keepalive ping for a pending clarification; failures are advisory. The payload shape keeps ping numbering in the broker and the resolver stateless.

type ClarifyPingParams ¶

type ClarifyPingParams struct {
	SessionID string
	RequestID string
	Seq       uint64
	AskedAt   time.Time
	Deadline  time.Time
}

ClarifyPingParams is one keepalive tick's identity-only payload. It carries no tokens, answers, or question content beyond what pending events expose.

type ComposedAssembler ¶

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

ComposedAssembler assembles selected startup prompt sections around the base agent prompt.

func NewComposedAssembler ¶

func NewComposedAssembler(opts ...ComposedAssemblerOption) *ComposedAssembler

NewComposedAssembler constructs a ComposedAssembler from startup section descriptors.

func (*ComposedAssembler) Assemble ¶

Assemble renders the selected startup sections using a baseline startup context for callers that only know about the legacy assembler seam.

func (*ComposedAssembler) AssembleStartup ¶

AssembleStartup renders eligible prepend sections, the trimmed base prompt, and eligible append sections into one composed startup system prompt.

func (*ComposedAssembler) AssembleStartupWithManifest ¶

func (a *ComposedAssembler) AssembleStartupWithManifest(
	ctx context.Context,
	startup session.StartupPromptContext,
	agent compozyconfig.AgentDef,
	workspace *workspacepkg.ResolvedWorkspace,
) (string, acp.StartupManifest, error)

AssembleStartupWithManifest measures budgeted sections in their document order.

type ComposedAssemblerOption ¶

type ComposedAssemblerOption func(*ComposedAssembler)

ComposedAssemblerOption customizes the prompt section chain for a ComposedAssembler.

func WithAppendPromptProviders ¶

func WithAppendPromptProviders(providers ...session.PromptProvider) ComposedAssemblerOption

WithAppendPromptProviders preserves the legacy append provider option by wrapping providers in explicit append descriptors.

func WithPrependPromptProviders ¶

func WithPrependPromptProviders(providers ...session.PromptProvider) ComposedAssemblerOption

WithPrependPromptProviders preserves the legacy prepend provider option by wrapping providers in explicit prepend descriptors.

func WithPromptSectionDescriptors ¶

func WithPromptSectionDescriptors(descriptors ...PromptSectionDescriptor) ComposedAssemblerOption

WithPromptSectionDescriptors appends explicit startup prompt section descriptors to the assembler.

func WithSectionSelector ¶

func WithSectionSelector(selector *SectionSelector) ComposedAssemblerOption

WithSectionSelector installs the daemon-owned startup section selector.

type ConfigLoader ¶

type ConfigLoader func() (compozyconfig.Config, error)

ConfigLoader resolves the daemon-level runtime configuration.

type ConsentDecision ¶

type ConsentDecision = settingspkg.ConsentDecision

type CoordinatorRoleResolver ¶

type CoordinatorRoleResolver interface {
	ResolveCoordinatorRole(ctx context.Context, workspaceID string) (compozyconfig.ResolvedCoordinatorRole, error)
}

CoordinatorRoleResolver resolves coordinator routing and safety policy without starting behavior.

type Daemon ¶

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

Daemon is the sole Compozy composition root.

func New ¶

func New(opts ...Option) (*Daemon, error)

New constructs the daemon composition root.

func (*Daemon) Boundaries ¶

func (d *Daemon) Boundaries(context.Context) error

Boundaries performs a best-effort import boundary verification for local source checkouts.

func (*Daemon) DaemonReadiness ¶

func (d *Daemon) DaemonReadiness() *contract.DaemonReadinessPayload

DaemonReadiness reports the lifecycle phase and current step for the status payload.

func (*Daemon) Drain ¶

func (d *Daemon) Drain(ctx context.Context) error

Drain closes new-work admission without interrupting already admitted work.

func (*Daemon) DrainState ¶

func (d *Daemon) DrainState() DrainState

DrainState returns the current in-memory daemon admission state.

func (*Daemon) DrainStatus ¶

func (d *Daemon) DrainStatus(ctx context.Context) (contract.DrainStatusResponse, error)

DrainStatus returns the daemon-owned quiesce readout used before process stop.

func (*Daemon) GetRestartOperation ¶

func (d *Daemon) GetRestartOperation(ctx context.Context, operationID string) (RestartOperation, error)

GetRestartOperation reads one persisted restart operation by id.

func (*Daemon) IsDraining ¶

func (d *Daemon) IsDraining() bool

IsDraining reports whether new-work admission is closed.

func (*Daemon) RequestRestart ¶

func (d *Daemon) RequestRestart(ctx context.Context) (RestartOperation, error)

RequestRestart creates the persisted restart operation, pre-flights the replacement binary, launches the detached relaunch helper, and signals the running daemon to enter its normal graceful shutdown path. A replacement that reports it cannot boot fails the operation with ErrRestartPreflightFailed before anything is launched or signaled. Requests are serialized: one made while another is still running is refused with ErrRestartInProgress and changes nothing.

func (*Daemon) Run ¶

func (d *Daemon) Run(ctx context.Context) error

Run boots the daemon, blocks until signal or context cancellation, then performs graceful shutdown.

func (*Daemon) Shutdown ¶

func (d *Daemon) Shutdown(ctx context.Context) error

Shutdown gracefully tears down the daemon in the required order.

func (*Daemon) SubagentService ¶

func (d *Daemon) SubagentService() session.SubagentService

func (*Daemon) Undrain ¶

func (d *Daemon) Undrain(ctx context.Context) error

Undrain restores new-work admission.

type DetachedRunMetadata ¶

type DetachedRunMetadata struct {
	TaskID    string
	TaskRunID string
}

DetachedRunMetadata carries detached task-runtime correlation fields.

type DetachedRunMode ¶

type DetachedRunMode string

DetachedRunMode identifies detached task-runtime behavior for the resolved policy.

const (
	// DetachedRunModeNone means detached task-runtime behavior is not enabled.
	DetachedRunModeNone DetachedRunMode = "none"
	// DetachedRunModeTaskRuntime means detached work reuses the existing task runtime.
	DetachedRunModeTaskRuntime DetachedRunMode = "task_runtime"
)

type DrainState ¶

type DrainState = contract.DrainState

DrainState is the public daemon admission state.

type GatewayTierServerFactory ¶

type GatewayTierServerFactory func(
	ctx context.Context,
	deps *RuntimeDeps,
	tier gateway.Tier,
	surfaces []gateway.Surface,
) (Server, error)

GatewayTierServerFactory constructs one daemon-owned loopback listener for a tier and its active surfaces.

type HarnessAugmenter ¶

type HarnessAugmenter string

HarnessAugmenter identifies a prompt input augmenter managed by harness policy.

const (
	// HarnessAugmenterSituation injects fresh bounded Compozy situation context.
	HarnessAugmenterSituation HarnessAugmenter = "situation"
	// HarnessAugmenterSkills injects the current effective skills catalog.
	HarnessAugmenterSkills HarnessAugmenter = "skills"
	// HarnessAugmenterStanding injects operator rules and the peer roster of always-on agents.
	HarnessAugmenterStanding HarnessAugmenter = "standing"
)

type HarnessContextResolver ¶

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

HarnessContextResolver derives harness policy from durable session state plus turn-origin metadata.

func NewHarnessContextResolver ¶

func NewHarnessContextResolver(
	runtime HarnessRuntimeSignals,
	opts ...HarnessContextResolverOption,
) *HarnessContextResolver

NewHarnessContextResolver constructs a daemon-owned harness context resolver.

func (*HarnessContextResolver) Resolve ¶

Resolve derives one authoritative harness context from explicit inputs.

func (*HarnessContextResolver) ResolvePrompt ¶

func (r *HarnessContextResolver) ResolvePrompt(
	info *session.Info,
	source session.TurnSource,
	meta acp.PromptMeta,
) (ResolvedHarnessContext, error)

ResolvePrompt resolves one live prompt-turn policy from session metadata.

func (*HarnessContextResolver) ResolveStartup ¶

ResolveStartup resolves startup policy from durable session context.

type HarnessContextResolverOption ¶

type HarnessContextResolverOption func(*HarnessContextResolver)

HarnessContextResolverOption configures provider-native skill-root resolution.

func WithHarnessSkillInjectionEnvLookup ¶

func WithHarnessSkillInjectionEnvLookup(
	lookup func(string) (string, bool),
) HarnessContextResolverOption

WithHarnessSkillInjectionEnvLookup configures the effective provider environment lookup.

func WithHarnessSkillInjectionHome ¶

func WithHarnessSkillInjectionHome(homePaths compozyconfig.HomePaths) HarnessContextResolverOption

WithHarnessSkillInjectionHome configures the operator and managed provider homes.

func WithHarnessSkillInjectionLogger ¶

func WithHarnessSkillInjectionLogger(logger *slog.Logger) HarnessContextResolverOption

WithHarnessSkillInjectionLogger configures suppression decision logging.

type HarnessPromptSection ¶

type HarnessPromptSection string

HarnessPromptSection identifies a startup prompt section managed by harness policy.

const (
	// HarnessPromptSectionRuntimeIdentity injects the daemon-owned Compozy runtime envelope.
	HarnessPromptSectionRuntimeIdentity HarnessPromptSection = "runtime_identity"
	// HarnessPromptSectionSituation injects the bounded Compozy situation context.
	HarnessPromptSectionSituation HarnessPromptSection = "situation"
	// HarnessPromptSectionSkills injects the active skills catalog prompt context.
	HarnessPromptSectionSkills HarnessPromptSection = "skills"
	// HarnessPromptSectionTools injects Compozy-native tool discovery and invocation guidance.
	HarnessPromptSectionTools HarnessPromptSection = "tools"
)

type HarnessResolutionInput ¶

type HarnessResolutionInput struct {
	Surface ResolutionSurface
	Session HarnessSessionInput
	Turn    HarnessTurnRequest
}

HarnessResolutionInput captures one resolver request.

type HarnessRuntimeSignals ¶

type HarnessRuntimeSignals struct {
	RuntimeIdentityPromptSectionEnabled bool
	SituationPromptSectionEnabled       bool
	SkillsPromptSectionEnabled          bool
	ToolsPromptSectionEnabled           bool
	SkillsAugmenter                     bool
	SituationAugmenter                  bool
	StandingAugmenter                   bool
	SyntheticTurnsEnabled               bool
	DetachedTaskRuntimeEnabled          bool
}

HarnessRuntimeSignals captures daemon-owned capability flags available to the resolver.

type HarnessSessionContext ¶

type HarnessSessionContext struct {
	SessionID    string
	Type         session.Type
	SpawnRole    string
	SessionClass SessionClass

	WorkspaceID        string
	Workspace          string
	AgentName          string
	Provider           string
	ProviderHomePolicy compozyconfig.ProviderHomePolicy
}

HarnessSessionContext is the normalized durable session context emitted by the resolver.

type HarnessSessionInput ¶

type HarnessSessionInput struct {
	SessionID string
	Type      session.Type
	SpawnRole string

	WorkspaceID        string
	Workspace          string
	AgentName          string
	Provider           string
	ProviderHomePolicy compozyconfig.ProviderHomePolicy
}

HarnessSessionInput carries durable session metadata into the resolver.

type HarnessTurnContext ¶

type HarnessTurnContext struct {
	Origin     TurnOrigin
	PromptMeta acp.PromptMeta
	Synthetic  *SyntheticTurnMetadata
	Detached   *DetachedRunMetadata
}

HarnessTurnContext is the normalized turn context emitted by the resolver.

type HarnessTurnRequest ¶

type HarnessTurnRequest struct {
	Source     session.TurnSource
	PromptMeta acp.PromptMeta
	Synthetic  *SyntheticTurnMetadata
	Detached   *DetachedRunMetadata
}

HarnessTurnRequest carries turn-time metadata into the resolver.

type Info ¶

type Info struct {
	PID       int       `json:"pid"`
	HTTPHost  string    `json:"http_host,omitempty"`
	Port      int       `json:"port"`
	StartedAt time.Time `json:"started_at"`
	// ReadinessPhase is the lifecycle phase when this file was written; absent on older daemons.
	ReadinessPhase string `json:"readiness_phase,omitempty"`
}

Info is the persisted daemon discovery record written to daemon.json.

func ReadInfo ¶

func ReadInfo(path string) (_ Info, returnErr error)

ReadInfo loads daemon.json from disk.

func (Info) Validate ¶

func (i Info) Validate() error

Validate ensures the persisted daemon info remains usable for discovery.

type Lock ¶

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

Lock owns the singleton daemon file lock.

func AcquireLock ¶

func AcquireLock(path string, pid int) (*Lock, error)

AcquireLock acquires the singleton daemon lock and records the current PID in the lock file.

func (*Lock) Path ¶

func (l *Lock) Path() string

Path reports the on-disk daemon lock file path.

func (*Lock) Release ¶

func (l *Lock) Release() error

Release clears the lock file contents and releases the advisory file lock.

func (*Lock) StalePID ¶

func (l *Lock) StalePID() int

StalePID reports the recovered stale daemon PID, if any.

type LockOwner ¶

type LockOwner struct {
	// PID is the PID recorded by the current or last holder; it is meaningful only when Held is true.
	PID int
	// Held reports whether some process currently holds the advisory lock.
	Held bool
}

LockOwner describes the observed holder of the singleton daemon lock.

func InspectLockOwner ¶

func InspectLockOwner(path string) (LockOwner, error)

InspectLockOwner reports whether the daemon lock is held and which PID its holder recorded. The contention probe takes and immediately releases the lock when it is free, and never rewrites the recorded PID, so a stale file left by a dead daemon reports Held=false. The PID is read after the probe, but a holder that has not yet recorded its own PID still reports the previous value; callers that wait on the holder must re-inspect.

type MCPApproval ¶

type MCPApproval = store.MCPApproval

type MCPApprovalStore ¶

type MCPApprovalStore interface {
	ListMCPServerApprovals(context.Context, string, string) ([]MCPApproval, error)
	PutMCPServerApproval(context.Context, MCPApproval) error
	DeleteMCPServerApproval(context.Context, string, string, string, string) error
}

type Observer ¶

type Observer interface {
	core.Observer
	session.Notifier
	Reconcile(ctx context.Context) (store.ReconcileResult, error)
}

Observer is the daemon observer surface used for transport wiring and reconciliation.

type Option ¶

type Option func(*Daemon)

Option customizes daemon construction.

func WithBoundaryVerification ¶

func WithBoundaryVerification(enabled bool) Option

WithBoundaryVerification enables best-effort import boundary verification on boot.

func WithCompozyExecutableResolver ¶

func WithCompozyExecutableResolver(resolver func() (string, error)) Option

WithCompozyExecutableResolver supplies the executable used by bundled extension commands.

func WithConfig ¶

func WithConfig(cfg *compozyconfig.Config) Option

WithConfig overrides daemon-level configuration loading.

func WithConfigLoader ¶

func WithConfigLoader(loader ConfigLoader) Option

WithConfigLoader overrides daemon-level configuration loading.

func WithGatewayProviderEffects ¶

func WithGatewayProviderEffects(effects gateway.EffectDriver) Option

WithGatewayProviderEffects injects the provider preflight, establish, verify, advertise, withdraw, teardown, and health-supervision lifecycle used by gateway reconciliation.

func WithGatewayTierServerFactory ¶

func WithGatewayTierServerFactory(factory GatewayTierServerFactory) Option

WithGatewayTierServerFactory overrides daemon-owned tier listener construction.

func WithHTTPServerFactory ¶

func WithHTTPServerFactory(factory ServerFactory) Option

WithHTTPServerFactory overrides HTTP server construction.

func WithHomePaths ¶

func WithHomePaths(homePaths compozyconfig.HomePaths) Option

WithHomePaths overrides the resolved Compozy home layout.

func WithLogger ¶

func WithLogger(logger *slog.Logger) Option

WithLogger injects the daemon logger.

func WithNow ¶

func WithNow(now func() time.Time) Option

WithNow overrides the daemon clock, mainly for tests.

func WithSignalBridge ¶

func WithSignalBridge(ch <-chan os.Signal) Option

WithSignalBridge overrides OS signal delivery, mainly for tests.

func WithUDSServerFactory ¶

func WithUDSServerFactory(factory ServerFactory) Option

WithUDSServerFactory overrides UDS server construction.

type PromptSectionBudgetBehavior ¶

type PromptSectionBudgetBehavior string

PromptSectionBudgetBehavior controls how an oversized section is handled.

const (
	// PromptSectionBudgetBehaviorTrim truncates the section to its declared budget.
	PromptSectionBudgetBehaviorTrim PromptSectionBudgetBehavior = "trim"
	// PromptSectionBudgetBehaviorOmit drops the section when it exceeds budget.
	PromptSectionBudgetBehaviorOmit PromptSectionBudgetBehavior = "omit"
)

type PromptSectionDescriptor ¶

type PromptSectionDescriptor struct {
	Name             string
	Position         PromptSectionPosition
	Order            int
	Budget           int
	BudgetBehavior   PromptSectionBudgetBehavior
	Provider         any
	Predicate        SectionPredicate
	StartupPredicate StartupSectionPredicate
}

PromptSectionDescriptor describes one startup prompt section provider plus its ordering, policy eligibility, and budget behavior.

type PromptSectionPosition ¶

type PromptSectionPosition string

PromptSectionPosition identifies whether a startup section renders before or after the base agent prompt.

const (
	// PromptSectionPositionPrepend renders the section before the base prompt.
	PromptSectionPositionPrepend PromptSectionPosition = "prepend"
	// PromptSectionPositionAppend renders the section after the base prompt.
	PromptSectionPositionAppend PromptSectionPosition = "append"
)

type ReentryMode ¶

type ReentryMode string

ReentryMode identifies how a resolved policy participates in synthetic reentry.

const (
	// ReentryModeNone means the turn is not synthetic reentry.
	ReentryModeNone ReentryMode = "none"
	// ReentryModeSynthetic means the turn is a validated synthetic reentry path.
	ReentryModeSynthetic ReentryMode = "synthetic"
)

type Registry ¶

type Registry interface {
	store.SkillExposureRepository
	core.TaskDesignationStore
	gateway.Store
	store.OnboardingStore
	looppkg.ReconciliationStore
	VerifyDefaultProfile(context.Context) error
	// contains filtered or unexported methods
}

Registry is the composition-root database surface grouped by owning domain. Consumers depend on their local narrow interfaces instead of this aggregate.

type RelaunchHelperConfig ¶

type RelaunchHelperConfig struct {
	HomePaths      compozyconfig.HomePaths
	OperationID    string
	Executable     func() (string, error)
	Sandbox        []string
	PollInterval   time.Duration
	ReleaseTimeout time.Duration
	ReadyTimeout   time.Duration
	ExitDrainWait  time.Duration
}

RelaunchHelperConfig configures one internal `compozy daemon relaunch` execution.

type ResolutionSurface ¶

type ResolutionSurface string

ResolutionSurface identifies which runtime seam is consuming the resolver.

const (
	// ResolutionSurfaceStartup resolves startup prompt policy.
	ResolutionSurfaceStartup ResolutionSurface = "startup"
	// ResolutionSurfaceTurn resolves live prompt-turn policy.
	ResolutionSurfaceTurn ResolutionSurface = "turn"
)

type ResolvedHarnessContext ¶

type ResolvedHarnessContext struct {
	Surface ResolutionSurface
	Session HarnessSessionContext
	Turn    HarnessTurnContext
	Policy  ResolvedHarnessPolicy
}

ResolvedHarnessContext captures the normalized inputs plus the derived policy.

type ResolvedHarnessPolicy ¶

type ResolvedHarnessPolicy struct {
	SessionClass         SessionClass
	TurnOrigin           TurnOrigin
	IncludeSections      []HarnessPromptSection
	EnableAugmenters     []HarnessAugmenter
	ReentryMode          ReentryMode
	DetachedRunMode      DetachedRunMode
	DiagnosticLabel      string
	ObservabilityTags    map[string]string
	SkillInjectionFilter SkillInjectionFilter
}

ResolvedHarnessPolicy is the authoritative daemon-owned harness runtime policy.

type ResolvedRole ¶

type ResolvedRole struct {
	Role            compozyconfig.RoleName
	Enabled         bool
	AgentName       string
	Builtin         bool
	Inherit         bool
	AgentDef        compozyconfig.AgentDef
	Provider        string
	Model           string
	ReasoningEffort string

	Fallbacks []compozyconfig.RoleFallback
	// PrimaryDisabled skips the primary route because its provider is disabled (BR-6).
	PrimaryDisabled bool
	Provenance      map[string]string
	// contains filtered or unexported fields
}

ResolvedRole is one invocation-time role routing decision.

type RestartOperation ¶

type RestartOperation struct {
	OperationID        string        `json:"operation_id"`
	Status             RestartStatus `json:"status"`
	OldPID             int           `json:"old_pid"`
	OldStartedAt       time.Time     `json:"old_started_at"`
	OldSocketPath      string        `json:"old_socket_path"`
	NewPID             int           `json:"new_pid,omitzero"`
	ActiveSessionCount int           `json:"active_session_count"`
	FailureReason      string        `json:"failure_reason,omitempty"`
	StartedAt          time.Time     `json:"started_at"`
	UpdatedAt          time.Time     `json:"updated_at"`
	CompletedAt        *time.Time    `json:"completed_at,omitempty"`
	// Progress reports a replacement daemon's data migration while it cannot serve status yet.
	Progress *RestartProgress `json:"progress,omitempty"`
}

RestartOperation is the persisted restart status record stored under ~/.compozy/restarts/.

func ReadRestartOperation ¶

func ReadRestartOperation(homePaths compozyconfig.HomePaths, operationID string) (RestartOperation, error)

ReadRestartOperation reads restart progress without requiring a ready daemon.

func (RestartOperation) Validate ¶

func (o RestartOperation) Validate() error

Validate ensures the persisted restart operation is structurally usable.

type RestartPreflightConfig ¶

type RestartPreflightConfig struct {
	HomePaths compozyconfig.HomePaths
	Getenv    func(string) string
	// LoadLaunchConfig loads the configuration the launch commands read before the daemon boots.
	LoadLaunchConfig func() error
}

RestartPreflightConfig configures one RunRestartPreflight execution.

type RestartPreflightMigration ¶

type RestartPreflightMigration struct {
	Stream      string `json:"stream"`
	Version     int64  `json:"version"`
	HeadVersion int64  `json:"head_version"`
	Pending     int    `json:"pending"`
}

RestartPreflightMigration is the non-mutating migration plan of one daemon-global stream.

type RestartPreflightReport ¶

type RestartPreflightReport struct {
	Schema string `json:"schema"`
	OK     bool   `json:"ok"`
	// Stage and Error describe the first check that failed.
	Stage      string                      `json:"stage,omitempty"`
	Error      string                      `json:"error,omitempty"`
	Migrations []RestartPreflightMigration `json:"migrations,omitempty"`
	// Warnings list checks that could not conclude; they never fail the pre-flight.
	Warnings []string `json:"warnings,omitempty"`
}

RestartPreflightReport is what one binary reports about booting a home without mutating it.

func RunRestartPreflight ¶

func RunRestartPreflight(ctx context.Context, cfg *RestartPreflightConfig) RestartPreflightReport

RunRestartPreflight reports whether this binary can boot the home: it plans the global database migrations through a read-only handle, then loads and validates the configuration as launch and boot do. It never applies a migration, never creates the database, and never opens per-session databases.

func (RestartPreflightReport) FailureReason ¶

func (r RestartPreflightReport) FailureReason() string

FailureReason renders the failed check for the restart journal and transport errors.

type RestartProgress ¶

type RestartProgress struct {
	Phase     string    `json:"phase"`
	Stage     string    `json:"stage"`
	Completed int64     `json:"completed"`
	Total     int64     `json:"total"`
	UpdatedAt time.Time `json:"updated_at"`
}

RestartProgress is the replacement daemon's latest data-migration progress.

type RestartStatus ¶

type RestartStatus string

RestartStatus is the durable lifecycle state of one daemon restart operation.

const (
	RestartStatusPending        RestartStatus = "pending"
	RestartStatusStopping       RestartStatus = "stopping"
	RestartStatusWaitingRelease RestartStatus = "waiting_release"
	RestartStatusStarting       RestartStatus = "starting"
	RestartStatusReady          RestartStatus = "ready"
	RestartStatusFailed         RestartStatus = "failed"
)

type RoleResolutionError ¶

type RoleResolutionError struct {
	Code  string
	Role  compozyconfig.RoleName
	Agent string
	Err   error
}

RoleResolutionError is a deterministic role-resolution failure.

func (*RoleResolutionError) DiagnosticCode ¶

func (e *RoleResolutionError) DiagnosticCode() string

DiagnosticCode returns the stable public code for transport projections.

func (*RoleResolutionError) Error ¶

func (e *RoleResolutionError) Error() string

func (*RoleResolutionError) Unwrap ¶

func (e *RoleResolutionError) Unwrap() error

type RoleResolver ¶

type RoleResolver interface {
	Resolve(ctx context.Context, workspaceID string, role compozyconfig.RoleName) (ResolvedRole, error)
}

type RuntimeDeps ¶

type RuntimeDeps struct {
	AgentInstances        *core.AgentInstanceAPI
	Subagents             session.SubagentService
	SessionMonitors       core.SessionMonitorService
	SessionProcesses      core.SessionProcessService
	Config                compozyconfig.Config
	AgentProbeConfig      *agentProbeConfigState
	HomePaths             compozyconfig.HomePaths
	Logger                *slog.Logger
	Sessions              SessionManager
	DrainController       core.DaemonDrainController
	Tasks                 taskpkg.Manager
	ToolRegistry          toolspkg.Registry
	Toolsets              core.ToolsetRegistry
	ToolArtifacts         toolspkg.ToolArtifactStore
	SessionAttachments    attachmentspkg.Store
	SessionFiles          core.SessionFileSearcher
	FileTree              core.FileTreeReader
	SessionChanges        core.SessionChangesReader
	ToolApprovals         toolspkg.ApprovalTokenIssuer
	ApprovalCoordinator   toolspkg.ApprovalCoordinator
	CmdPalette            cmdpalette.Registry
	ApprovalGrants        toolspkg.ApprovalGrantStore
	Clarify               toolspkg.ClarifyBroker
	HostedMCP             *mcppkg.HostedService
	MCPHostAPI            mcppkg.HostAPIInvoker
	Observer              Observer
	SchemaStreams         core.SchemaStreamStatusReader
	Automation            core.AutomationManager
	Loops                 core.LoopService
	Registry              Registry
	Profiles              *profile.Manager
	RuntimeMemory         doctor.RuntimeMemorySnapshotSource
	HostLoad              doctor.HostLoadSnapshotSource
	TelemetryStatus       core.TelemetryStatusSource
	DeadEntities          doctor.DeadEntitySource
	WorkspaceResolver     workspacepkg.RuntimeResolver
	WorkspaceService      core.WorkspaceService
	Worktrees             core.WorktreeService
	WorkspaceAccess       workspaceaccess.Policy
	AgentCatalog          core.AgentCatalog
	AgentResolver         session.AgentResolver
	AgentDefinitionSync   core.AgentDefinitionSync
	ModelCatalog          core.ModelCatalogService
	ProviderUsage         core.ProviderUsageService
	MarketplaceCatalog    core.MarketplaceCatalogService
	AgentContext          *situation.Service
	SoulAuthoring         core.SoulAuthoringService
	AgentMemory           *agentmemory.Store
	SoulHistoryPurger     core.SoulHistoryPurger
	SoulRefresher         core.SoulRefresher
	HeartbeatAuthor       core.HeartbeatAuthoringService
	HeartbeatPurger       core.HeartbeatHistoryPurger
	HeartbeatStatus       core.HeartbeatStatusService
	HeartbeatWake         core.HeartbeatWakeService
	SessionHealth         core.SessionHealthReader
	WakeEvents            core.HeartbeatWakeEventReader
	CoordinatorRole       CoordinatorRoleResolver
	Roles                 core.RolesStatusProvider
	SkillsRegistry        core.SkillsRegistry
	SkillResources        core.SkillResourceSyncer
	Settings              core.SettingsService
	SettingsRestart       core.SettingsRestartController
	SettingsUpdate        core.SettingsUpdateController
	SupportBundles        core.SupportBundleService
	Vault                 core.VaultService
	Extensions            udsapi.ExtensionService
	Resources             core.ResourceService
	WindowManagers        *windowManagerRegistry
	Terminals             *terminalpkg.Service
	AppTokens             *gateway.DeviceService
	Gateway               *gateway.Service
	GatewayChallenges     *gateway.ChallengeRegistry
	GatewayAuthLimiter    *gateway.AuthFailureLimiter
	GatewayPairingLimiter *gateway.AuthFailureLimiter
	StartedAt             time.Time

	OnProviderAuthSuccess func()
	ProviderAuthVerdicts  *providers.AuthVerdicts
}

RuntimeDeps captures the composition-root dependencies available to server factories.

type SectionPredicate ¶

type SectionPredicate func(ResolvedHarnessPolicy) bool

SectionPredicate decides whether a prompt section is eligible for one resolved startup policy.

type SectionSelector ¶

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

SectionSelector resolves startup policy and selects eligible startup prompt sections before final assembly.

func NewSectionSelector ¶

func NewSectionSelector(
	resolver *HarnessContextResolver,
	recorder *harnessLifecycleRecorder,
) *SectionSelector

NewSectionSelector constructs a daemon-owned startup section selector.

func (*SectionSelector) Select ¶

Select resolves startup policy for the provided startup context and returns the eligible startup sections in deterministic order without duplicates.

type Server ¶

type Server interface {
	Start(ctx context.Context) error
	Shutdown(ctx context.Context) error
}

Server is a daemon-owned runtime component with explicit start and shutdown phases.

type ServerFactory ¶

type ServerFactory func(ctx context.Context, deps RuntimeDeps) (Server, error)

ServerFactory constructs runtime components such as HTTP and UDS servers.

type SessionClass ¶

type SessionClass string

SessionClass is the session-side harness axis derived from durable session metadata rather than a top-level profile enum.

const (
	// SessionClassInteractive identifies user-owned interactive sessions.
	SessionClassInteractive SessionClass = "interactive"
	// SessionClassSystem identifies daemon-owned system sessions.
	SessionClassSystem SessionClass = "system"
	// SessionClassCoordinator identifies daemon-owned workspace coordinator sessions.
	SessionClassCoordinator SessionClass = "coordinator"
	// SessionClassSpawned identifies bounded child worker sessions.
	SessionClassSpawned SessionClass = "spawned"
)

type SessionManager ¶

type SessionManager = core.SessionManager

SessionManager is the shared transport-facing session surface consumed by daemon/.

type SessionManagerDeps ¶

type SessionManagerDeps struct {
	PermissionWaitResolver  acp.PermissionWaitResolver
	HomePaths               compozyconfig.HomePaths
	Logger                  *slog.Logger
	Notifier                session.Notifier
	SpawnWakeNotifier       session.SpawnWakeNotifier
	Hooks                   session.HookSet
	PromptAssembler         session.PromptAssembler
	StartupPromptOverlay    session.StartupPromptOverlay
	PromptInputAugmenter    session.PromptInputAugmenter
	CommandService          session.CommandService
	WorkAdmission           admission.Checker
	AgentResolver           session.AgentResolver
	SkillRegistry           session.SkillRegistry
	MCPResolver             session.MCPResolver
	MCPConsentFilter        session.MCPConsentFilter
	WorkspaceResolver       session.WorkspaceResolver
	WorktreeResolver        session.WorktreeResolver
	WindowReconciler        session.WindowReconciler
	SessionSupervision      compozyconfig.SessionSupervisionConfig
	SessionStop             compozyconfig.SessionStopConfig
	SessionAuthRecovery     compozyconfig.SessionAuthRecoveryConfig
	SessionBusyInput        compozyconfig.SessionBusyInputConfig
	SessionMessaging        compozyconfig.SessionMessagingConfig
	SessionDerive           compozyconfig.SessionDeriveConfig
	SessionInputQueue       store.SessionInputQueueStore
	SessionPromptAdmission  store.SessionPromptAdmissionStore
	SessionAttachments      session.AttachmentOpener
	SessionHealthConfig     compozyconfig.HeartbeatConfig
	CheckInTools            bool
	AttentionConfig         compozyconfig.AttentionConfig
	AttentionWorkspaceMutes session.AttentionWorkspaceMuteReader
	OperatorNoticeOutbox    session.OperatorNoticeOutbox
	SessionCatalog          store.SessionCatalog
	EventLedger             store.EventSummaryStore
	ProcessRegistry         *toolruntime.Registry
	Terminals               acp.TerminalHost
	HostedMCP               session.HostedMCPLauncher
	RuntimeMCPInventory     session.RuntimeMCPInventory
	ProviderSecrets         session.ProviderSecretResolver
	ProfileNames            session.ProfileNameResolver
	ModelCatalog            modelcatalog.Service
	SoulStore               session.SoulSnapshotStore
	SoulRunChecker          session.SoulRunActivityChecker
	SessionHealthStore      session.HealthStore
	MentionReferences       session.MentionReferenceRenderer
	AgentNiceness           int
	ProviderTelemetryEnv    func() []string
}

SessionManagerDeps captures the composition-root dependencies needed to create a session manager.

type SessionPolicy ¶

type SessionPolicy struct {
	Runtime SessionRuntimePolicy
}

type SessionRuntimeMode ¶

type SessionRuntimeMode string
const (
	SessionRuntimeModeEvidence SessionRuntimeMode = "evidence"
)

type SessionRuntimePolicy ¶

type SessionRuntimePolicy struct {
	Mode        SessionRuntimeMode
	Permissions compozyconfig.PermissionMode
}

type SkillInjectionFilter ¶

type SkillInjectionFilter func(*skillspkg.Skill) bool

SkillInjectionFilter decides whether one resolved skill remains in prompt catalogs.

type StartupSectionPredicate ¶

type StartupSectionPredicate func(session.StartupPromptContext) bool

StartupSectionPredicate decides whether a prompt section is eligible for the concrete startup context being assembled.

type SyntheticTurnMetadata ¶

type SyntheticTurnMetadata struct {
	Reason      string
	Trigger     string
	SourceTask  string
	SourceRunID string
}

SyntheticTurnMetadata carries validated daemon-only synthetic reentry metadata.

type TurnOrigin ¶

type TurnOrigin string

TurnOrigin identifies the resolved harness origin for one turn.

const (
	// TurnOriginUser identifies a standard user-driven turn.
	TurnOriginUser TurnOrigin = "user"
	// TurnOriginSynthetic identifies a daemon-owned synthetic turn.
	TurnOriginSynthetic TurnOrigin = "synthetic"
)

type UpdateLock ¶

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

UpdateLock owns the cross-process runtime mutation lock.

func AcquireUpdateLock ¶

func AcquireUpdateLock(path string, owner UpdateLockOwner) (*UpdateLock, error)

AcquireUpdateLock locks update.lock and records the caller's process identity.

func (*UpdateLock) Release ¶

func (l *UpdateLock) Release() error

Release clears the owner payload, unlocks, and closes update.lock.

func (*UpdateLock) StaleOwner ¶

func (l *UpdateLock) StaleOwner() *UpdateLockOwner

StaleOwner reports the stale identity replaced during acquisition, if any.

type UpdateLockOwner ¶

type UpdateLockOwner struct {
	ProcessToken string    `json:"process_token,omitempty"`
	PID          int       `json:"pid"`
	StartedAt    time.Time `json:"started_at"`
}

UpdateLockOwner is the durable process identity associated with update.lock.

Source Files ¶

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL