goal

type AtomicStore interface {
	Store
	MutateGoals(ctx context.Context, workspaceID, sessionID string, mutate Mutation) error
	AccountGoalUsage(ctx context.Context, workspaceID, sessionID, goalID, assistantMessageID string, tokenDelta uint64, updatedAt string) (spec.SessionGoalRecord, bool, error)
}

type BoundedPolicy struct {
	MaxContinuations uint32
}

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

type CASLedgerConfig struct {
	Blobs      casblob.Store
	Prefix     string
	MaxRetries int
	Now        func() time.Time
}

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

type CASStoreConfig struct {
	Blobs      casblob.Store
	Prefix     string
	MaxRetries int
}

type ContinuationAdmission struct {
	WorkspaceID     string
	SessionID       string
	GoalID          string
	ParentTaskID    string
	ParentMessageID string
	Attempt         uint32
	Inbound         channel.Inbound
	Authority       tools.MemoryAuthority
}

type ContinuationBackend interface {
	Admit(ctx context.Context, admission ContinuationAdmission) (ContinuationReceipt, error)
	Inspect(ctx context.Context, receipt ContinuationReceipt) (ContinuationState, error)
}

type ContinuationEnvelope struct {
	Schema          string          `json:"schema"`
	WorkspaceID     string          `json:"workspace_id"`
	SessionID       string          `json:"session_id"`
	GoalID          string          `json:"goal_id"`
	ParentTaskID    string          `json:"parent_task_id,omitempty"`
	ParentMessageID string          `json:"parent_message_id"`
	Attempt         uint32          `json:"attempt"`
	Inbound         channel.Inbound `json:"inbound"`
}

type ContinuationLedger interface {
	Append(ctx context.Context, workspaceID, sessionID string, record DecisionRecord) (DecisionRecord, error)
	// AppendFirstDecision atomically admits the first decision for one
	// goal/assistant-turn pair. It returns the existing decision and false when
	// another process already decided that turn. Follow-up audit records for an
	// admitted plan use Append.
	AppendFirstDecision(ctx context.Context, workspaceID, sessionID string, record DecisionRecord) (DecisionRecord, bool, error)
	List(ctx context.Context, workspaceID, sessionID string) ([]DecisionRecord, error)
}

type ContinuationPolicy interface {
	Decide(ctx context.Context, input PolicyInput) PolicyDecision
}

type ContinuationReceipt struct {
	Backend string
	TaskID  string
}

type ContinuationState string

type CreateInput struct {
	Objective   string
	TokenBudget *uint64
}

type DecisionAction string

type DecisionReason string

type DecisionRecord struct {
	SchemaVersion     uint32         `json:"schema_version"`
	Sequence          uint64         `json:"sequence"`
	WorkspaceID       string         `json:"workspace_id"`
	SessionID         string         `json:"session_id"`
	GoalID            string         `json:"goal_id"`
	TurnMessageID     string         `json:"turn_message_id"`
	Action            DecisionAction `json:"action"`
	Reason            DecisionReason `json:"reason"`
	Detail            string         `json:"detail,omitempty"`
	CreatedAt         string         `json:"created_at"`
	TokenUsage        uint64         `json:"token_usage,omitempty"`
	TokenBudget       *uint64        `json:"token_budget,omitempty"`
	ContinuationsUsed uint32         `json:"continuations_used,omitempty"`
	Evidence          []string       `json:"evidence,omitempty"`
	// ContinuationMessageID and ContinuationRequestID are minted before the
	// plan is committed. Backend and task identity appear only after durable
	// admission succeeds. None of these fields carries task authority.
	ContinuationMessageID string `json:"continuation_message_id,omitempty"`
	ContinuationRequestID string `json:"continuation_request_id,omitempty"`
	ContinuationBackend   string `json:"continuation_backend,omitempty"`
	ContinuationTaskID    string `json:"continuation_task_id,omitempty"`
	// Continuation is stored once on the planned record so a durable backend
	// can reconstruct credential-free ingress after a process restart even
	// when its task API does not expose the original assignment payload.
	// Authority is deliberately absent from ContinuationEnvelope.
	Continuation *ContinuationEnvelope `json:"continuation,omitempty"`
}

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

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

type Mutation func(state *spec.SessionGoalsState) error

type PolicyDecision struct {
	Continue bool
	Block    bool
	Reason   DecisionReason
	Detail   string
}

type PolicyInput struct {
	Goal              spec.SessionGoalRecord
	ContinuationsUsed uint32
	Verification      *VerificationResult
	// WrapUpUsed reports that this goal has already been granted its one
	// budget-exhaustion wrap-up round, so the next budget check must block
	// rather than grant another.
	WrapUpUsed bool
}

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

type RuntimeConfig struct {
	Service             *Service
	Ledger              ContinuationLedger
	Policy              ContinuationPolicy
	ContinuationBackend ContinuationBackend
	Enqueuer            channel.Enqueuer
	Verifier            Verifier
	AuthHandoff         *authhandoff.Store
	DefaultWorkspaceID  string
	NewID               func(prefix string) (string, error)
	// VerifierFailureStreak is how many CONSECUTIVE verifier errors must occur
	// before a goal is blocked. 0 uses DefaultVerifierFailureStreak; 1 restores
	// the original block-on-first-error behavior.
	//
	// A verifier error is fail-closed by design, but failing closed on a single
	// error conflates "this goal cannot succeed" with "the verifier had a bad
	// minute" — a network blip or a model hiccup would permanently kill a goal
	// that was making progress. Requiring the condition to persist keeps the
	// fail-closed guarantee for real faults and drops it for transient ones.
	VerifierFailureStreak uint32
}

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

type ServiceConfig struct {
	Store Store
	Now   func() time.Time
	NewID func() (string, error)
}

type Store interface {
	PutGoal(ctx context.Context, workspaceID, sessionID string, record spec.SessionGoalRecord) error
	ListGoals(ctx context.Context, workspaceID, sessionID string) ([]spec.SessionGoalRecord, error)
}

type UpdateInput struct {
	ID            string
	Status        spec.SessionGoalStatus
	Evidence      []string
	BlockedReason string
}

type VerificationRequest struct {
	Goal       spec.SessionGoalRecord
	Transcript []protocol.ChatMessage
}

type VerificationResult struct {
	Satisfied      bool
	Feedback       string
	FailedCriteria []string
	Evidence       []string
}

type Verifier interface {
	VerifyGoal(ctx context.Context, request VerificationRequest) (VerificationResult, error)
}