services

Sep 9, 2026

Changes in this version

type ApprovalService

+ func (as *ApprovalService) IsApprovalPending(approvalID string) bool

+ func (as *ApprovalService) ListPendingApprovalsInternal() []*PendingApproval

+ func (as *ApprovalService) ResolveApprovalReconciled(ctx context.Context, approvalID, decision, ruleName string) error

+ func (as *ApprovalService) SetReviewQueueRemover(r session.ReviewQueueRemover)

type ApprovalStore

+ func (s *ApprovalStore) ClearHumanResolving(id string)

+ func (s *ApprovalStore) IsHumanResolving(id string) bool

+ func (s *ApprovalStore) MarkHumanResolving(id string)

+ type NativeGitRolloutService struct

+ func NewNativeGitRolloutService() *NativeGitRolloutService

+ func (s *NativeGitRolloutService) GetNativeGitRolloutStatus(ctx context.Context, ...) (*connect.Response[sessionv1.NativeGitRolloutStatus], error)

+ func (s *NativeGitRolloutService) SetNativeMergeGlobalOverride(ctx context.Context, ...) (*connect.Response[sessionv1.NativeGitRolloutStatus], error)

+ func (s *NativeGitRolloutService) SetNativeMergeWorktreeOverride(ctx context.Context, ...) (*connect.Response[sessionv1.NativeGitRolloutStatus], error)

+ func (s *NativeGitRolloutService) SetNativeWorktreeGlobalOverride(ctx context.Context, ...) (*connect.Response[sessionv1.NativeGitRolloutStatus], error)

+ func (s *NativeGitRolloutService) SetNativeWorktreeSessionOverride(ctx context.Context, ...) (*connect.Response[sessionv1.NativeGitRolloutStatus], error)

type RulesService

+ func (rs *RulesService) SetApprovalService(as reconciliationResolver)

type SessionService

+ func (s *SessionService) GetTmuxVersionStatus(_ context.Context, _ *connect.Request[sessionv1.GetTmuxVersionStatusRequest]) (*connect.Response[sessionv1.GetTmuxVersionStatusResponse], error)

+ func (s *SessionService) RestartTmuxServer(_ context.Context, req *connect.Request[sessionv1.RestartTmuxServerRequest]) (*connect.Response[sessionv1.RestartTmuxServerResponse], error)

Sep 7, 2026

Changes in this version

+ var ErrJulesDispatchInFlight = errors.New("jules: dispatch already in flight for this item")

+ var ErrJulesEgressNotAcknowledged = errors.New("egress consent not acknowledged for this repository")

+ func TrackOpenStream(method string) (done func())

type AnalyticsEntry

+ Source string

type ApprovalHandler

+ func (h *ApprovalHandler) HandlePiExtensionLoaded(w http.ResponseWriter, r *http.Request)

+ func (h *ApprovalHandler) SetPiExtensionHealthTracker(t *PiExtensionHealthTracker)

type BacklogService

+ func (s *BacklogService) CreateLivenessDefinition(ctx context.Context, ...) (*connect.Response[sessionv1.CreateLivenessDefinitionResponse], error)

+ func (s *BacklogService) CreateStage(ctx context.Context, req *connect.Request[sessionv1.CreateStageRequest]) (*connect.Response[sessionv1.CreateStageResponse], error)

+ func (s *BacklogService) CreateStageTransition(ctx context.Context, ...) (*connect.Response[sessionv1.CreateStageTransitionResponse], error)

+ func (s *BacklogService) CreateTransitionGate(ctx context.Context, ...) (*connect.Response[sessionv1.CreateTransitionGateResponse], error)

+ func (s *BacklogService) DeleteLivenessDefinition(ctx context.Context, ...) (*connect.Response[sessionv1.DeleteLivenessDefinitionResponse], error)

+ func (s *BacklogService) DeleteStage(ctx context.Context, req *connect.Request[sessionv1.DeleteStageRequest]) (*connect.Response[sessionv1.DeleteStageResponse], error)

+ func (s *BacklogService) DeleteStageTransition(ctx context.Context, ...) (*connect.Response[sessionv1.DeleteStageTransitionResponse], error)

+ func (s *BacklogService) DeleteTransitionGate(ctx context.Context, ...) (*connect.Response[sessionv1.DeleteTransitionGateResponse], error)

+ func (s *BacklogService) DispatchToJules(ctx context.Context, req *connect.Request[sessionv1.DispatchToJulesRequest]) (*connect.Response[sessionv1.DispatchToJulesResponse], error)

+ func (s *BacklogService) GetLivenessDefinition(ctx context.Context, ...) (*connect.Response[sessionv1.GetLivenessDefinitionResponse], error)

+ func (s *BacklogService) GetStage(ctx context.Context, req *connect.Request[sessionv1.GetStageRequest]) (*connect.Response[sessionv1.GetStageResponse], error)

+ func (s *BacklogService) GetStageTransition(ctx context.Context, req *connect.Request[sessionv1.GetStageTransitionRequest]) (*connect.Response[sessionv1.GetStageTransitionResponse], error)

+ func (s *BacklogService) GetTransitionGate(ctx context.Context, req *connect.Request[sessionv1.GetTransitionGateRequest]) (*connect.Response[sessionv1.GetTransitionGateResponse], error)

+ func (s *BacklogService) ListLivenessDefinitions(ctx context.Context, ...) (*connect.Response[sessionv1.ListLivenessDefinitionsResponse], error)

+ func (s *BacklogService) ListStageTransitions(ctx context.Context, ...) (*connect.Response[sessionv1.ListStageTransitionsResponse], error)

+ func (s *BacklogService) ListStages(ctx context.Context, _ *connect.Request[sessionv1.ListStagesRequest]) (*connect.Response[sessionv1.ListStagesResponse], error)

+ func (s *BacklogService) ListTransitionGates(ctx context.Context, ...) (*connect.Response[sessionv1.ListTransitionGatesResponse], error)

+ func (s *BacklogService) RecordGateApproval(ctx context.Context, req *connect.Request[sessionv1.RecordGateApprovalRequest]) (*connect.Response[sessionv1.RecordGateApprovalResponse], error)

+ func (s *BacklogService) SetGateSatisfactionRepository(repo session.GateSatisfactionRepository)

+ func (s *BacklogService) SetJulesDispatcher(d JulesDispatcher)

+ func (s *BacklogService) SetLivenessEngine(engine session.LivenessEngine)

+ func (s *BacklogService) SetLivenessRepository(repo session.LivenessRepository)

+ func (s *BacklogService) SetStageCRUDRepository(repo session.StageCRUDRepository)

+ func (s *BacklogService) SetStageConfigEngine(engine stageConfigCacheInvalidator)

+ func (s *BacklogService) UpdateLivenessDefinition(ctx context.Context, ...) (*connect.Response[sessionv1.UpdateLivenessDefinitionResponse], error)

+ func (s *BacklogService) UpdateStage(ctx context.Context, req *connect.Request[sessionv1.UpdateStageRequest]) (*connect.Response[sessionv1.UpdateStageResponse], error)

+ func (s *BacklogService) UpdateStageTransition(ctx context.Context, ...) (*connect.Response[sessionv1.UpdateStageTransitionResponse], error)

+ func (s *BacklogService) UpdateTransitionGate(ctx context.Context, ...) (*connect.Response[sessionv1.UpdateTransitionGateResponse], error)

type CredentialChain

+ func (c *CredentialChain) SetJulesTokenSource(tokens julesKeyringTokenSource)

type HookName

+ const HookExtensionHealth

+ type JulesConfigService struct

+ func NewJulesConfigService(keys julesKeyManager, sources julesSourceResolver, ...) *JulesConfigService

+ func (s *JulesConfigService) ConfirmEgressConsent(ctx context.Context, ...) (*connect.Response[sessionv1.ConfirmEgressConsentResponse], error)

+ func (s *JulesConfigService) GetJulesConfig(ctx context.Context, req *connect.Request[sessionv1.GetJulesConfigRequest]) (*connect.Response[sessionv1.GetJulesConfigResponse], error)

+ func (s *JulesConfigService) RevokeEgressConsent(ctx context.Context, ...) (*connect.Response[sessionv1.RevokeEgressConsentResponse], error)

+ func (s *JulesConfigService) SetPoller(poller julesAuthReconnectReporter)

+ func (s *JulesConfigService) SetUsageCounter(usage julesUsageSnapshotter)

+ func (s *JulesConfigService) TestJulesConnection(ctx context.Context, ...) (*connect.Response[sessionv1.TestJulesConnectionResponse], error)

+ func (s *JulesConfigService) UpdateJulesConfig(ctx context.Context, req *connect.Request[sessionv1.UpdateJulesConfigRequest]) (*connect.Response[sessionv1.UpdateJulesConfigResponse], error)

+ type JulesCredentialSource struct

+ func (s *JulesCredentialSource) Name() string

+ func (s *JulesCredentialSource) Resolve(ctx context.Context, provider string) (Credential, bool, error)

+ type JulesDispatchRequest struct

+ Branch jules.GitHubBranchRef

+ ItemID string

+ Prompt string

+ func NewJulesDispatchRequest(itemID, branch, prompt string) (JulesDispatchRequest, error)

+ type JulesDispatchService struct

+ func NewJulesDispatchService(storage *session.Storage, transitionGuard julesTransitionGuard, ...) *JulesDispatchService

+ func (s *JulesDispatchService) DispatchToJules(ctx context.Context, item *session.BacklogItemData, req JulesDispatchRequest) (jules.JulesSessionName, error)

+ func (s *JulesDispatchService) SetUsageCounter(usage julesUsageRecorder)

+ type JulesDispatcher interface

+ DispatchToJules func(ctx context.Context, item *session.BacklogItemData, req JulesDispatchRequest) (jules.JulesSessionName, error)

+ type JulesUsageCounter struct

+ func NewJulesUsageCounter() *JulesUsageCounter

+ func (c *JulesUsageCounter) IncAPIError()

+ func (c *JulesUsageCounter) IncAPIRateLimited()

+ func (c *JulesUsageCounter) IncSessionCompleted()

+ func (c *JulesUsageCounter) IncSessionDispatched()

+ func (c *JulesUsageCounter) IncSessionFailed()

+ func (c *JulesUsageCounter) Snapshot() JulesUsageSnapshot

+ type JulesUsageSnapshot struct

+ APIError int64

+ APIRateLimited int64

+ SessionCompleted int64

+ SessionDispatched int64

+ SessionFailed int64

+ type PiExtensionHealth int

+ const PiExtensionHealthFailed

+ const PiExtensionHealthLoaded

+ const PiExtensionHealthUnknown

+ func (h PiExtensionHealth) String() string

+ type PiExtensionHealthTracker struct

+ func NewPiExtensionHealthTracker() *PiExtensionHealthTracker

+ func (t *PiExtensionHealthTracker) Forget(sessionID string)

+ func (t *PiExtensionHealthTracker) HealthFor(sessionID string) PiExtensionHealth

+ func (t *PiExtensionHealthTracker) RecordPing(sessionID string)

+ type PiExtensionStatusService struct

+ func NewPiExtensionStatusService() *PiExtensionStatusService

+ func (s *PiExtensionStatusService) HandlePiExtensionStatus(w http.ResponseWriter, r *http.Request)

type SessionService

+ func (s *SessionService) ConfirmEgressConsent(ctx context.Context, ...) (*connect.Response[sessionv1.ConfirmEgressConsentResponse], error)

+ func (s *SessionService) GetJulesConfig(ctx context.Context, req *connect.Request[sessionv1.GetJulesConfigRequest]) (*connect.Response[sessionv1.GetJulesConfigResponse], error)

+ func (s *SessionService) RevokeEgressConsent(ctx context.Context, ...) (*connect.Response[sessionv1.RevokeEgressConsentResponse], error)

+ func (s *SessionService) SetJulesConfigDependencies(keys julesKeyManager, sources julesSourceResolver, ...)

+ func (s *SessionService) SetJulesKeyringTokenSource(tokens julesKeyringTokenSource)

+ func (s *SessionService) SetJulesUsageCounter(usage julesUsageSnapshotter)

+ func (s *SessionService) TestJulesConnection(ctx context.Context, ...) (*connect.Response[sessionv1.TestJulesConnectionResponse], error)

+ func (s *SessionService) UpdateJulesConfig(ctx context.Context, req *connect.Request[sessionv1.UpdateJulesConfigRequest]) (*connect.Response[sessionv1.UpdateJulesConfigResponse], error)

type TymuxRolloutService

+ func (s *TymuxRolloutService) SetTymuxGlobalOverride(ctx context.Context, ...) (*connect.Response[sessionv1.TymuxRolloutStatus], error)

Sep 3, 2026

Changes in this version

+ const SessionCreationOutcomeCancelled

+ const SessionCreationOutcomeFailed

+ const SessionCreationOutcomeStale

+ const SessionCreationOutcomeSuccess

+ var ErrCreationAwaitTimeout = errors.New("timed out waiting for session creation to reach a terminal status")

+ var ErrCreationVanished = errors.New("session creation was cancelled while waiting for it to complete")

+ func RecordSessionCreationMetrics(ctx context.Context, outcome string, duration time.Duration)

+ type CreationOutcome struct

+ FailureReason string

+ InstanceID string

+ Status session.Status

type SessionService

+ func (s *SessionService) AwaitCreationTerminal(ctx context.Context, instanceID string, timeout time.Duration) (CreationOutcome, error)

+ func (s *SessionService) CancelSessionCreation(ctx context.Context, ...) (*connect.Response[sessionv1.CancelSessionCreationResponse], error)

+ func (s *SessionService) RetrySessionCreation(ctx context.Context, ...) (*connect.Response[sessionv1.RetrySessionCreationResponse], error)

+ type StaleCreationSweeper struct

+ func NewStaleCreationSweeper(poller *session.ReviewQueuePoller, storage terminalStatusStore, ...) *StaleCreationSweeper

+ func (s *StaleCreationSweeper) Start(ctx context.Context)

Aug 30, 2026

Changes in this version

type SessionService

+ func (s *SessionService) IsRetryPending(sessionUUID string) bool

+ func (s *SessionService) RetrySession(ctx context.Context, req *connect.Request[sessionv1.RetrySessionRequest]) (*connect.Response[sessionv1.RetrySessionResponse], error)

type SessionStopper

+ IsRetryPending func(sessionUUID string) bool

Aug 29, 2026

Changes in this version

type BacklogService

+ func (s *BacklogService) AutoReopenForPRFixWithKnownSession(ctx context.Context, itemID, fixContext string, ...) error

+ func (s *BacklogService) GetSessionSteerer() SessionSteerer

+ func (s *BacklogService) GetSessionStopper() SessionStopper

+ func (s *BacklogService) HasActiveWorkSession(ctx context.Context, itemID string) (*session.ItemSessionSummary, error)

+ func (s *BacklogService) SetSessionSteerer(steerer SessionSteerer)

+ type HandoffSummaryFeatureController struct

+ func (HandoffSummaryFeatureController) Disable() error

+ func (HandoffSummaryFeatureController) Enable(context.Context) error

+ func (HandoffSummaryFeatureController) IsEnabled() bool

+ type HandoffSummaryService struct

+ func NewHandoffSummaryService(generator *session.HandoffSummaryGenerator) *HandoffSummaryService

+ func (s *HandoffSummaryService) GetHandoffSummary(ctx context.Context, req *connect.Request[sessionv1.GetHandoffSummaryRequest]) (*connect.Response[sessionv1.GetHandoffSummaryResponse], error)

+ func (s *HandoffSummaryService) TriggerHandoffSummary(ctx context.Context, ...) (*connect.Response[sessionv1.TriggerHandoffSummaryResponse], error)

type LogLevelHandler

+ func (h *LogLevelHandler) HandleClearPackage(w http.ResponseWriter, r *http.Request)

+ func (h *LogLevelHandler) HandleGetPackages(w http.ResponseWriter, _ *http.Request)

+ func (h *LogLevelHandler) HandleSetPackage(w http.ResponseWriter, r *http.Request)

+ type MemoryPressureNotifier struct

+ func NewMemoryPressureNotifier(poller *session.ReviewQueuePoller, eventBus *events.EventBus) *MemoryPressureNotifier

+ func (n *MemoryPressureNotifier) Start(ctx context.Context)

+ type PRFixEventRouter interface

+ TriggerPRFixForEvent func(ctx context.Context, repoFullName string, prNumber int) (matched bool, err error)

type SessionService

+ func (s *SessionService) IsReadyForSteer(sessionUUID string) bool

+ func (s *SessionService) SessionProgram(sessionUUID string) (string, bool)

+ func (s *SessionService) SetStreamHubGlobalOverride(ctx context.Context, ...) (*connect.Response[sessionv1.StreamHubRolloutStatus], error)

+ func (s *SessionService) SteerActiveSession(ctx context.Context, sessionUUID, message string) error

+ type SessionSteerer interface

+ IsReadyForSteer func(sessionUUID string) bool

+ SessionProgram func(sessionUUID string) (program string, ok bool)

+ SteerActiveSession func(ctx context.Context, sessionUUID, message string) error

type StreamHubRolloutService

+ func (s *StreamHubRolloutService) SetStreamHubGlobalOverride(ctx context.Context, ...) (*connect.Response[sessionv1.StreamHubRolloutStatus], error)

+ type TymuxRolloutService struct

+ func NewTymuxRolloutService() *TymuxRolloutService

+ func (s *TymuxRolloutService) CompleteTymuxRollbackRehearsal(ctx context.Context, ...) (*connect.Response[sessionv1.TymuxRolloutStatus], error)

+ func (s *TymuxRolloutService) GetTymuxRolloutStatus(ctx context.Context, ...) (*connect.Response[sessionv1.TymuxRolloutStatus], error)

+ func (s *TymuxRolloutService) SetTymuxSessionOverride(ctx context.Context, ...) (*connect.Response[sessionv1.TymuxRolloutStatus], error)

Aug 23, 2026

Changes in this version

type SessionService

+ func (s *SessionService) CompleteStreamHubRollbackRehearsal(ctx context.Context, ...) (*connect.Response[sessionv1.StreamHubRolloutStatus], error)

+ func (s *SessionService) GetStreamHubRolloutStatus(ctx context.Context, ...) (*connect.Response[sessionv1.StreamHubRolloutStatus], error)

+ func (s *SessionService) SetStreamHubSessionOverride(ctx context.Context, ...) (*connect.Response[sessionv1.StreamHubRolloutStatus], error)

+ type StreamHubRolloutService struct

+ func NewStreamHubRolloutService() *StreamHubRolloutService

+ func (s *StreamHubRolloutService) CompleteStreamHubRollbackRehearsal(ctx context.Context, ...) (*connect.Response[sessionv1.StreamHubRolloutStatus], error)

+ func (s *StreamHubRolloutService) GetStreamHubRolloutStatus(ctx context.Context, ...) (*connect.Response[sessionv1.StreamHubRolloutStatus], error)

+ func (s *StreamHubRolloutService) SetStreamHubSessionOverride(ctx context.Context, ...) (*connect.Response[sessionv1.StreamHubRolloutStatus], error)

Aug 22, 2026

Changes in this version

+ const HubStartFailedErrorCode

+ var HubRegistry = &hubRegistry

+ func BuildRemoteHealthProber(ctx context.Context, remote *config.RemoteConfig, pool *tmux.SSHClientPool, ...) (*sshremote.RemoteHealthProber, error)

+ func InjectHookConfigRemote(ctx context.Context, runner tmux.CommandRunner, rootDir, sessionID string, ...) error

+ func NewRegistryHostResolver(stateDir string, ttl time.Duration) *registryHostResolver

+ type ClaudeSettingsPathResult struct

+ Err error

+ Label string

+ Path string

+ Priority int

+ Rules []classifier.Rule

+ func LoadClaudeSettingsRulesDetailed(projectDir string) []ClaudeSettingsPathResult

+ type ClaudeSettingsWatcher struct

+ func NewClaudeSettingsWatcher(projectDir string, ...) *ClaudeSettingsWatcher

+ func (w *ClaudeSettingsWatcher) Reload(ctx context.Context) (ruleCount int, failedPaths []string)

+ func (w *ClaudeSettingsWatcher) Start(ctx context.Context)

+ func (w *ClaudeSettingsWatcher) Stopped() <-chan struct{}

+ type DeepLinkResolver struct

+ func NewDeepLinkResolver(items backlogItemGetter, hostResolver HostResolver) *DeepLinkResolver

+ func (d *DeepLinkResolver) HandleResolve(w http.ResponseWriter, r *http.Request)

+ func (d *DeepLinkResolver) RegisterRoutes(mux *http.ServeMux)

+ type HostResolver interface

+ ResolveHost func(hostname string) (advertisedAddress string, lastSeenAt string, reachable bool, ok bool)

+ type InjectHookOption func(*injectHookOptions)

+ func WithRemoteHookTarget(target RemoteHookTarget) InjectHookOption

+ type PRCreationService struct

+ func NewPRCreationService(storage session.InstanceStore, eventBus *events.EventBus, ...) *PRCreationService

+ func (s *PRCreationService) CreatePullRequest(ctx context.Context, req *connect.Request[sessionv1.CreatePullRequestRequest]) (*connect.Response[sessionv1.CreatePullRequestResponse], error)

+ func (s *PRCreationService) DraftPullRequest(ctx context.Context, req *connect.Request[sessionv1.DraftPullRequestRequest]) (*connect.Response[sessionv1.DraftPullRequestResponse], error)

+ func (s *PRCreationService) SetBacklogLifecycleListener(l *session.BacklogLifecycleListener)

+ func (s *PRCreationService) SetHeadlessPool(pool *headless.Pool)

+ type RemoteHookTarget struct

+ BearerToken string

+ SocketPath string

+ type RemoteService struct

+ func NewRemoteService(knownHosts *sshremote.KnownHostsStore, keyStore *sshremote.KeyStore, ...) *RemoteService

+ func (s *RemoteService) CreateRemote(ctx context.Context, req *connect.Request[sessionv1.CreateRemoteRequest]) (*connect.Response[sessionv1.CreateRemoteResponse], error)

+ func (s *RemoteService) DeleteRemote(ctx context.Context, req *connect.Request[sessionv1.DeleteRemoteRequest]) (*connect.Response[sessionv1.DeleteRemoteResponse], error)

+ func (s *RemoteService) GenerateRemoteIdentity(ctx context.Context, ...) (*connect.Response[sessionv1.GenerateRemoteIdentityResponse], error)

+ func (s *RemoteService) ListRemotes(ctx context.Context, req *connect.Request[sessionv1.ListRemotesRequest]) (*connect.Response[sessionv1.ListRemotesResponse], error)

+ func (s *RemoteService) TestRemoteConnection(ctx context.Context, ...) (*connect.Response[sessionv1.TestRemoteConnectionResponse], error)

+ func (s *RemoteService) TrustRemoteHostKey(ctx context.Context, req *connect.Request[sessionv1.TrustRemoteHostKeyRequest]) (*connect.Response[sessionv1.TrustRemoteHostKeyResponse], error)

type RulesService

+ func (rs *RulesService) ReloadClaudeSettingsRules(ctx context.Context, ...) (*connect.Response[sessionv1.ReloadClaudeSettingsRulesResponse], error)

+ func (rs *RulesService) SetClaudeSettingsWatcher(w *ClaudeSettingsWatcher)

type SessionService

+ func (s *SessionService) CreatePullRequest(ctx context.Context, req *connect.Request[sessionv1.CreatePullRequestRequest]) (*connect.Response[sessionv1.CreatePullRequestResponse], error)

+ func (s *SessionService) DraftPullRequest(ctx context.Context, req *connect.Request[sessionv1.DraftPullRequestRequest]) (*connect.Response[sessionv1.DraftPullRequestResponse], error)

+ func (s *SessionService) GetClaudeSettingsWatcher() *ClaudeSettingsWatcher

+ func (s *SessionService) ReloadClaudeSettingsRules(ctx context.Context, ...) (*connect.Response[sessionv1.ReloadClaudeSettingsRulesResponse], error)

+ func (s *SessionService) SetPermissionRequestHandler(handler sshremote.PermissionRequestHandler)

+ func (s *SessionService) SetRemoteDeps(keyStore *sshremote.KeyStore, knownHosts *sshremote.KnownHostsStore)

+ type WebSocketTransport struct

+ func NewWebSocketTransport(stream *connectWebSocketStream) *WebSocketTransport

+ func (t *WebSocketTransport) BindSubscriber(hub *streamhub.StreamHub, id streamhub.SubscriberID)

+ func (t *WebSocketTransport) Close() error

+ func (t *WebSocketTransport) Send(data []byte) error

+ func (t *WebSocketTransport) SuppressNextSend()

Aug 20, 2026

Changes in this version

type SessionService

+ func (s *SessionService) SetDeleteSessionCleanupTimeout(d time.Duration)

Aug 19, 2026

Changes in this version

type BacklogService

+ func (s *BacklogService) EnterpriseHosts() []string

Aug 16, 2026

Changes in this version

type ApprovalHandler

+ func (h *ApprovalHandler) SetDashboardBaseURLFn(fn func() string)

+ func (h *ApprovalHandler) SetSlackNotifier(n *SlackNotifier)

+ func (h *ApprovalHandler) SlackNotifierForTest() *SlackNotifier

type BacklogService

+ func (s *BacklogService) UnarchiveBacklogItem(ctx context.Context, ...) (*connect.Response[sessionv1.UnarchiveBacklogItemResponse], error)

+ type ResyncOptions struct

+ EchoResyncID bool

+ SkipStaleDimensionSlowPath bool

+ UseFastLane bool

type RuleSpec

+ MinSessionIdleMinutes int32

type SessionService

+ func (s *SessionService) GetSlackConfig(ctx context.Context, req *connect.Request[sessionv1.GetSlackConfigRequest]) (*connect.Response[sessionv1.GetSlackConfigResponse], error)

+ func (s *SessionService) SetSlackNotifier(n *SlackNotifier)

+ func (s *SessionService) SlackNotifierForTest() *SlackNotifier

+ func (s *SessionService) TestSlackWebhook(ctx context.Context, req *connect.Request[sessionv1.TestSlackWebhookRequest]) (*connect.Response[sessionv1.TestSlackWebhookResponse], error)

+ func (s *SessionService) UpdateSlackConfig(ctx context.Context, req *connect.Request[sessionv1.UpdateSlackConfigRequest]) (*connect.Response[sessionv1.UpdateSlackConfigResponse], error)

+ type SlackConfigService struct

+ func NewSlackConfigService(n *SlackNotifier) *SlackConfigService

+ func (s *SlackConfigService) GetSlackConfig(ctx context.Context, req *connect.Request[sessionv1.GetSlackConfigRequest]) (*connect.Response[sessionv1.GetSlackConfigResponse], error)

+ func (s *SlackConfigService) TestSlackWebhook(ctx context.Context, req *connect.Request[sessionv1.TestSlackWebhookRequest]) (*connect.Response[sessionv1.TestSlackWebhookResponse], error)

+ func (s *SlackConfigService) UpdateSlackConfig(ctx context.Context, req *connect.Request[sessionv1.UpdateSlackConfigRequest]) (*connect.Response[sessionv1.UpdateSlackConfigResponse], error)

+ type SlackInteractiveHandler struct

+ func NewSlackInteractiveHandler(resolver approvalResolver) *SlackInteractiveHandler

+ func (h *SlackInteractiveHandler) Handle(w http.ResponseWriter, r *http.Request)

+ type SlackInteractivePayload struct

+ Actions []struct{ ... }

+ User struct{ ... }

+ type SlackNotifier struct

+ func NewSlackNotifier() *SlackNotifier

+ func (n *SlackNotifier) GetDeliveryStatus() (attempted, success bool, errMsg string, at time.Time)

+ func (n *SlackNotifier) MaybeNotifyQueueDepthThreshold(ctx context.Context, cfg *config.Config, depth, threshold int, ...) (fired bool)

+ func (n *SlackNotifier) NotifyApprovalPending(ctx context.Context, cfg *config.Config, approval *PendingApproval, ...)

+ func (n *SlackNotifier) NotifyReviewQueueItem(ctx context.Context, cfg *config.Config, item *session.ReviewItem, ...)

+ type StaleSessionNotifier struct

+ func NewStaleSessionNotifier(poller *session.ReviewQueuePoller, eventBus *events.EventBus) *StaleSessionNotifier

+ func (n *StaleSessionNotifier) Start(ctx context.Context)

Aug 14, 2026

Changes in this version

+ const MaxWebhookBodyBytes

+ func ValidateCallbackURL(ctx context.Context, rawURL string) error

+ func VerifyGitHubSignature(secret string, body []byte, sigHeader string) bool

+ func VerifyWebhookSecret(secret string, body []byte, sigHeader string) bool

type BacklogService

+ func (s *BacklogService) AddBacklogItemDependency(ctx context.Context, ...) (*connect.Response[sessionv1.AddBacklogItemDependencyResponse], error)

+ func (s *BacklogService) Admit(ctx context.Context) (bool, error)

+ func (s *BacklogService) CreateBacklogItemFromChat(ctx context.Context, ...) (*connect.Response[sessionv1.CreateBacklogItemFromChatResponse], error)

+ type CallbackConfigService struct

+ func NewCallbackConfigService() *CallbackConfigService

+ func (c *CallbackConfigService) GetCallbackConfig(ctx context.Context, req *connect.Request[sessionv1.GetCallbackConfigRequest]) (*connect.Response[sessionv1.GetCallbackConfigResponse], error)

+ func (c *CallbackConfigService) SetSharedCallbackConfig(cfg *config.Config, mu *sync.RWMutex)

+ func (c *CallbackConfigService) UpdateCallbackConfig(ctx context.Context, ...) (*connect.Response[sessionv1.UpdateCallbackConfigResponse], error)

+ type CallbackDispatcher struct

+ func NewCallbackDispatcher(cfg *config.Config) *CallbackDispatcher

+ func (d *CallbackDispatcher) ConfigMu() *sync.RWMutex

+ func (d *CallbackDispatcher) Dispatch(eventType string, payload any)

+ type GenericWebhookHandler struct

+ func NewGenericWebhookHandler(repo session.WorkflowRepository, scheduler *workflows.Scheduler, ...) *GenericWebhookHandler

+ func (h *GenericWebhookHandler) Handle(w http.ResponseWriter, r *http.Request)

+ func (h *GenericWebhookHandler) RegisterRoutes(mux *http.ServeMux)

+ type GitHubWebhookHandler struct

+ func NewGitHubWebhookHandler(repo session.WorkflowRepository, scheduler *workflows.Scheduler, ...) *GitHubWebhookHandler

+ func (h *GitHubWebhookHandler) Handle(w http.ResponseWriter, r *http.Request)

+ func (h *GitHubWebhookHandler) RegisterRoutes(mux *http.ServeMux)

type SessionService

+ func (s *SessionService) GetCallbackConfig(ctx context.Context, req *connect.Request[sessionv1.GetCallbackConfigRequest]) (*connect.Response[sessionv1.GetCallbackConfigResponse], error)

+ func (s *SessionService) ListTriggerFireEvents(ctx context.Context, ...) (*connect.Response[sessionv1.ListTriggerFireEventsResponse], error)

+ func (s *SessionService) SetSharedCallbackConfig(cfg *config.Config, mu *sync.RWMutex)

+ func (s *SessionService) UpdateCallbackConfig(ctx context.Context, ...) (*connect.Response[sessionv1.UpdateCallbackConfigResponse], error)

+ type TriggerRateLimiter struct

+ func NewTriggerRateLimiter() *TriggerRateLimiter

+ func (t *TriggerRateLimiter) Allow(workflowID uuid.UUID) bool

type WorkflowService

+ func (s *WorkflowService) ListTriggerFireEvents(ctx context.Context, ...) (*connect.Response[sessionv1.ListTriggerFireEventsResponse], error)

+ func (ws *WorkflowService) SetTriggerFireEventRepo(repo session.TriggerFireEventRepository)

Aug 13, 2026

Changes in this version

type AnalyticsSummary

+ RiskLevelCounts map[string]int

type BacklogService

+ func (s *BacklogService) RejectPlan(ctx context.Context, req *connect.Request[sessionv1.RejectPlanRequest]) (*connect.Response[sessionv1.RejectPlanResponse], error)

type FeatureFlagService

+ func (f *FeatureFlagService) SetStatusDetailProvider(name string, fn func() string)

+ type HeadroomEstimate struct

+ AssumedBudget int64

+ PctRemaining float64

+ TokensUsed int64

+ Valid bool

+ WindowEnd time.Time

+ WindowStart time.Time

+ type ImportService struct

+ func NewImportService(detector *session.HistoryFileDetector, inspector ProcessCreateTimeReader) *ImportService

+ func NewImportServiceWithRealInspector(storage session.InstanceStore, registry *session.Registry, ...) *ImportService

+ func (s *ImportService) CancelPendingKill(ctx context.Context, req *connect.Request[sessionv1.CancelPendingKillRequest]) (*connect.Response[sessionv1.CancelPendingKillResponse], error)

+ func (s *ImportService) CommitImportExternalSession(ctx context.Context, ...) (*connect.Response[sessionv1.CommitImportExternalSessionResponse], error)

+ func (s *ImportService) ConfirmKillExternalSession(ctx context.Context, ...) (*connect.Response[sessionv1.ConfirmKillExternalSessionResponse], error)

+ func (s *ImportService) PreviewImportExternalSession(ctx context.Context, ...) (*connect.Response[sessionv1.PreviewImportExternalSessionResponse], error)

+ type LauncherPresetsService struct

+ func NewLauncherPresetsService() *LauncherPresetsService

+ func (s *LauncherPresetsService) GetLauncherPresets(ctx context.Context, req *connect.Request[sessionv1.GetLauncherPresetsRequest]) (*connect.Response[sessionv1.GetLauncherPresetsResponse], error)

type PendingApproval

+ RiskLevel string

type PersistedApproval

+ RiskLevel string

+ type ProcessCreateTimeReader interface

+ CreateTime func(pid int32) (int64, error)

+ type QuotaGate struct

+ func NewQuotaGate(cfgFn func() config.QuotaConfig, tokenStore tokens.TokenStoreReader, ...) *QuotaGate

+ func (g *QuotaGate) IsPausedByQuota() bool

+ func (g *QuotaGate) Reconcile(ctx context.Context)

+ func (g *QuotaGate) ShouldThrottleForeground() bool

+ func (g *QuotaGate) StatusDetail() string

+ type RateLimitAggregate struct

+ LastEventAt time.Time

type SessionService

+ func NewSessionServiceWithSearchEngine(storage session.InstanceStore, eventBus *events.EventBus, ...) *SessionService

+ func (s *SessionService) GetEscapeAnalyticsGlobalSummary(ctx context.Context, ...) (*connect.Response[sessionv1.GetEscapeAnalyticsGlobalSummaryResponse], error)

+ func (s *SessionService) GetLauncherPresets(ctx context.Context, req *connect.Request[sessionv1.GetLauncherPresetsRequest]) (*connect.Response[sessionv1.GetLauncherPresetsResponse], error)

+ func (s *SessionService) SetQuotaGate(g *QuotaGate)

+ func (s *SessionService) SetStatusDetailProvider(name string, fn func() string)

Aug 10, 2026

Changes in this version

+ func HasActiveReviewSession(priorSessions []session.ItemSessionSummary) bool

+ func RemoveHooksConfig(rootDir string, hooks []HookName) error

+ func StartBacklogGitHubForwardSyncSubscriber(ctx context.Context, bus *events.EventBus, registry *session.PluginRegistry, ...)

type AnalyticsStore

+ func (s *AnalyticsStore) Stop()

type AnalyticsSummary

+ EscalationReasonCounts map[string]int

type ApprovalHandler

+ func (h *ApprovalHandler) SetLiveInstanceFinder(f LiveInstanceFinder)

+ func (h *ApprovalHandler) SetPollInterval(d time.Duration)

type ApprovalService

+ func (as *ApprovalService) SetLiveInstanceFinder(f LiveInstanceFinder)

+ type BacklogDebugMutateHandler struct

+ func NewBacklogDebugMutateHandler(storage *session.Storage) *BacklogDebugMutateHandler

+ func (h *BacklogDebugMutateHandler) RegisterRoutes(mux *http.ServeMux)

+ type BacklogItemEventPublisher struct

+ Bus *events.EventBus

+ func (p *BacklogItemEventPublisher) PublishItemChanged(item *session.BacklogItemData, change session.BacklogItemChange)

type BacklogService

+ func (s *BacklogService) AutoRespawnTriage(ctx context.Context, itemID string) error

+ func (s *BacklogService) ConfigMu() *sync.RWMutex

+ func (s *BacklogService) DequeueNextQueuedItems(ctx context.Context) error

+ func (s *BacklogService) IsTriageLive(itemID string) bool

+ func (s *BacklogService) MaybeTriggerTriage(ctx context.Context, itemID string, skipTriage bool, repoPath string) bool

+ func (s *BacklogService) PreviewBackwardSyncImpact(ctx context.Context, ...) (*connect.Response[sessionv1.PreviewBackwardSyncImpactResponse], error)

+ func (s *BacklogService) Registry() *session.PluginRegistry

+ func (s *BacklogService) ResolveReworkBlockedStaleIfRecovered(ctx context.Context, itemID string) error

+ func (s *BacklogService) SetRepoWatchRemover(remover RepoWatchRemover)

+ func (s *BacklogService) SyncLoopForForwardSync() *session.SyncLoop

+ func (s *BacklogService) WatchBacklogItems(ctx context.Context, req *connect.Request[sessionv1.WatchBacklogItemsRequest], ...) error

type DefaultsService

+ func (d *DefaultsService) SetOnGlobalDefaultsUpdated(fn func())

+ func (d *DefaultsService) SetSharedBacklogConfig(cfg *config.Config, mu *sync.RWMutex)

type GitHubUserService

+ func (s *GitHubUserService) AddGitHubAccountFromCLI(ctx context.Context, ...) (*connect.Response[sessionv1.AddGitHubAccountWithTokenResponse], error)

+ func (s *GitHubUserService) AddGitHubAccountWithToken(ctx context.Context, ...) (*connect.Response[sessionv1.AddGitHubAccountWithTokenResponse], error)

+ func (s *GitHubUserService) ListGitHubCLIHosts(_ context.Context, _ *connect.Request[sessionv1.ListGitHubCLIHostsRequest]) (*connect.Response[sessionv1.ListGitHubCLIHostsResponse], error)

type HookName

+ const HookGitDriftCheck

type HookReceiver

+ func (h *HookReceiver) HandlePostToolUseDriftCheck(w http.ResponseWriter, r *http.Request)

+ func (h *HookReceiver) SetDriftCheckFn(fn func(worktreePath, mainBranch string) (int, error))

+ func (h *HookReceiver) SetDriftCheckMinInterval(d time.Duration)

+ func (h *HookReceiver) SetDriftThreshold(n int)

type InsightsService

+ func (s *InsightsService) GetSessionTurnTimeline(_ context.Context, ...) (*connect.Response[sessionv1.GetSessionTurnTimelineResponse], error)

type PendingApproval

+ EscalationCategory string

+ EscalationReason string

type PersistedApproval

+ EscalationCategory string

+ EscalationReason string

+ type RepoWatchRemover interface

+ RemoveRepo func(repoPath string)

type RuleSpec

+ RequireCIPassing bool

+ type SessionRetentionSweeper struct

+ func NewSessionRetentionSweeper(storage *session.Storage, cfg *config.Config, svc *SessionService) *SessionRetentionSweeper

+ func (s *SessionRetentionSweeper) Start(ctx context.Context)

type SessionService

+ func (s *SessionService) PreviewDestinationPath(ctx context.Context, ...) (*connect.Response[sessionv1.PreviewDestinationPathResponse], error)

+ func (s *SessionService) ResumeCrashedSession(ctx context.Context, ...) (*connect.Response[sessionv1.ResumeCrashedSessionResponse], error)

+ func (s *SessionService) SetOnGlobalDefaultsUpdated(fn func())

+ func (s *SessionService) SetSessionSummaryGenerator(g *session.SessionSummaryGenerator)

+ func (s *SessionService) SetSharedBacklogConfig(cfg *config.Config, mu *sync.RWMutex)

+ func (s *SessionService) SetTmuxStreamerManager(mgr *session.ExternalTmuxStreamerManager)

+ func (s *SessionService) SetUserPRCache(cache *githubpkg.UserPRCache)

+ func (s *SessionService) Shutdown()

+ func (s *SessionService) TimeSinceLastMeaningfulOutput(sessionUUID string) (time.Duration, bool)

type SessionStopper

+ TimeSinceLastMeaningfulOutput func(sessionUUID string) (dur time.Duration, ok bool)

+ type SessionSummaryService struct

+ func NewSessionSummaryService(generator *session.SessionSummaryGenerator, instances liveInstanceFinder) *SessionSummaryService

+ func (s *SessionSummaryService) GetSessionSummary(ctx context.Context, req *connect.Request[sessionv1.GetSessionSummaryRequest]) (*connect.Response[sessionv1.GetSessionSummaryResponse], error)

+ func (s *SessionSummaryService) RegenerateSessionSummary(ctx context.Context, ...) (*connect.Response[sessionv1.RegenerateSessionSummaryResponse], error)

Jul 21, 2026

Changes in this version

type AutonomousOrchestrationService

+ func (a *AutonomousOrchestrationService) SetAutonomousStuckRespawner(r AutonomousStuckRespawner)

+ type AutonomousStuckRespawner interface

+ AutoRespawnAutonomousWork func(ctx context.Context, itemID string) error

+ type BacklogAttachmentUploadHandler struct

+ func NewBacklogAttachmentUploadHandler(dir string) (*BacklogAttachmentUploadHandler, error)

+ func (h *BacklogAttachmentUploadHandler) HandleUpload(w http.ResponseWriter, r *http.Request)

type BacklogService

+ func (s *BacklogService) AutoRespawnAutonomousWork(ctx context.Context, itemID string) error

+ func (s *BacklogService) AutoRespawnReview(ctx context.Context, itemID string) error

+ func (s *BacklogService) BulkResetStuckRemediation(ctx context.Context, ...) (*connect.Response[sessionv1.BulkResetStuckRemediationResponse], error)

+ func (s *BacklogService) GetBacklogItemShipStatus(ctx context.Context, ...) (*connect.Response[sessionv1.GetBacklogItemShipStatusResponse], error)

+ func (s *BacklogService) RemediateStaleWorkSession(ctx context.Context, itemID string) error

+ func (s *BacklogService) ResetStuckRemediation(ctx context.Context, ...) (*connect.Response[sessionv1.ResetStuckRemediationResponse], error)

+ func (s *BacklogService) SetOneShotRunner(r PRRunner)

+ func (s *BacklogService) TriggerRemediationNow(ctx context.Context, ...) (*connect.Response[sessionv1.TriggerRemediationNowResponse], error)

+ func (s *BacklogService) TriggerShipPR(ctx context.Context, req *connect.Request[sessionv1.TriggerShipPRRequest]) (*connect.Response[sessionv1.TriggerShipPRResponse], error)

+ type PRRunner interface

+ RunOneShotForSession func(ctx context.Context, sessionID, prompt string, timeoutSeconds int32) (string, error)

type SessionService

+ func (s *SessionService) ArchiveSessionByUUID(ctx context.Context, sessionUUID string) error

+ func (s *SessionService) KillTmuxPaneOnly(ctx context.Context, sessionUUID string) error

+ func (s *SessionService) RunOneShotForSession(ctx context.Context, sessionID, prompt string, timeoutSeconds int32) (string, error)

+ func (s *SessionService) SetAutonomousStuckRespawner(r AutonomousStuckRespawner)

type SessionStopper

+ ArchiveSessionByUUID func(ctx context.Context, sessionUUID string) error

+ KillTmuxPaneOnly func(ctx context.Context, sessionUUID string) error

Jul 17, 2026

Changes in this version

+ type BacklogDebugSeedHandler struct

+ func NewBacklogDebugSeedHandler(storage *session.Storage) *BacklogDebugSeedHandler

+ func (h *BacklogDebugSeedHandler) RegisterRoutes(mux *http.ServeMux)

type BacklogService

+ func (s *BacklogService) CreatePipelineMode(ctx context.Context, req *connect.Request[sessionv1.CreatePipelineModeRequest]) (*connect.Response[sessionv1.CreatePipelineModeResponse], error)

+ func (s *BacklogService) DeletePipelineMode(ctx context.Context, req *connect.Request[sessionv1.DeletePipelineModeRequest]) (*connect.Response[sessionv1.DeletePipelineModeResponse], error)

+ func (s *BacklogService) GetPipelineMode(ctx context.Context, req *connect.Request[sessionv1.GetPipelineModeRequest]) (*connect.Response[sessionv1.GetPipelineModeResponse], error)

+ func (s *BacklogService) ListPipelineModes(ctx context.Context, _ *connect.Request[sessionv1.ListPipelineModesRequest]) (*connect.Response[sessionv1.ListPipelineModesResponse], error)

+ func (s *BacklogService) ListStuckBacklogItems(ctx context.Context, ...) (*connect.Response[sessionv1.ListStuckBacklogItemsResponse], error)

+ func (s *BacklogService) PipelineEngine() session.PipelineEngine

+ func (s *BacklogService) SetCapabilityCheck(c *headless.CodebaseReadCapabilitySelfCheck)

+ func (s *BacklogService) SetScrollbackManager(sm *scrollback.ScrollbackManager)

+ func (s *BacklogService) SnoozeStuckItem(ctx context.Context, req *connect.Request[sessionv1.SnoozeStuckItemRequest]) (*connect.Response[sessionv1.SnoozeStuckItemResponse], error)

+ func (s *BacklogService) UpdatePipelineMode(ctx context.Context, req *connect.Request[sessionv1.UpdatePipelineModeRequest]) (*connect.Response[sessionv1.UpdatePipelineModeResponse], error)

type SessionService

+ func (s *SessionService) GetBacklogLifecycleListener() *session.BacklogLifecycleListener

Jul 14, 2026

Changes in this version

+ func SetHookBaseURLFn(fn func() string)

type AutonomousOrchestrationService

+ func (a *AutonomousOrchestrationService) SetReviewGateTrigger(t ReviewGateTrigger)

+ func (a *AutonomousOrchestrationService) TriggerReviewForSession(sessionUUID string)

type BacklogService

+ func (s *BacklogService) AutoReopenAfterFailedReview(ctx context.Context, itemID string) error

+ func (s *BacklogService) AutoReopenForPRFix(ctx context.Context, itemID string, fixContext string) error

+ func (s *BacklogService) GetBacklogItemCost(ctx context.Context, req *connect.Request[sessionv1.GetBacklogItemCostRequest]) (*connect.Response[sessionv1.GetBacklogItemCostResponse], error)

+ func (s *BacklogService) GetBacklogItemDiff(ctx context.Context, req *connect.Request[sessionv1.GetBacklogItemDiffRequest]) (*connect.Response[sessionv1.GetBacklogItemDiffResponse], error)

+ func (s *BacklogService) GetSessionBacklogIndex(ctx context.Context, ...) (*connect.Response[sessionv1.GetSessionBacklogIndexResponse], error)

+ func (s *BacklogService) SetEventBus(b *events.EventBus)

+ func (s *BacklogService) SetTokenStore(ts tokens.TokenStoreReader, pt *tokens.PricingTable)

+ func (s *BacklogService) SubmitManualReview(ctx context.Context, req *connect.Request[sessionv1.SubmitManualReviewRequest]) (*connect.Response[sessionv1.SubmitManualReviewResponse], error)

+ type EventBusNotifier struct

+ Bus *events.EventBus

+ func (n *EventBusNotifier) Notify(itemID, title, message string, notificationType, priority int32)

+ type ReviewGateTrigger interface

+ TriggerReviewForSession func(workSessionUUID string)

type SearchService

+ func (ss *SearchService) SetResolveConversationUUID(fn func(ctx context.Context, tmuxUUID string) (string, error))

type SessionCreator

+ CreateWorktreeSession func(ctx context.Context, title, repoPath, worktreePath, prompt string, ...) (*session.Instance, error)

type SessionService

+ func (s *SessionService) CreateWorktreeSession(ctx context.Context, title, repoPath, worktreePath, prompt string, ...) (*session.Instance, error)

+ func (s *SessionService) SetResolveConversationUUID(fn func(ctx context.Context, tmuxUUID string) (string, error))

+ func (s *SessionService) SetReviewGateTrigger(t ReviewGateTrigger)

+ func (s *SessionService) TriggerReviewForSession(sessionUUID string)

Jul 6, 2026

Changes in this version

+ type AIClient interface

+ Complete func(ctx context.Context, systemPrompt, userPrompt string) (string, error)

+ func NewBestAvailableAIClient(anthropicAPIKey string, specs []CLIAgentSpec) (AIClient, string)

+ type AgyCredentialSource struct

+ HomeDirOverride string

+ func (s *AgyCredentialSource) Name() string

+ func (s *AgyCredentialSource) Resolve(_ context.Context, provider string) (Credential, bool, error)

+ type AnalyticsGap struct

+ Count int

+ Program string

+ RepresentativeCmds []string

+ ToolName string

type AnalyticsStore

+ func (s *AnalyticsStore) GetSubcommandBreakdown(ctx context.Context, program string, since time.Time) ([]session.SubcommandDecisionCount, error)

+ func (s *AnalyticsStore) ListRecentCommands(ctx context.Context, program, subcommand string, since time.Time, n int) ([]string, error)

+ func (s *AnalyticsStore) LoadProgramWindow(ctx context.Context, program string, since time.Time) ([]AnalyticsEntry, error)

+ type AnthropicAIClient struct

+ OnResponseHeaders func(http.Header)

+ func NewAnthropicAIClient(cred Credential) (*AnthropicAIClient, error)

+ func NewAnthropicAIClientFromKey(apiKey string) (*AnthropicAIClient, error)

+ func (c *AnthropicAIClient) Complete(ctx context.Context, systemPrompt, userPrompt string) (string, error)

+ type AnthropicLimitsClient struct

+ func NewAnthropicLimitsClient(chain *CredentialChain, model string) *AnthropicLimitsClient

+ func (c *AnthropicLimitsClient) ModelContextWindow(model string) int

+ func (c *AnthropicLimitsClient) Provider() string

+ func (c *AnthropicLimitsClient) QueryLimits(ctx context.Context) (ProviderLimits, error)

+ func (c *AnthropicLimitsClient) UpdateFromResponseHeaders(h http.Header, current ProviderLimits) ProviderLimits

type ApprovalHandler

+ func (h *ApprovalHandler) SetAutoApprovalLogger(l autoApprovalLogger)

+ func (h *ApprovalHandler) SetAutonomousChecker(fn func(string) bool)

+ func (h *ApprovalHandler) SetHeadlessPool(pool headlessPoolApprover)

type ApprovalService

+ func (as *ApprovalService) SetEventBus(bus *events.EventBus)

+ type AutonomousDriverStarter interface

+ StartAutonomousDriverForInstance func(inst *session.Instance)

+ StartAutonomousDriverWithTimeout func(inst *session.Instance, startupTimeout time.Duration)

+ type AutonomousOrchestrationService struct

+ func NewAutonomousOrchestrationService(pool *headless.Pool, bus *events.EventBus) *AutonomousOrchestrationService

+ func (a *AutonomousOrchestrationService) SetInstanceFinder(fn func(string) *session.Instance)

+ func (a *AutonomousOrchestrationService) SetLifecycleContext(ctx context.Context)

+ func (a *AutonomousOrchestrationService) SetPool(pool *headless.Pool)

+ func (a *AutonomousOrchestrationService) SetStorageGetter(fn func() *session.Storage)

+ func (a *AutonomousOrchestrationService) StartAutonomousDriverForInstance(inst *session.Instance)

+ func (a *AutonomousOrchestrationService) StartAutonomousDriverWithTimeout(inst *session.Instance, startupTimeout time.Duration)

+ func (a *AutonomousOrchestrationService) StopDriverForSession(sessionTitle string)

+ type BacklogService struct

+ func NewBacklogService(storage *session.Storage, creator SessionCreator, cfg *config.Config, ...) *BacklogService

+ func (s *BacklogService) ApprovePlan(ctx context.Context, req *connect.Request[sessionv1.ApprovePlanRequest]) (*connect.Response[sessionv1.ApprovePlanResponse], error)

+ func (s *BacklogService) ArchiveBacklogItem(ctx context.Context, req *connect.Request[sessionv1.ArchiveBacklogItemRequest]) (*connect.Response[sessionv1.ArchiveBacklogItemResponse], error)

+ func (s *BacklogService) AttachSessionToItem(ctx context.Context, ...) (*connect.Response[sessionv1.AttachSessionToItemResponse], error)

+ func (s *BacklogService) CancelTriage(ctx context.Context, req *connect.Request[sessionv1.CancelTriageRequest]) (*connect.Response[sessionv1.CancelTriageResponse], error)

+ func (s *BacklogService) CreateBacklogItem(ctx context.Context, req *connect.Request[sessionv1.CreateBacklogItemRequest]) (*connect.Response[sessionv1.CreateBacklogItemResponse], error)

+ func (s *BacklogService) CreateItemSource(ctx context.Context, req *connect.Request[sessionv1.CreateItemSourceRequest]) (*connect.Response[sessionv1.CreateItemSourceResponse], error)

+ func (s *BacklogService) DeleteBacklogItem(ctx context.Context, req *connect.Request[sessionv1.DeleteBacklogItemRequest]) (*connect.Response[sessionv1.DeleteBacklogItemResponse], error)

+ func (s *BacklogService) DeleteItemSource(ctx context.Context, req *connect.Request[sessionv1.DeleteItemSourceRequest]) (*connect.Response[sessionv1.DeleteItemSourceResponse], error)

+ func (s *BacklogService) GetBacklogItem(ctx context.Context, req *connect.Request[sessionv1.GetBacklogItemRequest]) (*connect.Response[sessionv1.GetBacklogItemResponse], error)

+ func (s *BacklogService) GetSyncHistory(ctx context.Context, req *connect.Request[sessionv1.GetSyncHistoryRequest]) (*connect.Response[sessionv1.GetSyncHistoryResponse], error)

+ func (s *BacklogService) ImportGitHubIssue(ctx context.Context, req *connect.Request[sessionv1.ImportGitHubIssueRequest]) (*connect.Response[sessionv1.ImportGitHubIssueResponse], error)

+ func (s *BacklogService) ListBacklogItems(ctx context.Context, req *connect.Request[sessionv1.ListBacklogItemsRequest]) (*connect.Response[sessionv1.ListBacklogItemsResponse], error)

+ func (s *BacklogService) ListGitHubIssues(ctx context.Context, req *connect.Request[sessionv1.ListGitHubIssuesRequest]) (*connect.Response[sessionv1.ListGitHubIssuesResponse], error)

+ func (s *BacklogService) ListItemSources(ctx context.Context, req *connect.Request[sessionv1.ListItemSourcesRequest]) (*connect.Response[sessionv1.ListItemSourcesResponse], error)

+ func (s *BacklogService) OverrideVerdict(ctx context.Context, req *connect.Request[sessionv1.OverrideVerdictRequest]) (*connect.Response[sessionv1.OverrideVerdictResponse], error)

+ func (s *BacklogService) SearchGitHubRepos(ctx context.Context, req *connect.Request[sessionv1.SearchGitHubReposRequest]) (*connect.Response[sessionv1.SearchGitHubReposResponse], error)

+ func (s *BacklogService) SetAutonomousDriverStarter(starter AutonomousDriverStarter)

+ func (s *BacklogService) SetGitHubResolver(fn func(input string) (string, *session.GitHubRef, error))

+ func (s *BacklogService) SetHeadlessPool(pool headless.PoolClient)

+ func (s *BacklogService) SetPluginRegistry(registry *session.PluginRegistry)

+ func (s *BacklogService) SetSessionStopper(stopper SessionStopper)

+ func (s *BacklogService) SetSyncFeatureEnabledCheck(check func() bool)

+ func (s *BacklogService) SetSyncKeyFunc(keyFunc func() ([]byte, error))

+ func (s *BacklogService) SetTriageCleanupTimeout(d time.Duration)

+ func (s *BacklogService) Shutdown()

+ func (s *BacklogService) SpawnSessionFromItem(ctx context.Context, ...) (*connect.Response[sessionv1.SpawnSessionFromItemResponse], error)

+ func (s *BacklogService) SuggestNextItem(ctx context.Context, _ *connect.Request[sessionv1.SuggestNextItemRequest]) (*connect.Response[sessionv1.SuggestNextItemResponse], error)

+ func (s *BacklogService) TransitionBacklogItemStatus(ctx context.Context, ...) (*connect.Response[sessionv1.TransitionBacklogItemStatusResponse], error)

+ func (s *BacklogService) TriggerReReview(ctx context.Context, req *connect.Request[sessionv1.TriggerReReviewRequest]) (*connect.Response[sessionv1.TriggerReReviewResponse], error)

+ func (s *BacklogService) TriggerSync(ctx context.Context, req *connect.Request[sessionv1.TriggerSyncRequest]) (*connect.Response[sessionv1.TriggerSyncResponse], error)

+ func (s *BacklogService) TriggerTriage(ctx context.Context, req *connect.Request[sessionv1.TriggerTriageRequest]) (*connect.Response[sessionv1.TriggerTriageResponse], error)

+ func (s *BacklogService) UpdateBacklogItem(ctx context.Context, req *connect.Request[sessionv1.UpdateBacklogItemRequest]) (*connect.Response[sessionv1.UpdateBacklogItemResponse], error)

+ func (s *BacklogService) UpdateItemSource(ctx context.Context, req *connect.Request[sessionv1.UpdateItemSourceRequest]) (*connect.Response[sessionv1.UpdateItemSourceResponse], error)

+ type BulkUpsertResult struct

+ Created int

+ Errors []string

+ Skipped int

+ Updated int

+ type CDPStreamHandler struct

+ func NewCDPStreamHandler(finder InstanceFinder) *CDPStreamHandler

+ func (h *CDPStreamHandler) HandleWebSocket(w http.ResponseWriter, r *http.Request)

+ type CLIAIClient struct

+ func NewCLIAIClient(spec CLIAgentSpec) (*CLIAIClient, error)

+ func (c *CLIAIClient) Complete(ctx context.Context, systemPrompt, userPrompt string) (string, error)

+ type CLIAgentSpec struct

+ Args func() []string

+ Binary string

+ Name string

+ PromptAsArg bool

+ PromptSeparator string

+ type CapacityMonitor struct

+ func NewCapacityMonitor(cfg config.CapacityConfig, eventBus *events.EventBus, poller InstancePoller, ...) *CapacityMonitor

+ func (m *CapacityMonitor) GetCurrentLimits() map[string]ProviderLimits

+ func (m *CapacityMonitor) GetSessionLimits(title string) (ProviderLimits, bool)

+ func (m *CapacityMonitor) RegisterClient(name string, client ProviderLimitsClient)

+ func (m *CapacityMonitor) Start(ctx context.Context)

+ func (m *CapacityMonitor) UpdateFromResponseHeaders(provider string, headers http.Header)

+ type CheckpointService struct

+ func NewCheckpointService(storage session.InstanceStore, eventBus *events.EventBus) *CheckpointService

+ func (cs *CheckpointService) ClearConversationState(ctx context.Context, ...) (*connect.Response[sessionv1.ClearConversationStateResponse], error)

+ func (cs *CheckpointService) CreateCheckpoint(ctx context.Context, req *connect.Request[sessionv1.CreateCheckpointRequest]) (*connect.Response[sessionv1.CreateCheckpointResponse], error)

+ func (cs *CheckpointService) ListCheckpoints(ctx context.Context, req *connect.Request[sessionv1.ListCheckpointsRequest]) (*connect.Response[sessionv1.ListCheckpointsResponse], error)

+ func (cs *CheckpointService) SetExternalDiscovery(d *session.ExternalSessionDiscovery)

+ func (cs *CheckpointService) SetLoadInstancesFn(fn func() ([]*session.Instance, error))

+ func (cs *CheckpointService) SetPoller(p *session.ReviewQueuePoller)

+ func (cs *CheckpointService) SetScrollbackMgr(mgr ScrollbackSequencer)

+ type ClaudeOAuthCredentialSource struct

+ HomeDirOverride string

+ func (s *ClaudeOAuthCredentialSource) Name() string

+ func (s *ClaudeOAuthCredentialSource) Resolve(_ context.Context, provider string) (Credential, bool, error)

+ type ConfigFileCredentialSource struct

+ func (s *ConfigFileCredentialSource) Name() string

+ func (s *ConfigFileCredentialSource) Resolve(_ context.Context, provider string) (Credential, bool, error)

+ type ConfigFileRulesRepository interface

+ GetRules func(ctx context.Context) (rules []RuleSpec, filePath string, err error)

+ SaveRules func(ctx context.Context, ruleIDs []string, rule *sessionv1.ApprovalRuleProto) (filePath string, err error)

+ type Credential struct

+ APIKey string

+ BearerToken string

+ ExpiresAt time.Time

+ IsADC bool

+ Provider string

+ Source string

+ func (c Credential) AnthropicAuthHeader() (key, value string, ok bool)

+ func (c Credential) GoogleAuthHeader() (key, value string, ok bool)

+ func (c Credential) IsValid() bool

+ type CredentialChain struct

+ func NewChain(sources ...CredentialSource) *CredentialChain

+ func NewDefaultChain(cfg *config.Config) *CredentialChain

+ func (c *CredentialChain) Resolve(ctx context.Context, provider string) (Credential, error)

+ type CredentialSource interface

+ Name func() string

+ Resolve func(ctx context.Context, provider string) (Credential, bool, error)

+ type DefaultRulePromptBuilder struct

+ func (b *DefaultRulePromptBuilder) BuildSystemPrompt(ctx RulePromptContext) string

+ func (b *DefaultRulePromptBuilder) BuildUserPrompt(ctx RulePromptContext) string

type DefaultsService

+ func (d *DefaultsService) DeleteAlias(ctx context.Context, req *connect.Request[sessionv1.DeleteAliasRequest]) (*connect.Response[sessionv1.DeleteAliasResponse], error)

+ func (d *DefaultsService) ListAliases(ctx context.Context, req *connect.Request[sessionv1.ListAliasesRequest]) (*connect.Response[sessionv1.ListAliasesResponse], error)

+ func (d *DefaultsService) UpsertAlias(ctx context.Context, req *connect.Request[sessionv1.UpsertAliasRequest]) (*connect.Response[sessionv1.UpsertAliasResponse], error)

+ type EnvVarCredentialSource struct

+ func (s *EnvVarCredentialSource) Name() string

+ func (s *EnvVarCredentialSource) Resolve(_ context.Context, provider string) (Credential, bool, error)

+ type ErrorRegistry struct

+ func NewErrorRegistry(entClient *ent.Client, enabled bool) *ErrorRegistry

+ func (r *ErrorRegistry) Acknowledge(ctx context.Context, fingerprint string) error

+ func (r *ErrorRegistry) List(ctx context.Context, includeAcknowledged bool) ([]*ent.ErrorEvent, error)

+ func (r *ErrorRegistry) Record(ctx context.Context, errVal error, procedure string)

+ type FeatureController interface

+ Disable func() error

+ Enable func(ctx context.Context) error

+ IsEnabled func() bool

+ type FeatureFlagService struct

+ func NewFeatureFlagService() *FeatureFlagService

+ func (f *FeatureFlagService) GetFeatureFlags(ctx context.Context, req *connect.Request[sessionv1.GetFeatureFlagsRequest]) (*connect.Response[sessionv1.GetFeatureFlagsResponse], error)

+ func (f *FeatureFlagService) SetFeatureController(name string, c FeatureController)

+ func (f *FeatureFlagService) UpdateFeatureFlag(ctx context.Context, req *connect.Request[sessionv1.UpdateFeatureFlagRequest]) (*connect.Response[sessionv1.UpdateFeatureFlagResponse], error)

type FileService

+ func (fs *FileService) ServeFileRaw(w http.ResponseWriter, r *http.Request)

+ type FileUploadHandler struct

+ func NewFileUploadHandler(dir string) *FileUploadHandler

+ func (h *FileUploadHandler) HandleUpload(w http.ResponseWriter, r *http.Request)

+ type GeminiLimitsClient struct

+ func NewGeminiLimitsClient(chain *CredentialChain, model string) *GeminiLimitsClient

+ func (c *GeminiLimitsClient) ModelContextWindow(model string) int

+ func (c *GeminiLimitsClient) Provider() string

+ func (c *GeminiLimitsClient) QueryLimits(ctx context.Context) (ProviderLimits, error)

+ func (c *GeminiLimitsClient) UpdateFromResponseHeaders(h http.Header, current ProviderLimits) ProviderLimits

+ type GitHubUserService struct

+ func NewGitHubUserService(cache *githubpkg.UserPRCache) *GitHubUserService

+ func (s *GitHubUserService) GetGitHubAuthState(ctx context.Context, _ *connect.Request[sessionv1.GetGitHubAuthStateRequest]) (*connect.Response[sessionv1.GetGitHubAuthStateResponse], error)

+ func (s *GitHubUserService) ListGitHubAccounts(_ context.Context, _ *connect.Request[sessionv1.ListGitHubAccountsRequest]) (*connect.Response[sessionv1.ListGitHubAccountsResponse], error)

+ func (s *GitHubUserService) ListUserPRs(ctx context.Context, _ *connect.Request[sessionv1.ListUserPRsRequest]) (*connect.Response[sessionv1.ListUserPRsResponse], error)

+ func (s *GitHubUserService) PollGitHubDeviceAuth(ctx context.Context, ...) (*connect.Response[sessionv1.PollGitHubDeviceAuthResponse], error)

+ func (s *GitHubUserService) RevokeGitHubToken(ctx context.Context, req *connect.Request[sessionv1.RevokeGitHubTokenRequest]) (*connect.Response[sessionv1.RevokeGitHubTokenResponse], error)

+ func (s *GitHubUserService) StartGitHubDeviceAuth(ctx context.Context, ...) (*connect.Response[sessionv1.StartGitHubDeviceAuthResponse], error)

+ func (s *GitHubUserService) WatchUserPRs(ctx context.Context, _ *connect.Request[sessionv1.WatchUserPRsRequest], ...) error

+ type GitignoreCache struct

+ func NewGitignoreCache(maxSize int, ttl time.Duration) GitignoreCache

+ func (c *GitignoreCache) Get(key string) ([]gitignore.Pattern, bool)

+ func (c *GitignoreCache) Put(key string, patterns []gitignore.Pattern, mtime time.Time)

+ type HeadlessService struct

+ func NewHeadlessService(pool *headless.Pool) *HeadlessService

+ func (s *HeadlessService) RunHeadlessCall(ctx context.Context, req *connect.Request[sessionv1.RunHeadlessCallRequest], ...) error

+ type InsightsService struct

+ func NewInsightsService(store tokens.TokenStoreReader, pricing *tokens.PricingTable, ...) *InsightsService

+ func (s *InsightsService) GetInsightsSummary(_ context.Context, req *connect.Request[sessionv1.GetInsightsSummaryRequest]) (*connect.Response[sessionv1.GetInsightsSummaryResponse], error)

+ func (s *InsightsService) ListSessionTokens(_ context.Context, req *connect.Request[sessionv1.ListSessionTokensRequest]) (*connect.Response[sessionv1.ListSessionTokensResponse], error)

+ func (s *InsightsService) WatchInsights(ctx context.Context, _ *connect.Request[sessionv1.WatchInsightsRequest], ...) error

+ type InstanceFinder interface

+ FindInstance func(sessionID string) *session.Instance

+ type InstancePoller interface

+ GetInstances func() []*session.Instance

+ type LiveInstanceFinder interface

+ FindLiveInstance func(id string) *session.Instance

+ type LocalFileService struct

+ func NewLocalFileService() *LocalFileService

+ func (s *LocalFileService) ListLocalDirectory(w http.ResponseWriter, r *http.Request)

+ func (s *LocalFileService) ServeLocalFile(w http.ResponseWriter, r *http.Request)

+ type LogLevelHandler struct

+ func NewLogLevelHandler() *LogLevelHandler

+ func (h *LogLevelHandler) HandleGet(w http.ResponseWriter, _ *http.Request)

+ func (h *LogLevelHandler) HandleSet(w http.ResponseWriter, r *http.Request)

+ func (h *LogLevelHandler) RegisterRoutes(mux *http.ServeMux)

+ type ProviderLimits struct

+ Available bool

+ ContextTokensMax int

+ ContextTokensUsed int

+ EstimatedCostUSD float64

+ FetchedAt time.Time

+ InputTokensLimit int

+ InputTokensRemaining int

+ InputTokensReset time.Time

+ LastErrorCode string

+ Model string

+ OutputTokensLimit int

+ OutputTokensRemaining int

+ OutputTokensReset time.Time

+ Provider string

+ RequestsLimit int

+ RequestsRemaining int

+ RequestsReset time.Time

+ SessionInputTokens int

+ SessionOutputTokens int

+ TokensLimit int

+ TokensRemaining int

+ TokensReset time.Time

+ type ProviderLimitsClient interface

+ ModelContextWindow func(model string) int

+ Provider func() string

+ QueryLimits func(ctx context.Context) (ProviderLimits, error)

+ UpdateFromResponseHeaders func(headers http.Header, current ProviderLimits) ProviderLimits

type ReactiveQueueManager

+ OnControllerStatusChange func(inst *session.Instance, newStatus detection.DetectedStatus)

type ReviewQueueService

+ func (rqs *ReviewQueueService) GetReactiveQueueManager() ReactiveQueueManager

+ type RulePromptBuilder interface

+ BuildSystemPrompt func(ctx RulePromptContext) string

+ BuildUserPrompt func(ctx RulePromptContext) string

+ type RulePromptContext struct

+ AnalyticsGaps []AnalyticsGap

+ CommandSample string

+ ExistingRules []RuleSpec

+ ProgramFilter string

+ ToolNameFilter string

+ WindowDays int

type RuleSpec

+ BlockedSubcommands []string

+ ForbiddenFlags []string

+ Programs []string

+ PythonModes []string

+ RequiredFlagPrefixes []string

+ RequiredFlags []string

+ SafePythonImportsOnly bool

+ Subcommands []string

type RulesService

+ func (rs *RulesService) BulkUpsertRules(ctx context.Context, req *connect.Request[sessionv1.BulkUpsertRulesRequest]) (*connect.Response[sessionv1.BulkUpsertRulesResponse], error)

+ func (rs *RulesService) ExportRules(ctx context.Context, req *connect.Request[sessionv1.ExportRulesRequest]) (*connect.Response[sessionv1.ExportRulesResponse], error)

+ func (rs *RulesService) GenerateSuggestedRule(ctx context.Context, ...) (*connect.Response[sessionv1.GenerateSuggestedRuleResponse], error)

+ func (rs *RulesService) GetConfigFileRules(ctx context.Context, _ *connect.Request[sessionv1.GetConfigFileRulesRequest]) (*connect.Response[sessionv1.GetConfigFileRulesResponse], error)

+ func (rs *RulesService) GetProgramAnalytics(ctx context.Context, ...) (*connect.Response[sessionv1.GetProgramAnalyticsResponse], error)

+ func (rs *RulesService) SaveRulesToConfigFile(ctx context.Context, ...) (*connect.Response[sessionv1.SaveRulesToConfigFileResponse], error)

+ func (rs *RulesService) ValidateRules(ctx context.Context, req *connect.Request[sessionv1.ValidateRulesRequest]) (*connect.Response[sessionv1.ValidateRulesResponse], error)

type RulesStore

+ func (s *RulesStore) BulkUpsert(ctx context.Context, specs []RuleSpec, overwriteDuplicates bool) BulkUpsertResult

+ type ScrollbackSequencer interface

+ CurrentSequence func(sessionID string) uint64

type SearchService

+ func (ss *SearchService) SetInstanceProvider(fn func() []*session.Instance)

+ type SessionCreator interface

+ CreateDirectorySession func(ctx context.Context, title, path, prompt string, tags []string, oneShot bool, ...) (*session.Instance, error)

+ type SessionImageUploadHandler struct

+ func NewSessionImageUploadHandler(storage session.InstanceStore, finder instanceFinder) *SessionImageUploadHandler

+ func (h *SessionImageUploadHandler) HandleUpload(w http.ResponseWriter, r *http.Request)

type SessionService

+ func NewSessionServiceWithEntClient(entClient *ent.Client) (*SessionService, error)

+ func (s *SessionService) AcknowledgeError(ctx context.Context, req *connect.Request[sessionv1.AcknowledgeErrorRequest]) (*connect.Response[sessionv1.AcknowledgeErrorResponse], error)

+ func (s *SessionService) ArchiveSession(ctx context.Context, req *connect.Request[sessionv1.ArchiveSessionRequest]) (*connect.Response[sessionv1.ArchiveSessionResponse], error)

+ func (s *SessionService) ArchiveWorkflowSessions(ctx context.Context, ...) (*connect.Response[sessionv1.ArchiveWorkflowSessionsResponse], error)

+ func (s *SessionService) BulkUpsertRules(ctx context.Context, req *connect.Request[sessionv1.BulkUpsertRulesRequest]) (*connect.Response[sessionv1.BulkUpsertRulesResponse], error)

+ func (s *SessionService) ClearConversationState(ctx context.Context, ...) (*connect.Response[sessionv1.ClearConversationStateResponse], error)

+ func (s *SessionService) CreateDirectorySession(ctx context.Context, title, path, prompt string, tags []string, oneShot bool, ...) (*session.Instance, error)

+ func (s *SessionService) CreateWorkflow(ctx context.Context, req *connect.Request[sessionv1.CreateWorkflowRequest]) (*connect.Response[sessionv1.CreateWorkflowResponse], error)

+ func (s *SessionService) DeleteAlias(ctx context.Context, req *connect.Request[sessionv1.DeleteAliasRequest]) (*connect.Response[sessionv1.DeleteAliasResponse], error)

+ func (s *SessionService) DeleteShell(ctx context.Context, req *connect.Request[sessionv1.DeleteShellRequest]) (*connect.Response[sessionv1.DeleteShellResponse], error)

+ func (s *SessionService) DeleteWorkflow(ctx context.Context, req *connect.Request[sessionv1.DeleteWorkflowRequest]) (*connect.Response[sessionv1.DeleteWorkflowResponse], error)

+ func (s *SessionService) DeleteWorkflowFailedSessions(ctx context.Context, ...) (*connect.Response[sessionv1.DeleteWorkflowFailedSessionsResponse], error)

+ func (s *SessionService) ExportRules(ctx context.Context, req *connect.Request[sessionv1.ExportRulesRequest]) (*connect.Response[sessionv1.ExportRulesResponse], error)

+ func (s *SessionService) GenerateSuggestedRule(ctx context.Context, ...) (*connect.Response[sessionv1.GenerateSuggestedRuleResponse], error)

+ func (s *SessionService) GetConfigFileRules(ctx context.Context, req *connect.Request[sessionv1.GetConfigFileRulesRequest]) (*connect.Response[sessionv1.GetConfigFileRulesResponse], error)

+ func (s *SessionService) GetDetectionEvents(ctx context.Context, req *connect.Request[sessionv1.GetDetectionEventsRequest]) (*connect.Response[sessionv1.GetDetectionEventsResponse], error)

+ func (s *SessionService) GetEscapeAnalyticsSummary(ctx context.Context, ...) (*connect.Response[sessionv1.GetEscapeAnalyticsSummaryResponse], error)

+ func (s *SessionService) GetFeatureFlags(ctx context.Context, req *connect.Request[sessionv1.GetFeatureFlagsRequest]) (*connect.Response[sessionv1.GetFeatureFlagsResponse], error)

+ func (s *SessionService) GetFileService() *FileService

+ func (s *SessionService) GetHookStatus(_ context.Context, _ *connect.Request[sessionv1.GetHookStatusRequest]) (*connect.Response[sessionv1.GetHookStatusResponse], error)

+ func (s *SessionService) GetInstances() []*session.Instance

+ func (s *SessionService) GetProgramAnalytics(ctx context.Context, ...) (*connect.Response[sessionv1.GetProgramAnalyticsResponse], error)

+ func (s *SessionService) GetProviderLimits(ctx context.Context, req *connect.Request[sessionv1.GetProviderLimitsRequest]) (*connect.Response[sessionv1.GetProviderLimitsResponse], error)

+ func (s *SessionService) HibernateSession(ctx context.Context, req *connect.Request[sessionv1.HibernateSessionRequest]) (*connect.Response[sessionv1.HibernateSessionResponse], error)

+ func (s *SessionService) InstallHooks(_ context.Context, req *connect.Request[sessionv1.InstallHooksRequest]) (*connect.Response[sessionv1.InstallHooksResponse], error)

+ func (s *SessionService) IsSessionLive(sessionUUID string) bool

+ func (s *SessionService) KillTmuxSessionByTitle(ctx context.Context, title string) error

+ func (s *SessionService) ListAliases(ctx context.Context, req *connect.Request[sessionv1.ListAliasesRequest]) (*connect.Response[sessionv1.ListAliasesResponse], error)

+ func (s *SessionService) ListErrors(ctx context.Context, req *connect.Request[sessionv1.ListErrorsRequest]) (*connect.Response[sessionv1.ListErrorsResponse], error)

+ func (s *SessionService) ListShells(ctx context.Context, req *connect.Request[sessionv1.ListShellsRequest]) (*connect.Response[sessionv1.ListShellsResponse], error)

+ func (s *SessionService) ListSlashCommands(ctx context.Context, req *connect.Request[sessionv1.ListSlashCommandsRequest]) (*connect.Response[sessionv1.ListSlashCommandsResponse], error)

+ func (s *SessionService) ListWorkflows(ctx context.Context, req *connect.Request[sessionv1.ListWorkflowsRequest]) (*connect.Response[sessionv1.ListWorkflowsResponse], error)

+ func (s *SessionService) LogClientEvents(_ context.Context, req *connect.Request[sessionv1.LogClientEventsRequest]) (*connect.Response[sessionv1.LogClientEventsResponse], error)

+ func (s *SessionService) QueryEscapeAnalytics(ctx context.Context, ...) (*connect.Response[sessionv1.QueryEscapeAnalyticsResponse], error)

+ func (s *SessionService) ReapPausedTmuxSessions()

+ func (s *SessionService) RestartShell(ctx context.Context, req *connect.Request[sessionv1.RestartShellRequest]) (*connect.Response[sessionv1.RestartShellResponse], error)

+ func (s *SessionService) ResumeHibernatedSession(ctx context.Context, ...) (*connect.Response[sessionv1.ResumeHibernatedSessionResponse], error)

+ func (s *SessionService) RunWorkflow(ctx context.Context, req *connect.Request[sessionv1.RunWorkflowRequest]) (*connect.Response[sessionv1.RunWorkflowResponse], error)

+ func (s *SessionService) SaveRulesToConfigFile(ctx context.Context, ...) (*connect.Response[sessionv1.SaveRulesToConfigFileResponse], error)

+ func (s *SessionService) SetAnalyticsClient(c *ent.Client)

+ func (s *SessionService) SetBacklogLifecycleListener(l *session.BacklogLifecycleListener)

+ func (s *SessionService) SetErrorRegistry(r *ErrorRegistry)

+ func (s *SessionService) SetFeatureController(name string, c FeatureController)

+ func (s *SessionService) SetHeadlessPool(pool *headless.Pool)

+ func (s *SessionService) SetLifecycleContext(ctx context.Context)

+ func (s *SessionService) SetMemoryCacheReader(r session.MemoryCacheReader)

+ func (s *SessionService) SetRegistry(r *session.Registry)

+ func (s *SessionService) SetTokenStoreReader(store tokens.TokenStoreReader)

+ func (s *SessionService) SetWorkflowRepository(repo session.WorkflowRepository)

+ func (s *SessionService) SetWorkflowService(svc *WorkflowService)

+ func (s *SessionService) SpawnReviewSession(ctx context.Context, item *ent.BacklogItem, itemSessionID string, ...) (*session.Instance, error)

+ func (s *SessionService) SpawnShell(ctx context.Context, req *connect.Request[sessionv1.SpawnShellRequest]) (*connect.Response[sessionv1.SpawnShellResponse], error)

+ func (s *SessionService) StartAutonomousDriverForInstance(inst *session.Instance)

+ func (s *SessionService) StartAutonomousDriverWithTimeout(inst *session.Instance, startupTimeout time.Duration)

+ func (s *SessionService) StopDriverForSession(sessionTitle string)

+ func (s *SessionService) StopSessionByUUID(ctx context.Context, sessionUUID string) error

+ func (s *SessionService) StopShell(ctx context.Context, req *connect.Request[sessionv1.StopShellRequest]) (*connect.Response[sessionv1.StopShellResponse], error)

+ func (s *SessionService) UnarchiveSession(ctx context.Context, req *connect.Request[sessionv1.UnarchiveSessionRequest]) (*connect.Response[sessionv1.UnarchiveSessionResponse], error)

+ func (s *SessionService) UpdateFeatureFlag(ctx context.Context, req *connect.Request[sessionv1.UpdateFeatureFlagRequest]) (*connect.Response[sessionv1.UpdateFeatureFlagResponse], error)

+ func (s *SessionService) UpdateSessionProgram(ctx context.Context, sessionID string, newProgram string) error

+ func (s *SessionService) UpdateWorkflow(ctx context.Context, req *connect.Request[sessionv1.UpdateWorkflowRequest]) (*connect.Response[sessionv1.UpdateWorkflowResponse], error)

+ func (s *SessionService) UpsertAlias(ctx context.Context, req *connect.Request[sessionv1.UpsertAliasRequest]) (*connect.Response[sessionv1.UpsertAliasResponse], error)

+ func (s *SessionService) ValidateRules(ctx context.Context, req *connect.Request[sessionv1.ValidateRulesRequest]) (*connect.Response[sessionv1.ValidateRulesResponse], error)

+ func (s *SessionService) WireInstanceCallbacks(inst *session.LiveInstance)

+ func (s *SessionService) WriteToSession(ctx context.Context, req *connect.Request[sessionv1.WriteToSessionRequest]) (*connect.Response[sessionv1.WriteToSessionResponse], error)

+ type SessionStopper interface

+ IsSessionLive func(sessionUUID string) bool

+ KillTmuxSessionByTitle func(ctx context.Context, title string) error

+ StopSessionByUUID func(ctx context.Context, sessionUUID string) error

+ type SessionSwitcher interface

+ UpdateSessionProgram func(ctx context.Context, sessionID string, newProgram string) error

+ type SlashCommandService struct

+ func NewSlashCommandService() *SlashCommandService

+ func (s *SlashCommandService) ListSlashCommands(ctx context.Context, req *connect.Request[sessionv1.ListSlashCommandsRequest]) (*connect.Response[sessionv1.ListSlashCommandsResponse], error)

+ type StreamingWSBridge struct

+ func NewStreamingWSBridge(handler http.Handler) *StreamingWSBridge

+ func (b *StreamingWSBridge) Handler(apiPrefix string) http.Handler

+ type TerminalService struct

+ func NewTerminalService() *TerminalService

+ func (ts *TerminalService) GetTerminalSnapshot(ctx context.Context, ...) (*connect.Response[sessionv1.GetTerminalSnapshotResponse], error)

+ func (ts *TerminalService) SetExternalDiscovery(d *session.ExternalSessionDiscovery)

+ func (ts *TerminalService) SetPoller(p *session.ReviewQueuePoller)

+ func (ts *TerminalService) WriteToSession(ctx context.Context, req *connect.Request[sessionv1.WriteToSessionRequest]) (*connect.Response[sessionv1.WriteToSessionResponse], error)

type UnfinishedWorkService

+ func (s *UnfinishedWorkService) GetWorktreeDiff(_ context.Context, req *connect.Request[sessionv1.GetWorktreeDiffRequest]) (*connect.Response[sessionv1.GetWorktreeDiffResponse], error)

+ type VNCProxyHandler struct

+ func NewVNCProxyHandler(finder InstanceFinder) *VNCProxyHandler

+ func (h *VNCProxyHandler) HandleWebSocket(w http.ResponseWriter, r *http.Request)

+ type WorkflowSchedulerInterface interface

+ FireNow func(ctx context.Context, wf *ent.Workflow, arg string) (string, error)

+ Reload func(ctx context.Context, wf *ent.Workflow) error

+ Remove func(workflowID string) error

+ type WorkflowService struct

+ func NewWorkflowService(repo session.WorkflowRepository, scheduler WorkflowSchedulerInterface, ...) *WorkflowService

+ func (s *WorkflowService) CreateWorkflow(ctx context.Context, req *connect.Request[sessionv1.CreateWorkflowRequest]) (*connect.Response[sessionv1.CreateWorkflowResponse], error)

+ func (s *WorkflowService) DeleteWorkflow(ctx context.Context, req *connect.Request[sessionv1.DeleteWorkflowRequest]) (*connect.Response[sessionv1.DeleteWorkflowResponse], error)

+ func (s *WorkflowService) ListWorkflows(ctx context.Context, req *connect.Request[sessionv1.ListWorkflowsRequest]) (*connect.Response[sessionv1.ListWorkflowsResponse], error)

+ func (s *WorkflowService) RunWorkflow(ctx context.Context, req *connect.Request[sessionv1.RunWorkflowRequest]) (*connect.Response[sessionv1.RunWorkflowResponse], error)

+ func (s *WorkflowService) UpdateWorkflow(ctx context.Context, req *connect.Request[sessionv1.UpdateWorkflowRequest]) (*connect.Response[sessionv1.UpdateWorkflowResponse], error)

+ func (ws *WorkflowService) ArchiveWorkflowSessions(ctx context.Context, ...) (*connect.Response[sessionv1.ArchiveWorkflowSessionsResponse], error)

+ func (ws *WorkflowService) DeleteWorkflowFailedSessions(ctx context.Context, ...) (*connect.Response[sessionv1.DeleteWorkflowFailedSessionsResponse], error)

+ func (ws *WorkflowService) SetPoller(p *session.ReviewQueuePoller)

type WorkspaceService

+ func (ws *WorkspaceService) ListBranches(ctx context.Context, req *connect.Request[sessionv1.ListBranchesRequest]) (*connect.Response[sessionv1.ListBranchesResponse], error)

+ func (ws *WorkspaceService) SetLiveFinder(f LiveInstanceFinder)

Apr 28, 2026

Changes in this version

type SessionService

+ func (s *SessionService) SetHistoryLinker(hl *session.HistoryLinker)

Apr 27, 2026

Changes in this version

+ type ProjectService struct

+ func NewProjectService(storage *session.Storage) *ProjectService

+ func (s *ProjectService) AssignSessionsToProject(ctx context.Context, ...) (*connect.Response[sessionv1.AssignSessionsToProjectResponse], error)

+ func (s *ProjectService) CreateProject(ctx context.Context, req *connect.Request[sessionv1.CreateProjectRequest]) (*connect.Response[sessionv1.CreateProjectResponse], error)

+ func (s *ProjectService) DeleteProject(ctx context.Context, req *connect.Request[sessionv1.DeleteProjectRequest]) (*connect.Response[sessionv1.DeleteProjectResponse], error)

+ func (s *ProjectService) ListProjects(ctx context.Context, req *connect.Request[sessionv1.ListProjectsRequest]) (*connect.Response[sessionv1.ListProjectsResponse], error)

+ func (s *ProjectService) UpdateProject(ctx context.Context, req *connect.Request[sessionv1.UpdateProjectRequest]) (*connect.Response[sessionv1.UpdateProjectResponse], error)

type SessionService

+ func (s *SessionService) AssignSessionsToProject(ctx context.Context, ...) (*connect.Response[sessionv1.AssignSessionsToProjectResponse], error)

+ func (s *SessionService) BatchCreateSessions(ctx context.Context, ...) (*connect.Response[sessionv1.BatchCreateSessionsResponse], error)

+ func (s *SessionService) CreateProject(ctx context.Context, req *connect.Request[sessionv1.CreateProjectRequest]) (*connect.Response[sessionv1.CreateProjectResponse], error)

+ func (s *SessionService) DeleteProject(ctx context.Context, req *connect.Request[sessionv1.DeleteProjectRequest]) (*connect.Response[sessionv1.DeleteProjectResponse], error)

+ func (s *SessionService) DeletePromptHistory(ctx context.Context, ...) (*connect.Response[sessionv1.DeletePromptHistoryResponse], error)

+ func (s *SessionService) ListProjects(ctx context.Context, req *connect.Request[sessionv1.ListProjectsRequest]) (*connect.Response[sessionv1.ListProjectsResponse], error)

+ func (s *SessionService) ListPromptHistory(ctx context.Context, req *connect.Request[sessionv1.ListPromptHistoryRequest]) (*connect.Response[sessionv1.ListPromptHistoryResponse], error)

+ func (s *SessionService) RunOneShot(ctx context.Context, req *connect.Request[sessionv1.RunOneShotRequest]) (*connect.Response[sessionv1.RunOneShotResponse], error)

+ func (s *SessionService) UpdateProject(ctx context.Context, req *connect.Request[sessionv1.UpdateProjectRequest]) (*connect.Response[sessionv1.UpdateProjectResponse], error)

Apr 26, 2026

Changes in this version

+ type UnfinishedWorkService struct

+ func NewUnfinishedWorkService(scanner *unfinished.Scanner, stateStore *unfinished.StateStore, ...) *UnfinishedWorkService

+ func (s *UnfinishedWorkService) DismissWorktree(_ context.Context, req *connect.Request[sessionv1.DismissWorktreeRequest]) (*connect.Response[sessionv1.DismissWorktreeResponse], error)

+ func (s *UnfinishedWorkService) GetUnfinishedWorkConfig(_ context.Context, ...) (*connect.Response[sessionv1.GetUnfinishedWorkConfigResponse], error)

+ func (s *UnfinishedWorkService) GetWorktreeAISummary(ctx context.Context, ...) (*connect.Response[sessionv1.GetWorktreeAISummaryResponse], error)

+ func (s *UnfinishedWorkService) ListUnfinishedWork(_ context.Context, _ *connect.Request[sessionv1.ListUnfinishedWorkRequest]) (*connect.Response[sessionv1.ListUnfinishedWorkResponse], error)

+ func (s *UnfinishedWorkService) QuickCommitPush(_ context.Context, req *connect.Request[sessionv1.QuickCommitPushRequest]) (*connect.Response[sessionv1.QuickCommitPushResponse], error)

+ func (s *UnfinishedWorkService) ScanUnfinishedWork(_ context.Context, _ *connect.Request[sessionv1.ScanUnfinishedWorkRequest]) (*connect.Response[sessionv1.ScanUnfinishedWorkResponse], error)

+ func (s *UnfinishedWorkService) SnoozeWorktree(_ context.Context, req *connect.Request[sessionv1.SnoozeWorktreeRequest]) (*connect.Response[sessionv1.SnoozeWorktreeResponse], error)

+ func (s *UnfinishedWorkService) UndismissWorktree(_ context.Context, req *connect.Request[sessionv1.UndismissWorktreeRequest]) (*connect.Response[sessionv1.UndismissWorktreeResponse], error)

+ func (s *UnfinishedWorkService) UpdateUnfinishedWorkConfig(_ context.Context, ...) (*connect.Response[sessionv1.UpdateUnfinishedWorkConfigResponse], error)

+ func (s *UnfinishedWorkService) WatchUnfinishedWork(ctx context.Context, _ *connect.Request[sessionv1.WatchUnfinishedWorkRequest], ...) error

Apr 23, 2026

Changes in this version

type SessionService

+ func (s *SessionService) FindLiveInstance(id string) *session.Instance

+ func (s *SessionService) RemoveFromAllPollers(id string)

Apr 21, 2026

Changes in this version

+ func InjectHooksConfig(rootDir, sessionTitle string, hooks []HookName) error

+ func InjectMCPConfig(rootDir, binaryPath string) error

+ func RemoveMCPConfig(rootDir string) error

+ type HookName string

+ const HookPermissionApproval

+ const HookPostToolLogging

+ const HookPreToolLogging

+ const HookPromptSubmit

+ const HookStopNotification

+ type HookReceiver struct

+ func NewHookReceiver() *HookReceiver

+ func (h *HookReceiver) HandlePostToolUse(w http.ResponseWriter, r *http.Request)

+ func (h *HookReceiver) HandlePreToolUse(w http.ResponseWriter, r *http.Request)

+ func (h *HookReceiver) HandlePromptSubmit(w http.ResponseWriter, r *http.Request)

+ func (h *HookReceiver) HandleStop(w http.ResponseWriter, r *http.Request)

+ func (h *HookReceiver) RegisterRoutes(mux *http.ServeMux)

+ type ImageUploadHandler struct

+ func NewImageUploadHandler(dir string) *ImageUploadHandler

+ func (h *ImageUploadHandler) HandleUpload(w http.ResponseWriter, r *http.Request)

type SessionService

+ func (s *SessionService) ListBranches(ctx context.Context, req *connect.Request[sessionv1.ListBranchesRequest]) (*connect.Response[sessionv1.ListBranchesResponse], error)

+ func (s *SessionService) SetMCPServerURL(url string)

Apr 21, 2026

Changes in this version

type PushNotification

+ Renotify bool

Apr 21, 2026

Changes in this version

+ type SessionStreamer interface

+ StartControlMode func() error

+ StopControlMode func() error

+ SubscribeControlModeUpdates func() (string, <-chan []byte)

+ UnsubscribeControlModeUpdates func(id string)

Apr 17, 2026

Changes in this version

type SessionService

+ func (s *SessionService) GetTerminalSnapshot(ctx context.Context, ...) (*connect.Response[sessionv1.GetTerminalSnapshotResponse], error)

Apr 16, 2026

Changes in this version

+ type DirCache struct

+ func NewDirCache(maxSize int, ttl time.Duration) *DirCache

+ func (c *DirCache) Get(path string) ([]os.DirEntry, bool)

+ func (c *DirCache) Put(path string, entries []os.DirEntry, dirMtime time.Time)

Apr 14, 2026

Changes in this version

+ var ErrSettingsNotFound = fmt.Errorf("settings file not found")

+ type DefaultsService struct

+ func NewDefaultsService() *DefaultsService

+ func (d *DefaultsService) DeleteDirectoryRule(ctx context.Context, ...) (*connect.Response[sessionv1.DeleteDirectoryRuleResponse], error)

+ func (d *DefaultsService) DeleteProfile(ctx context.Context, req *connect.Request[sessionv1.DeleteProfileRequest]) (*connect.Response[sessionv1.DeleteProfileResponse], error)

+ func (d *DefaultsService) GetSessionDefaults(ctx context.Context, req *connect.Request[sessionv1.GetSessionDefaultsRequest]) (*connect.Response[sessionv1.GetSessionDefaultsResponse], error)

+ func (d *DefaultsService) ResolveDefaults(ctx context.Context, req *connect.Request[sessionv1.ResolveDefaultsRequest]) (*connect.Response[sessionv1.ResolveDefaultsResponse], error)

+ func (d *DefaultsService) UpdateGlobalDefaults(ctx context.Context, ...) (*connect.Response[sessionv1.UpdateGlobalDefaultsResponse], error)

+ func (d *DefaultsService) UpsertDirectoryRule(ctx context.Context, ...) (*connect.Response[sessionv1.UpsertDirectoryRuleResponse], error)

+ func (d *DefaultsService) UpsertProfile(ctx context.Context, req *connect.Request[sessionv1.UpsertProfileRequest]) (*connect.Response[sessionv1.UpsertProfileResponse], error)

type FileService

+ func (fs *FileService) SearchFiles(ctx context.Context, req *connect.Request[sessionv1.SearchFilesRequest]) (*connect.Response[sessionv1.SearchFilesResponse], error)

type PathCompletionService

+ func (p *PathCompletionService) ListWorktrees(ctx context.Context, req *connect.Request[sessionv1.ListWorktreesRequest]) (*connect.Response[sessionv1.ListWorktreesResponse], error)

+ type PushHandler struct

+ func NewPushHandler(pushService *PushService) *PushHandler

+ func (h *PushHandler) RegisterRoutes(mux *http.ServeMux)

+ type PushNotification struct

+ Body string

+ Data map[string]interface{}

+ Icon string

+ RequireInteraction bool

+ Tag string

+ Title string

+ type PushService struct

+ func NewPushService(configDir string) *PushService

+ func (ps *PushService) GetSubscriptions() []PushSubscription

+ func (ps *PushService) GetVapidPublicKey() string

+ func (ps *PushService) SendNotification(notif PushNotification) int

+ func (ps *PushService) Subscribe(sub PushSubscription) string

+ func (ps *PushService) Unsubscribe(endpoint string) bool

+ type PushSubscription struct

+ Endpoint string

+ Keys struct{ ... }

type RuleSpec

+ ToolCategory string

type SessionService

+ func (s *SessionService) DeleteDirectoryRule(ctx context.Context, ...) (*connect.Response[sessionv1.DeleteDirectoryRuleResponse], error)

+ func (s *SessionService) DeleteProfile(ctx context.Context, req *connect.Request[sessionv1.DeleteProfileRequest]) (*connect.Response[sessionv1.DeleteProfileResponse], error)

+ func (s *SessionService) GetSessionDefaults(ctx context.Context, req *connect.Request[sessionv1.GetSessionDefaultsRequest]) (*connect.Response[sessionv1.GetSessionDefaultsResponse], error)

+ func (s *SessionService) ListWorktrees(ctx context.Context, req *connect.Request[sessionv1.ListWorktreesRequest]) (*connect.Response[sessionv1.ListWorktreesResponse], error)

+ func (s *SessionService) ResolveDefaults(ctx context.Context, req *connect.Request[sessionv1.ResolveDefaultsRequest]) (*connect.Response[sessionv1.ResolveDefaultsResponse], error)

+ func (s *SessionService) SearchFiles(ctx context.Context, req *connect.Request[sessionv1.SearchFilesRequest]) (*connect.Response[sessionv1.SearchFilesResponse], error)

+ func (s *SessionService) UpdateGlobalDefaults(ctx context.Context, ...) (*connect.Response[sessionv1.UpdateGlobalDefaultsResponse], error)

+ func (s *SessionService) UpsertDirectoryRule(ctx context.Context, ...) (*connect.Response[sessionv1.UpsertDirectoryRuleResponse], error)

+ func (s *SessionService) UpsertProfile(ctx context.Context, req *connect.Request[sessionv1.UpsertProfileRequest]) (*connect.Response[sessionv1.UpsertProfileResponse], error)

+ type WorkspaceProvider interface

+ GetWorkspace func(sessionID string) (session.Workspace, error)

type WorkspaceService

+ func (ws *WorkspaceService) GetWorkspace(sessionID string) (session.Workspace, error)

Apr 9, 2026

Changes in this version

+ type FileService struct

+ func NewFileService(storage *session.Storage) *FileService

+ func (fs *FileService) GetFileContent(ctx context.Context, req *connect.Request[sessionv1.GetFileContentRequest]) (*connect.Response[sessionv1.GetFileContentResponse], error)

+ func (fs *FileService) ListFiles(ctx context.Context, req *connect.Request[sessionv1.ListFilesRequest]) (*connect.Response[sessionv1.ListFilesResponse], error)

type SessionService

+ func (s *SessionService) GetFileContent(ctx context.Context, req *connect.Request[sessionv1.GetFileContentRequest]) (*connect.Response[sessionv1.GetFileContentResponse], error)

+ func (s *SessionService) ListFiles(ctx context.Context, req *connect.Request[sessionv1.ListFilesRequest]) (*connect.Response[sessionv1.ListFilesResponse], error)

Apr 9, 2026

Changes in this version

+ type PathCompletionService struct

+ func NewPathCompletionService() *PathCompletionService

+ func (p *PathCompletionService) ListPathCompletions(ctx context.Context, ...) (*connect.Response[sessionv1.ListPathCompletionsResponse], error)

type SessionService

+ func (s *SessionService) ListPathCompletions(ctx context.Context, ...) (*connect.Response[sessionv1.ListPathCompletionsResponse], error)

Apr 8, 2026

Changes in this version

+ func ExpandPath(arg string) string

type ParsedCommand

+ ExpandedArgs []string

+ type PathClassification uint

+ const PathCwd

+ const PathGitRepo

+ const PathHome

+ const PathRoot

+ const PathSystemDir

+ const PathTempDir

+ func ClassifyPath(path string, ctx ClassificationContext) PathClassification

+ type PathMatcher struct

+ ArgIndex int

+ MatchIf PathClassification

+ RejectIf PathClassification

+ func (pm *PathMatcher) Matches(expandedArgs []string, ctx ClassificationContext) bool

type Rule

+ PathMatcher *PathMatcher

Apr 8, 2026

Changes in this version

type SessionService

+ func (s *SessionService) GetInstanceStore() session.InstanceStore

Apr 7, 2026

Changes in this version

+ const ToolCategoryAny

+ const ToolCategoryBuiltin

+ const ToolCategoryBuiltinAgent

+ const ToolCategoryMCP

+ const ToolCategoryMCPRead

+ const ToolCategoryMCPWrite

+ func CategorizeToolName(name string) string

+ func ExtractDomainsFromCommand(cmd string) []string

+ func FormatSecretDenyMessage(patternName string) string

+ func InjectHookConfig(rootDir, sessionTitle string) error

+ func StartExpirationCleanup(ctx context.Context, store *ApprovalStore)

+ func WriteSnapshot(snap *DebugSnapshot, dir string) (string, error)

+ type AnalyticsEntry struct

+ Alternative string

+ ApprovalID string

+ CommandCategory string

+ CommandPreview string

+ CommandProgram string

+ CommandSubcategory string

+ Cwd string

+ Decision string

+ DurationMs int64

+ ID string

+ PythonImports []string

+ Reason string

+ RiskLevel string

+ RuleID string

+ RuleName string

+ SessionID string

+ Timestamp time.Time

+ ToolName string

+ func ReclassifyGaps(entries []AnalyticsEntry, c Classifier) []AnalyticsEntry

+ type AnalyticsStore struct

+ func NewAnalyticsStore(filePath string) *AnalyticsStore

+ func (s *AnalyticsStore) DroppedCount() int64

+ func (s *AnalyticsStore) LoadWindow(since time.Time) ([]AnalyticsEntry, error)

+ func (s *AnalyticsStore) Record(entry AnalyticsEntry)

+ func (s *AnalyticsStore) RecordFromResult(payload PermissionRequestPayload, result ClassificationResult, ...)

+ func (s *AnalyticsStore) RecordManualDecision(approvalID, sessionID, toolName, cwd, decision string)

+ func (s *AnalyticsStore) Start(ctx interface{ ... })

+ type AnalyticsSummary struct

+ AutoApproveRate float64

+ CommandSubcommandStats []SubcommandStat

+ CoverageGapCount int

+ CoverageGapRate float64

+ DecisionCounts map[string]int

+ ManualReviewRate float64

+ TopCommandPrograms []ProgramStat

+ TopDeniedCommands []CommandStat

+ TopPythonImports []ImportStat

+ TopTools []ToolStat

+ TopTriggeredRules []RuleStat

+ TopUncoveredPrograms []ProgramStat

+ TopUncoveredTools []ToolStat

+ TotalDecisions int

+ WindowEnd time.Time

+ WindowStart time.Time

+ func ComputeSummary(entries []AnalyticsEntry) AnalyticsSummary

+ type ApprovalDecision struct

+ Behavior string

+ Message string

+ type ApprovalDetail struct

+ ClaudeSessionID string

+ CreatedAt time.Time

+ Cwd string

+ ExpiresAt time.Time

+ ID string

+ PermissionMode string

+ SessionID string

+ ToolInput map[string]interface{}

+ ToolName string

+ type ApprovalHandler struct

+ func NewApprovalHandler(store *ApprovalStore, storage *session.Storage, eventBus *events.EventBus) *ApprovalHandler

+ func (h *ApprovalHandler) HandlePermissionRequest(w http.ResponseWriter, r *http.Request)

+ func (h *ApprovalHandler) SetAnalyticsStore(a *AnalyticsStore)

+ func (h *ApprovalHandler) SetClassifier(c *RuleBasedClassifier)

+ func (h *ApprovalHandler) SetDomainChecker(d *DomainAgeChecker)

+ func (h *ApprovalHandler) SetNotificationStamper(s approvalNotificationStamper)

+ func (h *ApprovalHandler) SetQueueChecker(checker ReviewQueueChecker)

+ type ApprovalService struct

+ func NewApprovalService(store *ApprovalStore) *ApprovalService

+ func (as *ApprovalService) ListPendingApprovals(ctx context.Context, ...) (*connect.Response[sessionv1.ListPendingApprovalsResponse], error)

+ func (as *ApprovalService) ResolveApproval(ctx context.Context, req *connect.Request[sessionv1.ResolveApprovalRequest]) (*connect.Response[sessionv1.ResolveApprovalResponse], error)

+ func (as *ApprovalService) SetNotificationStore(store notificationMetadataStore)

+ type ApprovalSnapshot struct

+ Pending []ApprovalDetail

+ PendingCount int

+ type ApprovalStore struct

+ func NewApprovalStore(filePath string) *ApprovalStore

+ func (s *ApprovalStore) CancelSession(sessionID string) []string

+ func (s *ApprovalStore) CleanupExpired() []string

+ func (s *ApprovalStore) Create(a *PendingApproval) error

+ func (s *ApprovalStore) Get(id string) (*PendingApproval, bool)

+ func (s *ApprovalStore) GetApprovalMetadataBySession(sessionID string) []session.ApprovalMetadata

+ func (s *ApprovalStore) GetBySession(sessionID string) []*PendingApproval

+ func (s *ApprovalStore) GetFilePath() string

+ func (s *ApprovalStore) ListAll() []*PendingApproval

+ func (s *ApprovalStore) Remove(id string)

+ func (s *ApprovalStore) Resolve(id string, decision ApprovalDecision) error

+ type CircuitBreakerHandler struct

+ func NewCircuitBreakerHandler() *CircuitBreakerHandler

+ func (h *CircuitBreakerHandler) HandleCircuitBreakers(w http.ResponseWriter, r *http.Request)

+ func (h *CircuitBreakerHandler) RegisterRoutes(mux *http.ServeMux)

+ type ClassificationContext struct

+ Cwd string

+ IsGitRepo bool

+ IsWorktree bool

+ RepoRoot string

+ type ClassificationDecision int

+ const AutoAllow

+ const AutoDeny

+ const Escalate

+ type ClassificationResult struct

+ Alternative string

+ Decision ClassificationDecision

+ Reason string

+ RiskLevel RiskLevel

+ RuleID string

+ RuleName string

+ type Classifier interface

+ BuildContext func(cwd string) ClassificationContext

+ Classify func(payload PermissionRequestPayload, ctx ClassificationContext) ClassificationResult

+ type ClaudePermissions struct

+ Allow []string

+ Deny []string

+ func ParseClaudeSettings(path string) (*ClaudePermissions, error)

+ type CommandCriteria struct

+ BlockedSubcommands []string

+ ForbiddenFlags []string

+ Programs []string

+ PythonModes []string

+ RequiredFlagPrefixes []string

+ RequiredFlags []string

+ Subcommands []string

+ func (cc *CommandCriteria) Matches(pc ParsedCommand) bool

+ type CommandInfo struct

+ AllPrograms []string

+ Category string

+ Program string

+ Subcommand string

+ func ParseBashCommand(command string) CommandInfo

+ type CommandStat struct

+ Count int

+ Preview string

+ ToolName string

+ type ConfigService struct

+ func NewConfigService() *ConfigService

+ func (cs *ConfigService) GetClaudeConfig(ctx context.Context, req *connect.Request[sessionv1.GetClaudeConfigRequest]) (*connect.Response[sessionv1.GetClaudeConfigResponse], error)

+ func (cs *ConfigService) ListClaudeConfigs(ctx context.Context, req *connect.Request[sessionv1.ListClaudeConfigsRequest]) (*connect.Response[sessionv1.ListClaudeConfigsResponse], error)

+ func (cs *ConfigService) UpdateClaudeConfig(ctx context.Context, req *connect.Request[sessionv1.UpdateClaudeConfigRequest]) (*connect.Response[sessionv1.UpdateClaudeConfigResponse], error)

+ type ConnectRPCWebSocketHandler struct

+ func NewConnectRPCWebSocketHandler(sessionService *SessionService, ...) *ConnectRPCWebSocketHandler

+ func (h *ConnectRPCWebSocketHandler) HandleWebSocket(w http.ResponseWriter, r *http.Request)

+ func (h *ConnectRPCWebSocketHandler) SetExternalSessionSupport(discovery *session.ExternalSessionDiscovery)

+ type DailyBucket struct

+ AutoAllow int

+ AutoDeny int

+ Date string

+ Escalate int

+ ManualAllow int

+ ManualDeny int

+ Total int

+ func ComputeDailyBuckets(entries []AnalyticsEntry) []DailyBucket

+ func (b DailyBucket) AutoApproveRate() float64

+ type DatabaseService struct

+ func NewDatabaseService() *DatabaseService

+ func (ds *DatabaseService) GetCurrentDatabase(ctx context.Context, req *connect.Request[sessionv1.GetCurrentDatabaseRequest]) (*connect.Response[sessionv1.GetCurrentDatabaseResponse], error)

+ func (ds *DatabaseService) ListDatabases(ctx context.Context, req *connect.Request[sessionv1.ListDatabasesRequest]) (*connect.Response[sessionv1.ListDatabasesResponse], error)

+ func (ds *DatabaseService) MergeDatabase(ctx context.Context, req *connect.Request[sessionv1.MergeDatabaseRequest]) (*connect.Response[sessionv1.MergeDatabaseResponse], error)

+ func (ds *DatabaseService) SwitchDatabase(ctx context.Context, req *connect.Request[sessionv1.SwitchDatabaseRequest]) (*connect.Response[sessionv1.SwitchDatabaseResponse], error)

+ type DebugSnapshot struct

+ Approvals ApprovalSnapshot

+ Errors []string

+ Note string

+ RecentLogs RecentLogsSnapshot

+ Server ServerInfo

+ Sessions []SessionSnapshot

+ Timestamp time.Time

+ Tmux TmuxSnapshot

+ Version int

+ func CollectSnapshot(ctx context.Context, note string, instances []*session.Instance, ...) *DebugSnapshot

+ type DomainAgeChecker struct

+ func NewDomainAgeChecker(enabled bool) *DomainAgeChecker

+ func (d *DomainAgeChecker) IsNewlyRegistered(ctx context.Context, domain string) (bool, error)

+ func (d *DomainAgeChecker) NewDomainThreshold() time.Duration

+ type EscapeCodeHandler struct

+ func NewEscapeCodeHandler() *EscapeCodeHandler

+ func (h *EscapeCodeHandler) HandleClear(w http.ResponseWriter, r *http.Request)

+ func (h *EscapeCodeHandler) HandleExport(w http.ResponseWriter, r *http.Request)

+ func (h *EscapeCodeHandler) HandleGetAll(w http.ResponseWriter, r *http.Request)

+ func (h *EscapeCodeHandler) HandleGetByCategory(w http.ResponseWriter, r *http.Request)

+ func (h *EscapeCodeHandler) HandleGetBySession(w http.ResponseWriter, r *http.Request)

+ func (h *EscapeCodeHandler) HandleGetStats(w http.ResponseWriter, r *http.Request)

+ func (h *EscapeCodeHandler) HandleStatus(w http.ResponseWriter, r *http.Request)

+ func (h *EscapeCodeHandler) HandleToggle(w http.ResponseWriter, r *http.Request)

+ func (h *EscapeCodeHandler) RegisterRoutes(mux *http.ServeMux)

+ type ExternalWebSocketHandler struct

+ func NewExternalWebSocketHandler(discovery *session.ExternalSessionDiscovery, ...) *ExternalWebSocketHandler

+ func (h *ExternalWebSocketHandler) HandleApprovalResponse(w http.ResponseWriter, r *http.Request)

+ func (h *ExternalWebSocketHandler) HandleApprovals(w http.ResponseWriter, r *http.Request)

+ type GitHubService struct

+ func NewGitHubService(storage *session.Storage) *GitHubService

+ func (gs *GitHubService) ClosePR(ctx context.Context, req *connect.Request[sessionv1.ClosePRRequest]) (*connect.Response[sessionv1.ClosePRResponse], error)

+ func (gs *GitHubService) GetPRComments(ctx context.Context, req *connect.Request[sessionv1.GetPRCommentsRequest]) (*connect.Response[sessionv1.GetPRCommentsResponse], error)

+ func (gs *GitHubService) GetPRInfo(ctx context.Context, req *connect.Request[sessionv1.GetPRInfoRequest]) (*connect.Response[sessionv1.GetPRInfoResponse], error)

+ func (gs *GitHubService) MergePR(ctx context.Context, req *connect.Request[sessionv1.MergePRRequest]) (*connect.Response[sessionv1.MergePRResponse], error)

+ func (gs *GitHubService) PostPRComment(ctx context.Context, req *connect.Request[sessionv1.PostPRCommentRequest]) (*connect.Response[sessionv1.PostPRCommentResponse], error)

+ type ImportStat struct

+ Count int

+ Module string

+ type NotificationRateLimiter struct

+ func NewNotificationRateLimiter(r float64, b int) *NotificationRateLimiter

+ func (rl *NotificationRateLimiter) Allow(sessionID string) bool

+ func (rl *NotificationRateLimiter) Cleanup(activeSessions []string)

+ func (rl *NotificationRateLimiter) Count() int

+ func (rl *NotificationRateLimiter) Reset(sessionID string)

+ type NotificationService struct

+ func NewNotificationService(rateLimiter *NotificationRateLimiter, eventBus *events.EventBus) *NotificationService

+ func (ns *NotificationService) ClearNotificationHistory(ctx context.Context, ...) (*connect.Response[sessionv1.ClearNotificationHistoryResponse], error)

+ func (ns *NotificationService) GetNotificationHistory(ctx context.Context, ...) (*connect.Response[sessionv1.GetNotificationHistoryResponse], error)

+ func (ns *NotificationService) GetNotificationStore() *notifications.NotificationHistoryStore

+ func (ns *NotificationService) MarkNotificationRead(ctx context.Context, ...) (*connect.Response[sessionv1.MarkNotificationReadResponse], error)

+ func (ns *NotificationService) SendNotification(ctx context.Context, req *connect.Request[sessionv1.SendNotificationRequest]) (*connect.Response[sessionv1.SendNotificationResponse], error)

+ func (ns *NotificationService) SetNotificationStore(store *notifications.NotificationHistoryStore)

+ func (ns *NotificationService) SetReviewQueuePoller(poller *session.ReviewQueuePoller)

+ type ParsedCommand struct

+ Args []string

+ Program string

+ Raw string

+ func ExtractAllCommands(cmd string) []ParsedCommand

+ type PendingApproval struct

+ ClaudeSessionID string

+ CreatedAt time.Time

+ Cwd string

+ ExpiresAt time.Time

+ ID string

+ Orphaned bool

+ PermissionMode string

+ SessionID string

+ ToolInput map[string]interface{}

+ ToolName string

+ type PermissionRequestPayload struct

+ Cwd string

+ HookEventName string

+ PermissionMode string

+ SessionID string

+ ToolInput map[string]interface{}

+ ToolName string

+ TranscriptPath string

+ type PersistedApproval struct

+ ClaudeSessionID string

+ CreatedAt time.Time

+ Cwd string

+ ExpiresAt time.Time

+ ID string

+ Orphaned bool

+ PermissionMode string

+ SessionID string

+ ToolInput map[string]interface{}

+ ToolName string

+ type ProgramStat struct

+ Category string

+ Count int

+ Program string

+ type PythonInfo struct

+ Imports []string

+ IsInline bool

+ func ParsePythonCommand(command string) PythonInfo

+ type ReactiveQueueManager interface

+ AddStreamClient func(ctx context.Context, filters interface{}) (<-chan *sessionv1.ReviewQueueEvent, string)

+ RemoveStreamClient func(clientID string)

+ type RecentLogsSnapshot struct

+ LineCount int

+ Lines []string

+ LogFilePath string

+ type ReviewQueueChecker interface

+ CheckSession func(inst *session.Instance)

+ FindInstance func(sessionID string) *session.Instance

+ type ReviewQueueService struct

+ func NewReviewQueueService(reviewQueue *session.ReviewQueue, storage *session.Storage, ...) *ReviewQueueService

+ func (rqs *ReviewQueueService) AcknowledgeSession(ctx context.Context, req *connect.Request[sessionv1.AcknowledgeSessionRequest]) (*connect.Response[sessionv1.AcknowledgeSessionResponse], error)

+ func (rqs *ReviewQueueService) GetQueue() *session.ReviewQueue

+ func (rqs *ReviewQueueService) GetReviewQueue(ctx context.Context, req *connect.Request[sessionv1.GetReviewQueueRequest]) (*connect.Response[sessionv1.GetReviewQueueResponse], error)

+ func (rqs *ReviewQueueService) LogUserInteraction(ctx context.Context, req *connect.Request[sessionv1.LogUserInteractionRequest]) (*connect.Response[sessionv1.LogUserInteractionResponse], error)

+ func (rqs *ReviewQueueService) SetApprovalStore(store *ApprovalStore)

+ func (rqs *ReviewQueueService) SetReactiveQueueManager(mgr ReactiveQueueManager)

+ func (rqs *ReviewQueueService) SetReviewQueuePoller(poller *session.ReviewQueuePoller)

+ func (rqs *ReviewQueueService) WatchReviewQueue(ctx context.Context, req *connect.Request[sessionv1.WatchReviewQueueRequest], ...) error

+ type RiskLevel int

+ const RiskCritical

+ const RiskHigh

+ const RiskLow

+ const RiskMedium

+ type Rule struct

+ Alternative string

+ CommandPattern *regexp.Regexp

+ Criteria *CommandCriteria

+ Decision ClassificationDecision

+ Enabled bool

+ FilePattern *regexp.Regexp

+ ID string

+ Name string

+ Priority int

+ Reason string

+ RiskLevel RiskLevel

+ Source string

+ ToolCategory string

+ ToolName string

+ ToolPattern *regexp.Regexp

+ func LoadClaudeSettingsRules(projectDir string) []Rule

+ func SeedRules() []Rule

+ type RuleBasedClassifier struct

+ func NewRuleBasedClassifier() *RuleBasedClassifier

+ func (c *RuleBasedClassifier) AddRules(rules []Rule)

+ func (c *RuleBasedClassifier) BuildContext(cwd string) ClassificationContext

+ func (c *RuleBasedClassifier) Classify(payload PermissionRequestPayload, ctx ClassificationContext) ClassificationResult

+ func (c *RuleBasedClassifier) ReplaceRules(rules []Rule)

+ func (c *RuleBasedClassifier) Rules() []Rule

+ type RuleSpec struct

+ Alternative string

+ CommandPattern string

+ CreatedAt time.Time

+ Decision string

+ Enabled bool

+ FilePattern string

+ ID string

+ Name string

+ Priority int

+ Reason string

+ RiskLevel string

+ Source string

+ ToolName string

+ ToolPattern string

+ type RuleStat struct

+ Count int

+ RuleID string

+ RuleName string

+ type RulesFile struct

+ Rules []RuleSpec

+ Version int

+ type RulesService struct

+ func NewRulesService(rulesStore *RulesStore, analyticsStore *AnalyticsStore, ...) *RulesService

+ func (rs *RulesService) DeleteApprovalRule(ctx context.Context, req *connect.Request[sessionv1.DeleteApprovalRuleRequest]) (*connect.Response[sessionv1.DeleteApprovalRuleResponse], error)

+ func (rs *RulesService) GetApprovalAnalytics(ctx context.Context, ...) (*connect.Response[sessionv1.GetApprovalAnalyticsResponse], error)

+ func (rs *RulesService) ListApprovalRules(ctx context.Context, req *connect.Request[sessionv1.ListApprovalRulesRequest]) (*connect.Response[sessionv1.ListApprovalRulesResponse], error)

+ func (rs *RulesService) UpsertApprovalRule(ctx context.Context, req *connect.Request[sessionv1.UpsertApprovalRuleRequest]) (*connect.Response[sessionv1.UpsertApprovalRuleResponse], error)

+ type RulesStore struct

+ func NewRulesStore(filePath string) (*RulesStore, error)

+ func (s *RulesStore) All() []RuleSpec

+ func (s *RulesStore) Delete(id string) error

+ func (s *RulesStore) ToRules() []Rule

+ func (s *RulesStore) Upsert(spec RuleSpec) (RuleSpec, error)

+ func (s *RulesStore) WatchAndReload(ctx context.Context)

+ type SearchService struct

+ func NewSearchService(searchEngine *search.SearchEngine, snippetGenerator *search.SnippetGenerator, ...) *SearchService

+ func (ss *SearchService) GetClaudeHistoryDetail(ctx context.Context, ...) (*connect.Response[sessionv1.GetClaudeHistoryDetailResponse], error)

+ func (ss *SearchService) GetClaudeHistoryMessages(ctx context.Context, ...) (*connect.Response[sessionv1.GetClaudeHistoryMessagesResponse], error)

+ func (ss *SearchService) ListClaudeHistory(ctx context.Context, req *connect.Request[sessionv1.ListClaudeHistoryRequest]) (*connect.Response[sessionv1.ListClaudeHistoryResponse], error)

+ func (ss *SearchService) SearchClaudeHistory(ctx context.Context, ...) (*connect.Response[sessionv1.SearchClaudeHistoryResponse], error)

+ type SecretScanResult struct

+ Found bool

+ PatternName string

+ func ScanForSecrets(text string) SecretScanResult

+ type ServerInfo struct

+ Arch string

+ GoVersion string

+ OS string

+ PID int

+ UptimeSeconds int64

+ type SessionService struct

+ func NewSessionService(storage *session.Storage, eventBus *events.EventBus) *SessionService

+ func NewSessionServiceFromConfig() (*SessionService, error)

+ func (s *SessionService) AcknowledgeSession(ctx context.Context, req *connect.Request[sessionv1.AcknowledgeSessionRequest]) (*connect.Response[sessionv1.AcknowledgeSessionResponse], error)

+ func (s *SessionService) ClearNotificationHistory(ctx context.Context, ...) (*connect.Response[sessionv1.ClearNotificationHistoryResponse], error)

+ func (s *SessionService) ClosePR(ctx context.Context, req *connect.Request[sessionv1.ClosePRRequest]) (*connect.Response[sessionv1.ClosePRResponse], error)

+ func (s *SessionService) CreateCheckpoint(ctx context.Context, req *connect.Request[sessionv1.CreateCheckpointRequest]) (*connect.Response[sessionv1.CreateCheckpointResponse], error)

+ func (s *SessionService) CreateDebugSnapshot(ctx context.Context, ...) (*connect.Response[sessionv1.CreateDebugSnapshotResponse], error)

+ func (s *SessionService) CreateSession(ctx context.Context, req *connect.Request[sessionv1.CreateSessionRequest]) (*connect.Response[sessionv1.CreateSessionResponse], error)

+ func (s *SessionService) DeleteApprovalRule(ctx context.Context, req *connect.Request[sessionv1.DeleteApprovalRuleRequest]) (*connect.Response[sessionv1.DeleteApprovalRuleResponse], error)

+ func (s *SessionService) DeleteSession(ctx context.Context, req *connect.Request[sessionv1.DeleteSessionRequest]) (*connect.Response[sessionv1.DeleteSessionResponse], error)

+ func (s *SessionService) FocusWindow(ctx context.Context, req *connect.Request[sessionv1.FocusWindowRequest]) (*connect.Response[sessionv1.FocusWindowResponse], error)

+ func (s *SessionService) ForkSession(ctx context.Context, req *connect.Request[sessionv1.ForkSessionRequest]) (*connect.Response[sessionv1.ForkSessionResponse], error)

+ func (s *SessionService) GetAnalyticsStore() *AnalyticsStore

+ func (s *SessionService) GetApprovalAnalytics(ctx context.Context, ...) (*connect.Response[sessionv1.GetApprovalAnalyticsResponse], error)

+ func (s *SessionService) GetApprovalStore() *ApprovalStore

+ func (s *SessionService) GetClassifier() *RuleBasedClassifier

+ func (s *SessionService) GetClaudeConfig(ctx context.Context, req *connect.Request[sessionv1.GetClaudeConfigRequest]) (*connect.Response[sessionv1.GetClaudeConfigResponse], error)

+ func (s *SessionService) GetClaudeHistoryDetail(ctx context.Context, ...) (*connect.Response[sessionv1.GetClaudeHistoryDetailResponse], error)

+ func (s *SessionService) GetClaudeHistoryMessages(ctx context.Context, ...) (*connect.Response[sessionv1.GetClaudeHistoryMessagesResponse], error)

+ func (s *SessionService) GetCurrentDatabase(ctx context.Context, req *connect.Request[sessionv1.GetCurrentDatabaseRequest]) (*connect.Response[sessionv1.GetCurrentDatabaseResponse], error)

+ func (s *SessionService) GetEventBus() *events.EventBus

+ func (s *SessionService) GetLogs(ctx context.Context, req *connect.Request[sessionv1.GetLogsRequest]) (*connect.Response[sessionv1.GetLogsResponse], error)

+ func (s *SessionService) GetNotificationHistory(ctx context.Context, ...) (*connect.Response[sessionv1.GetNotificationHistoryResponse], error)

+ func (s *SessionService) GetNotificationStore() *notifications.NotificationHistoryStore

+ func (s *SessionService) GetPRComments(ctx context.Context, req *connect.Request[sessionv1.GetPRCommentsRequest]) (*connect.Response[sessionv1.GetPRCommentsResponse], error)

+ func (s *SessionService) GetPRInfo(ctx context.Context, req *connect.Request[sessionv1.GetPRInfoRequest]) (*connect.Response[sessionv1.GetPRInfoResponse], error)

+ func (s *SessionService) GetReviewQueue(ctx context.Context, req *connect.Request[sessionv1.GetReviewQueueRequest]) (*connect.Response[sessionv1.GetReviewQueueResponse], error)

+ func (s *SessionService) GetReviewQueueInstance() *session.ReviewQueue

+ func (s *SessionService) GetSession(ctx context.Context, req *connect.Request[sessionv1.GetSessionRequest]) (*connect.Response[sessionv1.GetSessionResponse], error)

+ func (s *SessionService) GetSessionDiff(ctx context.Context, req *connect.Request[sessionv1.GetSessionDiffRequest]) (*connect.Response[sessionv1.GetSessionDiffResponse], error)

+ func (s *SessionService) GetStorage() *session.Storage

+ func (s *SessionService) GetVCSStatus(ctx context.Context, req *connect.Request[sessionv1.GetVCSStatusRequest]) (*connect.Response[sessionv1.GetVCSStatusResponse], error)

+ func (s *SessionService) GetWorkspaceInfo(ctx context.Context, req *connect.Request[sessionv1.GetWorkspaceInfoRequest]) (*connect.Response[sessionv1.GetWorkspaceInfoResponse], error)

+ func (s *SessionService) ListApprovalRules(ctx context.Context, req *connect.Request[sessionv1.ListApprovalRulesRequest]) (*connect.Response[sessionv1.ListApprovalRulesResponse], error)

+ func (s *SessionService) ListCheckpoints(ctx context.Context, req *connect.Request[sessionv1.ListCheckpointsRequest]) (*connect.Response[sessionv1.ListCheckpointsResponse], error)

+ func (s *SessionService) ListClaudeConfigs(ctx context.Context, req *connect.Request[sessionv1.ListClaudeConfigsRequest]) (*connect.Response[sessionv1.ListClaudeConfigsResponse], error)

+ func (s *SessionService) ListClaudeHistory(ctx context.Context, req *connect.Request[sessionv1.ListClaudeHistoryRequest]) (*connect.Response[sessionv1.ListClaudeHistoryResponse], error)

+ func (s *SessionService) ListDatabases(ctx context.Context, req *connect.Request[sessionv1.ListDatabasesRequest]) (*connect.Response[sessionv1.ListDatabasesResponse], error)

+ func (s *SessionService) ListPendingApprovals(ctx context.Context, ...) (*connect.Response[sessionv1.ListPendingApprovalsResponse], error)

+ func (s *SessionService) ListSessions(ctx context.Context, req *connect.Request[sessionv1.ListSessionsRequest]) (*connect.Response[sessionv1.ListSessionsResponse], error)

+ func (s *SessionService) ListWorkspaceTargets(ctx context.Context, ...) (*connect.Response[sessionv1.ListWorkspaceTargetsResponse], error)

+ func (s *SessionService) LogUserInteraction(ctx context.Context, req *connect.Request[sessionv1.LogUserInteractionRequest]) (*connect.Response[sessionv1.LogUserInteractionResponse], error)

+ func (s *SessionService) MarkNotificationRead(ctx context.Context, ...) (*connect.Response[sessionv1.MarkNotificationReadResponse], error)

+ func (s *SessionService) MergeDatabase(ctx context.Context, req *connect.Request[sessionv1.MergeDatabaseRequest]) (*connect.Response[sessionv1.MergeDatabaseResponse], error)

+ func (s *SessionService) MergePR(ctx context.Context, req *connect.Request[sessionv1.MergePRRequest]) (*connect.Response[sessionv1.MergePRResponse], error)

+ func (s *SessionService) PostPRComment(ctx context.Context, req *connect.Request[sessionv1.PostPRCommentRequest]) (*connect.Response[sessionv1.PostPRCommentResponse], error)

+ func (s *SessionService) RenameSession(ctx context.Context, req *connect.Request[sessionv1.RenameSessionRequest]) (*connect.Response[sessionv1.RenameSessionResponse], error)

+ func (s *SessionService) ResolveApproval(ctx context.Context, req *connect.Request[sessionv1.ResolveApprovalRequest]) (*connect.Response[sessionv1.ResolveApprovalResponse], error)

+ func (s *SessionService) RestartSession(ctx context.Context, req *connect.Request[sessionv1.RestartSessionRequest]) (*connect.Response[sessionv1.RestartSessionResponse], error)

+ func (s *SessionService) SearchClaudeHistory(ctx context.Context, ...) (*connect.Response[sessionv1.SearchClaudeHistoryResponse], error)

+ func (s *SessionService) SendNotification(ctx context.Context, req *connect.Request[sessionv1.SendNotificationRequest]) (*connect.Response[sessionv1.SendNotificationResponse], error)

+ func (s *SessionService) SetConfigService(svc *ConfigService)

+ func (s *SessionService) SetExternalDiscovery(discovery *session.ExternalSessionDiscovery)

+ func (s *SessionService) SetNotificationStore(store *notifications.NotificationHistoryStore)

+ func (s *SessionService) SetReactiveQueueManager(mgr ReactiveQueueManager)

+ func (s *SessionService) SetReviewQueuePoller(poller *session.ReviewQueuePoller)

+ func (s *SessionService) SetScrollbackManager(mgr scrollbackSequencer)

+ func (s *SessionService) SetStatusManager(mgr *session.InstanceStatusManager)

+ func (s *SessionService) StreamTerminal(ctx context.Context, ...) error

+ func (s *SessionService) SwitchDatabase(ctx context.Context, req *connect.Request[sessionv1.SwitchDatabaseRequest]) (*connect.Response[sessionv1.SwitchDatabaseResponse], error)

+ func (s *SessionService) SwitchWorkspace(ctx context.Context, req *connect.Request[sessionv1.SwitchWorkspaceRequest]) (*connect.Response[sessionv1.SwitchWorkspaceResponse], error)

+ func (s *SessionService) UpdateClaudeConfig(ctx context.Context, req *connect.Request[sessionv1.UpdateClaudeConfigRequest]) (*connect.Response[sessionv1.UpdateClaudeConfigResponse], error)

+ func (s *SessionService) UpdateSession(ctx context.Context, req *connect.Request[sessionv1.UpdateSessionRequest]) (*connect.Response[sessionv1.UpdateSessionResponse], error)

+ func (s *SessionService) UpsertApprovalRule(ctx context.Context, req *connect.Request[sessionv1.UpsertApprovalRuleRequest]) (*connect.Response[sessionv1.UpsertApprovalRuleResponse], error)

+ func (s *SessionService) WatchReviewQueue(ctx context.Context, req *connect.Request[sessionv1.WatchReviewQueueRequest], ...) error

+ func (s *SessionService) WatchSessions(ctx context.Context, req *connect.Request[sessionv1.WatchSessionsRequest], ...) error

+ type SessionSnapshot struct

+ Branch string

+ Category string

+ CreatedAt time.Time

+ GitHubPRNumber int

+ InstanceType string

+ LastMeaningfulOutput time.Time

+ LastOutputSignature string

+ LastTerminalUpdate time.Time

+ PaneContent string

+ PaneContentRaw string

+ PaneContentTruncated bool

+ Path string

+ Program string

+ SessionType string

+ Status string

+ Tags []string

+ Title string

+ UpdatedAt time.Time

+ type SubcommandStat struct

+ Category string

+ Count int

+ Program string

+ Subcommand string

+ type TerminalWebSocketHandler struct

+ func NewTerminalWebSocketHandler(storage session.Storage, eventBus *events.EventBus) *TerminalWebSocketHandler

+ func (h *TerminalWebSocketHandler) HandleWebSocket(w http.ResponseWriter, r *http.Request)

+ type TmuxSessionDetail struct

+ ListPanesOutput string

+ PaneContent string

+ TmuxSessionName string

+ type TmuxSnapshot struct

+ ListSessionsOutput string

+ PerSession []TmuxSessionDetail

+ type ToolStat struct

+ Count int

+ ToolName string

+ type UtilityService struct

+ func NewUtilityService(approvalStore *ApprovalStore) *UtilityService

+ func (us *UtilityService) CreateDebugSnapshot(ctx context.Context, ...) (*connect.Response[sessionv1.CreateDebugSnapshotResponse], error)

+ func (us *UtilityService) FocusWindow(ctx context.Context, req *connect.Request[sessionv1.FocusWindowRequest]) (*connect.Response[sessionv1.FocusWindowResponse], error)

+ func (us *UtilityService) GetLogs(ctx context.Context, req *connect.Request[sessionv1.GetLogsRequest]) (*connect.Response[sessionv1.GetLogsResponse], error)

+ func (us *UtilityService) SetReviewQueuePoller(poller *session.ReviewQueuePoller)

+ type WatchReviewQueueFilters struct

+ IncludeStatistics bool

+ InitialSnapshot bool

+ PriorityFilter []session.Priority

+ ReasonFilter []session.AttentionReason

+ SessionIDs []string

+ func (f *WatchReviewQueueFilters) GetIncludeStatistics() bool

+ func (f *WatchReviewQueueFilters) GetInitialSnapshot() bool

+ func (f *WatchReviewQueueFilters) GetPriorityFilter() []session.Priority

+ func (f *WatchReviewQueueFilters) GetReasonFilter() []session.AttentionReason

+ func (f *WatchReviewQueueFilters) GetSessionIDs() []string

+ type WorkspaceService struct

+ func NewWorkspaceService(storage *session.Storage, eventBus *events.EventBus) *WorkspaceService

+ func (ws *WorkspaceService) GetVCSStatus(ctx context.Context, req *connect.Request[sessionv1.GetVCSStatusRequest]) (*connect.Response[sessionv1.GetVCSStatusResponse], error)

+ func (ws *WorkspaceService) GetWorkspaceInfo(ctx context.Context, req *connect.Request[sessionv1.GetWorkspaceInfoRequest]) (*connect.Response[sessionv1.GetWorkspaceInfoResponse], error)

+ func (ws *WorkspaceService) ListWorkspaceTargets(ctx context.Context, ...) (*connect.Response[sessionv1.ListWorkspaceTargetsResponse], error)

+ func (ws *WorkspaceService) SwitchWorkspace(ctx context.Context, req *connect.Request[sessionv1.SwitchWorkspaceRequest]) (*connect.Response[sessionv1.SwitchWorkspaceResponse], error)