application

type Access string

type AccessResolver interface {
	ResolvePrincipal(context.Context, RequestIdentity) (Principal, error)
	ListProjects(context.Context, Principal) (ProjectList, error)
	ResolveProject(context.Context, Principal, ProjectID, Access) (*ProjectRuntime, error)
	ResolveDependency(context.Context, Principal, ProjectID, string) (*ProjectRuntime, error)
}

type AcquiredTarget struct {
	Target     MutationTarget
	Graph      GraphStore
	Finalizers []MutationFinalizer
	Release    func() error
}

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

type ApplicationError struct {
	Code       ErrorCode
	Message    string
	Project    ProjectRef
	Action     *ProjectAction
	ApplyState ApplyState
	Revision   string
	Version    uint32
	Cause      error
	// Attachment and Ended carry the interpreted conflict on an
	// ErrorSessionDisplaced, ErrorConsentRequired or ErrorSessionEnded: who holds
	// the session now, or the act that ended it, so the caller can be told
	// who/when/why.
	Attachment *Attachment
	Ended      *SessionEnd
}

type AppliedMutation struct {
	Project  ProjectID
	BatchID  string
	Revision string
	Batch    MutationBatch
}

type ApplyResult struct {
	State    ApplyState
	Revision string
}

type ApplyState string

type Attachment struct {
	Subject       string
	ClientName    string
	ClientVersion string
	MCPSessionID  string
	LastActivity  time.Time
	UserWords     string `json:",omitempty"`
}

type AttachmentMaterialization struct {
	BlobID      string
	Digest      BlobDigest
	Size        int64
	SourceName  string
	LogicalPath string
}

type AttachmentPage struct {
	Filename   string
	Content    []byte
	Offset     int64
	NextOffset int64
	TotalSize  int64
	More       bool
	Digest     BlobDigest
}

type Author struct {
	Name  string
	Email string
}

type BlobDigest struct {
	Algorithm string
	Value     string
}

type BranchValidator interface {
	ValidateBranch(context.Context, MutationTarget) error
}

type BranchValidatorFunc func(context.Context, MutationTarget) error

type CanonicalChunk struct {
	ID      string
	EntryID string
	Ordinal int
	// Revision is deprecated: graph revision is a mutation-concurrency token,
	// never a vector-freshness token (d-cpt-65i). Reconciliation and hit
	// validity ignore it. Retained only for source compatibility.
	Revision    string
	ContentHash string
	Text        string
	// The following persisted citation and identity fields carry everything a
	// store needs to render a citation and answer entry-presence queries
	// without re-deriving chunks. Both the CLI indexer and the application
	// vector search populate them through the shared chunk-derivation helper.
	Body                 string
	Breadcrumb           []string
	Depth                int
	IsSummary            bool
	IsAttachment         bool
	SourceAttachmentPath string
	// EntryHash is the entry-state hash (entry content + summary + attachment
	// bytes) — the same definition as the CLI manifest state hash.
	EntryHash string
}

type ChooserKind string

type CollectSessionsCmd struct {
	Retention time.Duration
}

type CollectSessionsResult struct {
	RemovedSessions []SessionID
	RemovedStaged   []SessionRef
	DrainedIntents  int
	Skipped         []SessionID
}

type CreateEntryResult struct {
	Project  ProjectRef
	Binding  SessionBinding
	EntryID  string
	Summary  string
	Findings []Finding
}

type DocumentChange struct {
	LogicalPath    string
	Document       *EntryDocument
	CanonicalBytes []byte
	Delete         bool
}

type DocumentIssue struct {
	LogicalPath string
	Message     string
}

type EmbeddingExecutor interface {
	Spec(context.Context) (EmbeddingSpec, error)
	Embed(context.Context, []EmbeddingInput) ([]EmbeddingVector, error)
}

type EmbeddingExecutorFuncs struct {
	SpecFunc  func(context.Context) (EmbeddingSpec, error)
	EmbedFunc func(context.Context, []EmbeddingInput) ([]EmbeddingVector, error)
}

type EmbeddingInput struct {
	ID      string
	Text    string
	Purpose EmbeddingPurpose
}

type EmbeddingPurpose string

type EmbeddingSpec struct {
	Fingerprint string
}

type EmbeddingVector struct {
	ID     string
	Values []float32
}

type EntryDocument struct {
	LogicalPath string
	Frontmatter map[string]any
	Body        string
	Attachments []string
}

type EntryDraft struct {
	Target            MutationTarget
	Kind              string
	Layer             string
	Intent            string
	Body              string
	Refs              []EntryRef
	Closes            []string
	Supersedes        []string
	Participants      []string
	Confidence        string
	Topics            []string
	Index             *FactIndex
	AttachmentHandles []string
	// Canonical and Aliases carry a kind: actor signal's identity; Actor carries
	// a kind: role decision's bound actor canonical; Class carries a
	// kind: procedure decision's execution role. Mirrors the CLI-side
	// NewEntryCmd fields — a value on the wrong kind is a blocking finding at
	// the construction boundary.
	Canonical string
	Aliases   []string
	Actor     string
	Class     string
	// ProcedureSpec carries a kind: procedure decision's workflow declaration
	// as one structured document — {params?, state?, steps, framing?} —
	// converted strictly at draft-to-entry assembly. Interpretation stays
	// with the engine.
	ProcedureSpec map[string]any
	// FocusActors, FocusWhen, and Involvement carry a kind: focus decision's
	// advances list and its focus-level defaults. Mirrors the CLI-side
	// NewEntryCmd fields — ignored on other kinds, written onto the entry so
	// the model-layer validator sees the required involvement frontmatter.
	FocusActors   []string
	FocusWhen     *types.FocusWhen
	Involvement   []types.Involvement
	SkipPreflight bool
}

type EntryRef struct {
	ID   string
	Kind string
	Desc string
}

type ErrorCode string

type FactIndex struct {
	Title string `json:"title"`
	Topic string `json:"topic"`
}

type FactIndexRow struct {
	ID    string
	Title string
	Topic string
}

type FinalizerOutcome struct {
	Name      string
	Succeeded bool
	Message   string
}

type Finding struct {
	Severity    string
	Category    string
	Observation string
}

type FixedTargetAcquirer struct {
	Target     MutationTarget
	Graph      GraphStore
	Finalizers []MutationFinalizer
}

type GraphStore interface {
	Current(context.Context) (*Snapshot, error)
	Apply(context.Context, string, MutationBatch, StagedBlobReader) (ApplyResult, error)
	Reconcile(context.Context, string, string) (ApplyResult, error)
	ReadAttachmentPage(context.Context, string, string, int64, int) (AttachmentPage, error)
}

type GuideFinding struct {
	Reasoning string
	Axis      string
	Quote     string
	Repair    string
	Severity  string
}

type IndexNamespace struct {
	Project     ProjectID
	Fingerprint string
	Metric      string
}

type IndexedChunk struct {
	Chunk  CanonicalChunk
	Vector []float32
}

type InfoRequest struct{}

type InfoResult struct {
	Project     ProjectRef
	Participant string
	Language    string
	Search      string
	Recovery    string
}

type MutationBatch struct {
	ID          string
	Digest      string
	Changes     []DocumentChange
	Attachments []AttachmentMaterialization
	Message     string
	Author      Author
}

type MutationFinalizer interface {
	Name() string
	Finalize(context.Context, AppliedMutation) error
}

type MutationResult struct {
	Project ProjectRef
	Binding SessionBinding
}

type MutationTarget struct {
	Project ProjectID `json:"project"`
	Branch  string    `json:"branch"`
}

type PreparedTransition struct {
	Version uint32
	Target  MutationTarget
	// ExpectedGraphRevision is prepare-time provenance only. The apply CAS
	// operand is the freshly revalidated revision (see applyOnAcquired), so a
	// concurrent unrelated append merges cleanly instead of failing the pin.
	ExpectedGraphRevision string
	Batch                 MutationBatch
	// Staged keeps its persisted name so an in-flight intent stays replayable
	// across an upgrade.
	Staged  SessionRef `json:"BlobOwner"`
	BlobIDs []string
}

type Principal struct {
	Subject     string
	Participant string
}

type ProcedureListRequest struct{}

type ProcedureListResult struct {
	Project    ProjectRef
	Procedures string
}

type ProjectAction struct {
	ID          string
	DisplayName string
	State       ProjectState
	ActionURL   string
	Reason      string
}

type ProjectConfigDocument struct {
	LogicalPath string
	Fields      map[string]any
}

type ProjectID string

type ProjectList struct {
	Actions  []ProjectAction
	Projects []ProjectSummary
}

type ProjectRef struct {
	ID          ProjectID
	DisplayName string
}

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

type ProjectRuntimeOptions struct {
	Project       ProjectRef
	DefaultBranch string
	Language      string
	Dependencies  []string
	Graph         GraphStore
	Targets       TargetAcquirer
	Branches      BranchValidator
	Recovery      RecoveryAuthorizer
	Sessions      SessionStore
	StagedBlobs   StagedBlobStore
	Embeddings    EmbeddingExecutor
	SearchIndex   SearchIndexStore
	// LLM is the single LLM dependency: a pkg/llm Runner, injected as an
	// instance that arrives already composed — observed and bounded by the
	// host's decorators. Routing, deadlines, and recording are the host's
	// composition duty (20260830-234501-d-cpt-q6n); application contributes
	// only the facts it alone holds, the Purpose and the prompts.
	LLM        llm.Runner
	Finalizers []MutationFinalizer
	Now        func() time.Time
	// ExcludeEmbeddedFromIndex mirrors the CLI's excludeEmbedded semantics for
	// the vector index: connected-repo runtimes set it so binary-shipped base
	// entries embed once per machine (in the base store) rather than once per
	// connected repo. The base runtime leaves it false — its store includes
	// embedded entries. The rule is applied identically at index and read time.
	ExcludeEmbeddedFromIndex bool
}

type ProjectState string

type ProjectSummary struct {
	ProjectRef
	SourceID string
	CanRead  bool
	CanWrite bool
	State    ProjectState
}

type ReadAttachmentRequest struct {
	EntryID  string
	Filename string
	Offset   int64
	MaxBytes int
}

type ReadAttachmentResult struct {
	Project   ProjectRef
	Page      AttachmentPage
	Available []string
}

type RecoveryAccessRequest struct {
	Actor           Principal
	Target          MutationTarget
	Verb            RecoveryVerb
	OriginalSubject string
	OriginalSession SessionID
}

type RecoveryAuthorizer interface {
	AuthorizeRecovery(context.Context, RecoveryAccessRequest) error
}

type RecoveryAuthorizerFunc func(context.Context, RecoveryAccessRequest) error

type RecoveryItem struct {
	Session         SessionID
	MutationID      string
	Digest          string
	Target          MutationTarget
	OriginalSubject string
	State           RecoveryState
	// Reason qualifies State: what delivery waits on while pending, or which
	// decision ended it while abandoned. Empty when delivered.
	Reason RecoveryReason
	// Recovered records that recovery machinery touched this mutation — a
	// reconciliation or a verb. It is provenance, not state: a recovered write is
	// delivered exactly like one that never needed help.
	Recovered        bool
	LegacyUnroutable bool
	EntryIDs         []string
	LastEvidence     string
	// Cause is the terminal's structured cause (e.g. graph-contention for an
	// engine-recorded discard), empty for participant decisions and open items.
	Cause string
}

type RecoveryList struct {
	Project ProjectRef
	Items   []RecoveryItem
}

type RecoveryReason string

type RecoveryReconcileRequest struct {
	Session    SessionID
	MutationID string
}

type RecoveryRequest struct {
	Session    SessionID
	MutationID string
	Verb       RecoveryVerb
	Reason     string
	Target     MutationTarget
}

type RecoveryResult struct {
	Project    ProjectRef
	Item       RecoveryItem
	Transition TransitionResult
}

type RecoveryState string

type RecoveryVerb string

type RegistryFunction struct {
	Name   string
	Class  string
	Doc    string
	Reads  []string
	Writes []string
}

type RequestIdentity struct {
	Subject    string
	Scopes     []string
	Attributes map[string]any
}

type ScoredChunkHit struct {
	Namespace IndexNamespace
	ChunkID   string
	EntryID   string
	// EntryHash is the version this hit belongs to, resolved by the store (row
	// metadata, or the manifest for a legacy row). Read-time filtering keeps
	// the hit only when it equals the current entry's state hash. Empty means
	// the store cannot report a version, so the hit is not version-filtered.
	EntryHash string
	// Revision is deprecated and ignored by hit validity (see CanonicalChunk).
	Revision    string
	ContentHash string
	Score       float64
	// Persisted citation fields, rendered directly into search citations so a
	// hit needs no re-derivation of its source chunk.
	Body                 string
	Breadcrumb           []string
	Depth                int
	IsSummary            bool
	IsAttachment         bool
	SourceAttachmentPath string
}

type SearchIndexEntryManifest interface {
	IndexedEntries(context.Context, IndexNamespace) ([]StoredEntryRef, error)
}

type SearchIndexStore interface {
	Manifest(context.Context, IndexNamespace) ([]StoredChunkRef, error)
	Reconcile(context.Context, IndexNamespace, string, []IndexedChunk, []string) error
	Nearest(context.Context, []IndexNamespace, []float32, int) ([]ScoredChunkHit, error)
}

type SearchIndexStoreFuncs struct {
	ManifestFunc  func(context.Context, IndexNamespace) ([]StoredChunkRef, error)
	ReconcileFunc func(context.Context, IndexNamespace, string, []IndexedChunk, []string) error
	NearestFunc   func(context.Context, []IndexNamespace, []float32, int) ([]ScoredChunkHit, error)
}

type SearchRequest struct {
	Terms             []string
	Phrase            string
	Branch            string
	BranchFromSession bool
	Type              string
	Layer             string
	Kind              string
	IncludeSuperseded bool
	Limit             int
	MaxCitations      int
	Repos             []string
	AllRepos          bool
}

type SearchResult struct {
	Project  ProjectRef
	Results  string
	EntryIDs []string
}

type SessionAppend struct {
	Metadata *SessionMetadata
	Events   []StoredEvent
}

type SessionBinding struct {
	SessionID    SessionID
	Subject      string
	Project      ProjectID
	MCPSessionID string
	Version      uint64
}

type SessionEnd struct {
	Act     SessionEndAct
	EndedAt time.Time
	Reason  string `json:",omitempty"`
}

type SessionEndAct string

type SessionFilter struct {
	Subject string
	Project ProjectID
}

type SessionID string

type SessionMetadata struct {
	ID          SessionID
	Subject     string
	Project     ProjectID
	Participant string
	Label       string
	// Branch is the session's explicit branch binding. Empty means unbound;
	// compositions without a branch concept leave it empty.
	Branch     string `json:"branch,omitempty"`
	Attachment *Attachment
	// Ended is the session's single terminal record. Its presence is what makes
	// a session ended; nothing else about a session ends it (d-cpt-rw7).
	Ended     *SessionEnd `json:",omitempty"`
	UpdatedAt time.Time
}

type SessionRef struct {
	Subject string
	Session SessionID
}

type SessionStore interface {
	Create(context.Context, SessionMetadata) (StoredSession, error)
	Load(context.Context, SessionID) (StoredSession, error)
	List(context.Context, SessionFilter) ([]StoredSession, error)
	Append(context.Context, SessionID, uint64, SessionAppend) (uint64, error)
	Delete(context.Context, SessionID) error
}

type ShowRequest struct {
	IDs               []string
	UpDepth           int
	DownDepth         int
	Branch            string
	BranchFromSession bool
	// Budget bounds each direction's chain expansion on the serve path; the
	// zero value is unbounded — explicit pulls arrive complete (d-tac-rzi).
	Budget types.ShowTreeBudget
}

type ShowResult struct {
	Project    ProjectRef
	Entries    string
	FullIDs    []string
	SummaryIDs []string
}

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

type SnapshotData struct {
	Project  ProjectID
	Revision string
	Config   ProjectConfigDocument
	Entries  []EntryDocument
	WIP      []WIPDocument
	// Unreadable records documents a store could not decode into structured
	// form — a file whose YAML frontmatter would not parse, for example. They
	// are carried as data rather than aborting the load: BuildSnapshot turns
	// each into a graph load issue surfaced through Snapshot.Health, so one
	// malformed file no longer makes an entire graph (and every session over
	// it) unopenable.
	Unreadable []DocumentIssue
}

type StagedBlob struct {
	ID        string
	Session   SessionRef
	Digest    BlobDigest
	Size      int64
	Filename  string
	CreatedAt time.Time
}

type StagedBlobReader interface {
	Open(context.Context, string) (io.ReadCloser, error)
}

type StagedBlobStore interface {
	Stage(context.Context, SessionRef, string, io.Reader) (StagedBlob, error)
	Stat(context.Context, SessionRef, string) (StagedBlob, error)
	Open(context.Context, SessionRef, string) (io.ReadCloser, error)
	Retain(context.Context, SessionRef, string, []string) error
	Release(context.Context, SessionRef, string) error
	StagedSessions(context.Context) ([]SessionRef, error)
	DeleteStaged(context.Context, SessionRef) error
}

type StoredChunkRef struct {
	ID string
	// Revision is deprecated and ignored by reconciliation (see CanonicalChunk).
	Revision    string
	ContentHash string
}

type StoredEntryRef struct {
	EntryID string
	// EntryHash is the entry-state hash of this stored version — the same
	// definition as CanonicalChunk.EntryHash and the CLI manifest hash. Empty
	// only for a store that cannot report per-version identity.
	EntryHash string
}

type StoredEvent struct {
	CodecVersion uint32
	Code         string
	Payload      json.RawMessage
}

type StoredSession struct {
	Metadata SessionMetadata
	Version  uint64
	Events   []StoredEvent
}

type TargetAcquirer interface {
	Acquire(context.Context, MutationTarget) (*AcquiredTarget, error)
}

type TargetAcquirerFunc func(context.Context, MutationTarget) (*AcquiredTarget, error)

type TransitionResult struct {
	Project    ProjectRef
	Binding    SessionBinding
	Apply      ApplyResult
	Finalizers []FinalizerOutcome
}

type ValidationError struct {
	Warnings []types.Warning
}

type ViewRequest struct {
	Layout            string
	Branch            string
	BranchFromSession bool
	Repos             []string
	AllRepos          bool
	// Budget bounds the view's scaling parts on the serve path; the zero
	// value is unbounded — explicit pulls arrive complete (d-tac-rzi).
	Budget types.ViewBudget
	// OmitRecovery skips the appended recovery notices — for injected lanes
	// whose session already carries them via sessionInfo, so a pending
	// recovery is served once, not once per lane.
	OmitRecovery bool
}

type ViewResult struct {
	Project  ProjectRef
	Sections string
	// MatchedCount is the total primary units the layout produced across the
	// local graph and any queried dependency repos. Zero means the pipeline
	// matched nothing — surfaces distinguish an empty result from a failure
	// (an agent over MCP cannot tell a blank string from a broken call).
	MatchedCount int
	// KnownParticipants names the graph's canonical participants, populated
	// only when the result was empty and the layout carried a participant
	// filter — so an empty participant() view can say what names exist rather
	// than leaving an exact-match miss indistinguishable from no data.
	KnownParticipants []string
}

type WIPDocument struct {
	LogicalPath string
	Content     string
}

type WorkflowAbandonResult struct {
	Abandoned   bool
	Session     SessionID
	Label       string
	Discarded   []WorkflowInstanceSummary
	HeldMarkers []string
	Base        *WorkflowServe
}

type WorkflowAdvanceRequest struct {
	Instance string
	Report   map[string]any
	Label    string
}

type WorkflowChooser struct {
	Chooser string
	Kind    ChooserKind
	Options []WorkflowChooserOption
}

type WorkflowChooserOption struct {
	Choice  string
	Collect []string
}

type WorkflowInstanceSummary struct {
	Instance  string
	Procedure string
	Step      string
}

type WorkflowOpenRequest struct {
	MCPSessionID  string
	ClientName    string
	ClientVersion string
	Shell         string
	Label         string
}

type WorkflowParkResult struct {
	Instance  string
	Procedure string
	Step      string
	Base      *WorkflowServe
}

type WorkflowResumeRequest struct {
	SessionID     SessionID
	MCPSessionID  string
	ClientName    string
	ClientVersion string
	// UserWords is the user's verbatim request to move into the session, required
	// to attach to a session this connection does not already hold. Takeover
	// additionally authorizes displacing an attachment that is still recent.
	UserWords string
	Takeover  bool
}

type WorkflowResumeResult struct {
	Session      SessionID
	Participant  string
	Label        string
	Branch       string
	Open         []WorkflowServe
	Instructions string
	// Displaced names the attachment this attach ended (nil when the session was
	// unheld); TookOver is true when that displaced attachment was still recent,
	// so the caller can surface the fidelity limit of a takeover.
	Displaced *Attachment
	TookOver  bool
}

type WorkflowServe struct {
	Session        SessionID
	Branch         string
	Instance       string
	Procedure      string
	Status         string
	Step           string
	Goal           string
	Instructions   string
	Missing        []string
	ReportSchema   map[string]any
	PendingChooser *WorkflowChooser
	Execution      string
	Produced       map[string]any
	Diagnostics    []string
	// InstructionLanes are the unit's rendered lanes in order — what the MCP
	// layer dedups independently; Instructions is their join plus diagnostics.
	InstructionLanes []types.ServeLane
	// Sizes is the engine's per-part byte accounting for this serve, read by
	// the serve-budget measurement (d-tac-qwc).
	Sizes []types.PartSize
	Base  *WorkflowServe
	// Collected is the instance's already-gathered param and state values,
	// projected only onto resume serves so a newly attached or reoriented
	// agent sees what this instance holds — the anchor, chosen scope, and
	// reported judgments that persist across a handover (d-cpt-0tm). Empty on
	// door, next, and base-junction serves, which stay unchanged.
	Collected map[string]any
}

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

type WorkflowSessionSummary struct {
	Session      SessionID
	Label        string
	Participant  string
	Branch       string
	Anchor       string
	Open         []WorkflowInstanceSummary
	LastActivity time.Time
	Attachment   *Attachment
	Active       bool
}

type WorkflowStartRequest struct {
	Canonical string
	Params    map[string]any
	Label     string
	Parent    string
}