intent

type CapacityClass struct {
	ID    string
	Units wire.Count
}

type ConfigRef struct{ Revision, Path, Blob string }

type ExecutionCutover struct {
	EnabledBy    string
	DecisionRef  string
	GateEvidence []wire.Digest
}

type ExternalReviewDefinition struct {
	GateID                     string
	RecorderRoles              []string
	ReviewStages, AuthorStages []string
	RequireReviewerLease       bool
	// Sha256 is the definitionSha256: the digest of the canonical bytes of
	// this entry in the policy's externalReviews array.
	Sha256 wire.Digest
}

type File struct {
	Path   string // e.g. "tickets/AT-07.json"
	Sha256 wire.Digest
	Bytes  int
	Raw    []byte
}

type GateDefinition struct {
	GateID         string
	Kind           string
	Argv           []string
	Cwd            string
	Env            []string
	TimeoutSeconds wire.Count
	ExpectedExit   *wire.Count
	Reducer        *string
	Evidence       []string
	Inputs         []string
	SharedResource *struct{ Class, Key string }
	Reusable       bool
	Required       bool
}

type ImportEntry struct {
	SourceQueueID        string
	SourceItemID         string
	TicketID             wire.TicketID
	SourceRevisionSha256 *wire.Digest
	AppliedSeq           wire.Size
}

type ImportMap struct {
	QueueID wire.QueueID
	Entries []ImportEntry
}

type LaneBudget struct {
	InputTokens         wire.Size
	CacheCreationTokens wire.Size
	CacheReadTokens     wire.Size
	OutputTokens        wire.Size
	Turns               wire.Count
	WallClockMinutes    wire.Count
}

type LoopDetection struct {
	MaxNoProgressGenerations wire.Count
	MaxAlternatingReturns    wire.Count
}

type MemberConfig struct {
	ConfigRef       *ConfigRef
	Health, Cleanup *PoolCommand
	SafeReuse       *SafeReuse
}

type Policy struct {
	Supervision                *SupervisionPolicy
	Pools                      []Pool
	PolicyVersion              wire.Size
	Roles                      map[string][]string
	MaxActiveAttempts          wire.Count
	MaxWorkersTotal            wire.Count
	Classes                    []CapacityClass
	Lane                       LaneBudget
	TicketMultiplier           wire.Count
	RequireEnforcedFields      []string
	AdmissionsPerRevision      wire.Count
	RepairRounds               wire.Count
	MalformedReviewRetry       wire.Count
	GateRerunOnStale           wire.Count
	ReconcileAttempts          wire.Count
	EvidenceDays               wire.Count
	Gates                      []GateDefinition
	SerialFallback             string
	IntegrationRequiredKinds   []string
	AllowEmptyObligationsKinds []string
	ReviewLaneRequired         bool
	DocsLaneRequired           bool
	CemRequired                bool
	OcmRequired                bool
	Runtimes                   []RuntimeEntry
	AllowedEnvKeys             []string
	// ExternalReviews are the optional routing-only review gate definitions
	// (ERG-V0-009); absent means no external review gate exists.
	ExternalReviews []ExternalReviewDefinition
	// LoopDetection is the optional CAL-V0-102 no-progress loop policy;
	// nil (the key absent) disables loop detection.
	LoopDetection *LoopDetection
	Raw           []byte
}

type Pool struct {
	ID           string
	Members      []string
	ReservedFor  map[string]string
	MemberConfig map[string]MemberConfig
	// PriorityAdmission opts the pool into CAL-V0-101 priority-yield
	// admission. Omission, like an explicit false, keeps the old admission.
	PriorityAdmission bool
}

type PoolCommand struct {
	Argv, Env      []string
	Cwd            string
	TimeoutSeconds wire.Count
}

type Queue struct {
	QueueID               wire.QueueID
	RepositoryAuthorityID string
	Prefix                string
	NextSerial            wire.Count
	SchemaVersion         string
	CanonicalWriter       string
	ForeignAdapterID      *string
	IntentBranch          string
	Fixture               bool
	ExecutionCutover      *ExecutionCutover
	ImportMapSha256       *wire.Digest
	WriteBarrier          WriteBarrier
}

type Repository struct {
	// CommonDir is the Git common directory (`<primary>/.git`).
	CommonDir string
	// PrimaryWorktree is the worktree whose `.git` is the common directory
	// itself (§3.1). Linked worktrees are never the primary.
	PrimaryWorktree string
	// StateDir is `<git-common-dir>/taskman` (§3.4); it may not exist.
	StateDir string
	// LockPath is `<git-common-dir>/taskman.lock`; reads never open it.
	LockPath string
	// FromLinkedWorktree is true when cwd was inside a linked worktree.
	FromLinkedWorktree bool
	// IntentWorktree is the worktree whose `.taskman/` is the intent
	// projection (CTW-V0-001); read it through IntentRoot.
	IntentWorktree string
	// IntentGitDir is the Git directory holding the intent worktree's HEAD:
	// CommonDir for the primary, `<common>/worktrees/<id>` for a linked one.
	IntentGitDir string
	// IntentFix is the repair text resolution recorded when the primary is not
	// on the intent branch and no linked worktree was admitted (CTW-V0-005,
	// CTW-V0-006); empty otherwise.
	IntentFix string
}

type RuntimeEntry struct {
	RuntimeID               string
	PathSha256              wire.Digest
	FileSha256              wire.Digest
	Mode                    string
	ArgvPrefix              []string
	CapabilityProfileSha256 wire.Digest
	ObservedBudgetFields    []string
	Roles                   []string
	MaxWorkers              wire.Count
	Enabled                 bool
}

type SafeReuse struct {
	Reset, Verify                           PoolCommand
	EnvFile                                 string
	TimeoutSeconds, MaxAttempts, ExpectExit wire.Count
	ExpectStdout                            string
}

type Store struct {
	Root      string // <primary>/.taskman
	Queue     *Queue
	Policy    *Policy
	ImportMap *ImportMap // nil when absent
	Tickets   []*ticket.Record
	Releases  []*release.Record
	Inventory *ticket.Inventory
	Tree      Tree
	// Digests of the individual files, keyed by store-relative path.
	Digests map[string]wire.Digest
}

type SupervisionPolicy struct {
	MaxRepairCycles, Turns, WallClockMinutes wire.Count
	InputTokens, OutputTokens                wire.Size
	// Efforts is the owner's per-stage effort allowlist (CAL-V0-062). A
	// stage without an entry allows only "low".
	Efforts map[string][]string
	// StageWallMinutes bounds one supervised stage's configured wall time
	// (CAL-V0-063); empty means DefaultStageWallMinutes.
	StageWallMinutes wire.Count
	// Repositories are the owner-declared extra repositories a supervised
	// program may span (CAL-V0-071): name -> sha256 of the absolute
	// checkout path. Empty means single-repository programs only.
	Repositories map[string]wire.Digest
	// Host is the owner-selected supervised host the pinned runtime speaks
	// (CAL-V0-074, CAL-V0-076): "claude-code", "opencode", or empty for Codex.
	Host string
	// Continuations is how many times one stage run that reaches its stage
	// wall may continue its preserved session and worktree (CAL-V0-089);
	// empty means none, so a wall interruption waits for an operator.
	Continuations wire.Count
}

type Tree struct {
	Files      []File // sorted by path
	TotalBytes int
	Sha256     wire.Digest
}

type WriteBarrier struct {
	Reason string
	Since  *wire.Timestamp
}