agent

type Budget struct {
	PlannerMax      int
	PlannerUsed     int
	SubAgentLoopMax int
}

type BusyInfo struct {
	// StartedAt is the live owner's TurnStartedAt timestamp.
	StartedAt time.Time
	// OwnerID is the live owner's TurnOwnerID, useful for debug logs.
	OwnerID string
}

type CommonDeps struct {
	Repo        interfaces.Repository
	Registry    *model.WorkspaceRegistry
	LLMClient   gollem.LLMClient
	HistoryRepo gollem.HistoryRepository
	TraceRepo   trace.Repository

	// Optional sub-agent service / client deps. nil → the corresponding tool
	// set is empty.
	SlackSearch    slacktool.SearchService
	SlackBot       slacktool.BotService
	SlackRetriever slacktool.MessageRetriever
	NotionClient   notiontool.Client
	GitHubClient   *githubtool.Client
	WebFetchClient *webfetch.Client

	// JiraTools carries the already-expanded Jira read tools (see
	// pkg/agent/tool/jira). Unlike NotionClient/GitHubClient/WebFetchClient
	// this is not a client type: gollem exposes no exported helper to turn a
	// gollem.ToolSet into []gollem.Tool, so config.Jira.Configure expands it
	// once at startup and hands the result through as a plain tool slice.
	// nil/empty means Jira is not configured. Consumed both directly here
	// (casebound's always-on tool set) and via agent.ToolSetDeps.Jira for
	// the sub-agent resolver (proposal / threadcase investigation).
	JiraTools []gollem.Tool

	// Action mutator interfaces, used by `core` toolset. Required for
	// case-bound mode (which uses the full mutating tool set). Optional for
	// draft mode (read-only sub-agents).
	ActionUC     core.ActionMutator
	ActionStepUC core.ActionStepMutator

	// CaseUC backs the casewriter tools (case__update_case /
	// case__update_case_status / case__close_case) in case-bound mode. Optional:
	// nil means the case-bound agent cannot edit the case itself (the tools are
	// not built).
	CaseUC casewriter.CaseMutator

	// CaseRefUC backs the case_ref read tools
	// (core__search_referenceable_cases / core__get_referenceable_cases).
	// Optional: nil disables those tools (no case_ref fields configured).
	CaseRefUC core.CaseRefReader

	// CaseMultiUC / CaseMultiActionUC back the cross-case (case_multi) tool set
	// used by the workspace-channel agent. Unlike CaseUC (single-case
	// casewriter.CaseMutator), these carry the full cross-case read+write
	// surface whose tools take case_id at call time. Wired from the concrete
	// usecases via usecase.NewCaseMultiCaseAdapter / NewCaseMultiActionAdapter.
	// Optional: nil disables the cross-case tools.
	CaseMultiUC       casemulti.CaseUsecase
	CaseMultiActionUC casemulti.ActionUsecase

	// MemoUC backs the Case-scoped memo tools (memo__*) in case-bound mode.
	// Optional: nil means the agent gets no memo tools.
	MemoUC memotool.MemoMutator

	// KnowledgeAccessor backs the read-only workspace knowledge tools
	// (knowledge__search/get/list_tags). When set, read access is always
	// offered. KnowledgeMutator backs the write tools (create/update); each
	// mode wires the write tools only when the agent is permitted to mutate
	// shared knowledge (i.e. not while processing a private case). Both are
	// optional: nil means the corresponding tools are not built.
	KnowledgeAccessor knowledgetool.KnowledgeAccessor
	KnowledgeMutator  knowledgetool.KnowledgeMutator

	// HeartbeatInterval / HeartbeatStaleAfter govern §5.3 turn-lock activity
	// detection. Zero values fall back to DefaultHeartbeatInterval /
	// DefaultHeartbeatStaleAfter.
	HeartbeatInterval   time.Duration
	HeartbeatStaleAfter time.Duration
}

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

type LoadOrCreateSessionInput struct {
	ChannelID string
	ThreadTS  string

	// Case-bound mode fields. Zero values when this is open-mode.
	WorkspaceID string
	CaseID      int64
	// DetectActionID, when non-nil, runs a side lookup for an Action whose
	// SlackMessageTS matches ThreadTS (used by case-bound mode to link the
	// session to the action thread). Pass nil to skip.
	DetectActionID func(ctx context.Context, workspaceID, threadTS string) (int64, error)

	// Open-mode fields. Zero values when case-bound.
	CreatorUserID string
	ProposalID    model.CaseProposalID
}

type ToolSetDeps struct {
	Core      core.Deps
	Slack     slacktool.Deps
	Notion    notiontool.Deps
	GitHub    *githubtool.Client
	WebFetch  *webfetch.Client
	Knowledge knowledgetool.Deps

	// Jira carries the already-expanded Jira read tools (see
	// pkg/agent/tool/jira). nil/empty means Jira is not configured, so the
	// "jira" ToolSet ID resolves to nothing.
	Jira []gollem.Tool

	// CaseWrite backs the case_write toolset (the full single-case writer set).
	// The tools are built when CaseUC and CaseID identify a concrete case; a zero
	// value (no case yet, or no mutator wired) leaves the toolset empty so
	// requesting the ID resolves to nothing. StatusSet selects the mode-specific
	// "mark done" tool (case__update_case_status when set, case__close_case when
	// not) and Schema drives case__update_case's custom-field coercion.
	CaseWrite casewriter.Deps

	// OmitCore omits the core (action) toolset entirely. Set by thread-mode
	// agents: a thread-mode workspace manages no Actions, so even the
	// read-only list/get-action tools must not exist. Without this the
	// resolver would always build them (they only need Repo), since the
	// core read tools do not depend on ActionUC being wired.
	OmitCore bool

	// CaseMulti backs the case_multi (cross-case) toolset. Built only when
	// CaseMulti.CaseUC is non-nil (the workspace-channel host wires it); a nil
	// CaseUC leaves the toolset empty so requesting the ID resolves to nothing.
	CaseMulti casemulti.Deps
}

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

type TurnHandle struct {
	// Ctx is the cancellable context for this turn. Heartbeat owner-mismatch
	// (and Phase B interrupt) cancels it via cancelTurn; the mode body should
	// honour ctx.Done() at every awaitable boundary.
	Ctx context.Context
	// Session reflects the post-acquire state (TurnOwnerID, TurnHeartbeatAt
	// already populated).
	Session *model.Session
	// OwnerID is what the mode passes back to ReleaseTurnLock / Heartbeat.
	OwnerID string
	// Acquired is true iff the turn body should run.
	Acquired bool
	// Reclaimed is true when the lock was claimed from a stale prior owner.
	Reclaimed bool
	// Idempotent is true when the current trigger matches the live owner's
	// trigger (Slack duplicate event); the mode should drop and return nil.
	Idempotent bool
	// BusyOwner, when not nil, signals the lock is held by a fresh owner;
	// the mode should call its host's PostBusy and return.
	BusyOwner *model.Session
	// Release stops the heartbeat goroutine and releases the lock. Always
	// safe to call (no-op when Acquired is false). Pass an outer-scoped ctx
	// (typically the parent ctx, not Ctx, so a turn cancellation does not
	// strand the release).
	Release func(ctx context.Context)
}