kernel

type Budgets struct {
	// Root applies to every Process an application entry point spawns.
	Root budget.Root
	// Task applies to the sub-agent Processes a plan-execute run spawns.
	Task budget.Config
}

type BusyTurn struct {
	ProcessID agentkit.ProcessID
	// StartedAt is when the holding Process was created, which is the moment the
	// turn began.
	StartedAt time.Time
}

type Deps struct {
	// Repo is the durable Process store.
	Repo agentkit.Repository
	// History persists each Process's conversation as immutable versions.
	History agentkit.HistoryStore
	// LLM is the default model. A strategy that binds a model role to something
	// else does so through WithModelRole; an unbound role falls back here.
	LLM gollem.LLMClient
	// Trace is where each claim's archive is written.
	Trace trace.Repository
	// Tools carries the clients and usecases the tool factory builds from.
	Tools ToolDeps
	// Budgets are the ceilings Strategy.Limit answers with.
	Budgets Budgets
	// Models is which model each run generates through and what it may spend.
	// Required: without it a run has neither a priced ceiling nor a way to reach
	// a model other than the default one.
	Models ModelPolicy
	// Agents is the registry the application filled with its strategies before
	// building the Kernel. agentkit requires every Register to complete before
	// the first Spawn or Serve, so registration is the caller's job and this is
	// the finished result.
	Agents *agentkit.Registry
	// Slots is the deployment-wide concurrency gate. Optional: nil leaves every
	// run ungated, which is what a deployment that configured no limit wants.
	// Only runs whose Scope sets SlotGated are subject to it.
	Slots SlotGate
}

type Locator interface {
	// Busy names the run holding subject, or (nil, nil) when none does.
	Busy(ctx context.Context, subject agentkit.SubjectRef) (*BusyTurn, error)
	// ByTrigger names the run an earlier delivery of the same trigger already
	// started, or "" when there is none. Spawn resolves an idempotency key
	// silently — it returns the existing id without saying that it is existing —
	// so asking first is the only way to tell a re-delivery from a fresh event.
	ByTrigger(ctx context.Context, key string) (agentkit.ProcessID, error)
}

type ModelDef struct {
	// Ref is the name a Job or the CLI names this model by. Unique across every
	// definition the deployment loaded.
	Ref string
	// Provider is which client builds it: openai, claude or gemini.
	Provider string
	// Model is the model name handed to that provider.
	Model string
	// Rate prices one token of each kind.
	Rate pricing.Rate
}

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

type ModelPolicyInput struct {
	// Defs are every model the deployment declared. Reference names must be
	// unique, and every definition must be priced.
	Defs []ModelDef
	// DefaultRef is the reference name of the model a run that names none
	// generates through. Required, and must be one of Defs.
	DefaultRef string
	// Clients maps a reference name to the client that serves it. The default
	// reference needs no entry: it is the Kernel's positional client, which an
	// unbound role already resolves to.
	Clients map[string]gollem.LLMClient
	// DefaultBudget is what a run that names no budget of its own may spend.
	// Required and positive: a zero ceiling stops every run (see
	// budget.Root.Limiter), so it must be caught here rather than at the first
	// transition.
	DefaultBudget pricing.NanoUSD
}

type Scope struct {
	// WorkspaceID identifies the workspace whose configuration and tools this
	// Process runs under. Empty only for the workspace-agnostic draft flow.
	WorkspaceID string
	// CaseID is the case this Process is pinned to, or 0 when there is none
	// (a draft turn, or a create turn before the case exists).
	CaseID int64
	// ChannelID / ThreadTS locate the run's own Slack thread — the one its Session
	// is keyed on, and the one its answer belongs in.
	ChannelID string
	ThreadTS  string
	// UIChannelID / UIThreadTS locate the thread the person who triggered the run
	// is watching, for the runs where that is a DIFFERENT thread: a case raised by
	// a reaction lives in the monitored channel, while the reactor is watching the
	// thread they reacted in. Progress, questions and failure notices go here;
	// the case's own content still goes to ChannelID / ThreadTS.
	//
	// Empty means the two are the same thread, which is the case for every other
	// run. UITarget resolves that.
	UIChannelID string
	UIThreadTS  string
	// ProcessingTS and PreviewTS name the Slack message a case-draft turn's result
	// replaces, and are mutually exclusive: ProcessingTS is the "working on it"
	// placeholder a fresh mention posted, PreviewTS is the existing draft preview a
	// workspace switch updates in place. They live on the scope because the turn
	// that posted them returns long before the result exists, and the completion
	// handler runs on whichever instance committed the last transition.
	ProcessingTS string
	PreviewTS    string
	// SessionID is the model.Session this thread belongs to. It doubles as the
	// turn-lock subject id.
	SessionID string
	// ActorUserID is the Slack user whose access this run acts under. The claim
	// middleware turns it into the request-scoped auth token, so a run without
	// one acts with no user scope at all.
	ActorUserID string
	// Lang is the i18n language tag for user-facing copy this run produces.
	Lang string
	// ToolSets is the list of toolset ids this Process may use, or the single
	// element ToolSetsAll.
	ToolSets []string
	// PrivateCase withholds the workspace-wide knowledge write tools: a private
	// case's contents must not reach shared knowledge through an agent write.
	PrivateCase bool
	// JobID / JobRunID / EventType tie the run to its JobRunLog record. Empty
	// for runs that keep no such record.
	JobID     string
	JobRunID  string
	EventType string
	// SlotGated subjects the run to the deployment-wide concurrency gate: a
	// claim on it waits for a free execution slot before any transition runs.
	//
	// The host decides it at spawn rather than the runtime inferring it, so the
	// kernel needs no opinion about which kinds of run are rate-limited. Today
	// only scheduled Job runs set it — an interactive turn is a person waiting
	// for an answer, and a lifecycle or manual run is a single deliberate
	// action, so making either queue behind a batch would be the wrong trade.
	SlotGated bool
	// ProposalID names the case draft this run writes its result into. Empty for
	// every run that is not a case-draft turn.
	//
	// It travels on the run because the Session's ProposalID is MUTABLE: a later
	// mention on the same thread points the Session at a new draft, and it can do
	// so while this run is still going. A completion handler that read the Session
	// instead would write this run's draft into whatever draft the thread points at
	// by then.
	ProposalID string
	// LLMModel is the reference name of the model this run generates through —
	// an [[llm_model]] entry's alias, or its model name when it declares none.
	// Empty means the deployment's default model. A child Process inherits the
	// metadata, so a run's sub-agents generate through the same model.
	//
	// It carries neither the provider nor the price on purpose: both are read
	// from the reference name by the ModelPolicy built at startup. A run whose
	// reference name is no longer defined therefore falls back to the default
	// client AND the default price together — carrying a rate here would let it
	// generate with one model while being metered at another's.
	LLMModel string
	// Budget is the greatest amount this run may spend. Zero means "not
	// specified", and the deployment's default budget applies.
	Budget pricing.NanoUSD
}

type SlotGate interface {
	// Acquire takes a slot for the run identified by ref, and returns
	// (nil, nil) when every slot is occupied.
	//
	// "None free" is an ordinary answer, not an error: the caller waits and is
	// asked again. An error means the gate could not tell how many runs are in
	// flight, which the caller must treat as "do not proceed".
	Acquire(ctx context.Context, ref SlotRef) (SlotHold, error)
}

type SlotHold interface {
	Release(ctx context.Context)
}

type SlotRef struct {
	WorkspaceID string
	CaseID      int64
	JobID       string
}

type ToolDeps struct {
	Repo     interfaces.Repository    // required
	Registry *model.WorkspaceRegistry // required

	SlackBot       slacktool.BotService
	SlackSearch    slacktool.SearchService
	SlackRetriever slacktool.MessageRetriever
	// SlackPoster backs the channel-pinned poster an unattended run reports
	// through. It is a narrower interface than SlackBot on purpose: an LLM holding
	// the post tool must not reach the wider Slack surface.
	SlackPoster slackpost.Poster
	// SlackLimits bounds how much of a Slack read tool's result reaches the
	// model context. The zero value leaves both bounds disabled.
	SlackLimits    slacktool.Limits
	NotionClient   notiontool.Client
	GitHubClient   *githubtool.Client
	WebFetchClient *webfetch.Client

	// JiraTools carries the already-expanded Jira read tools. gollem exposes no
	// helper to turn a ToolSet into []Tool, so the CLI expands it once at
	// startup and hands the result through as a plain slice.
	JiraTools []gollem.Tool

	ActionUC     core.ActionMutator
	ActionStepUC core.ActionStepMutator
	CaseUC       casewriter.CaseMutator
	CaseRefUC    core.CaseRefReader

	CaseMultiUC       casemulti.CaseUsecase
	CaseMultiActionUC casemulti.ActionUsecase

	MemoUC memotool.MemoMutator

	KnowledgeAccessor knowledgetool.KnowledgeAccessor
	KnowledgeMutator  knowledgetool.KnowledgeMutator
}

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