noa

type ApplyInput struct {
	Ranges []CompressRange
	// Messages is the view the model was looking at — the same array its refs
	// were resolved against. Re-deriving it here would risk a different array
	// and therefore a misaligned range.
	Messages []CoreMessage
	State    CompressionState
	Config   Config
	// CallID is the tool_use id of this Compress call.
	CallID string
	// Archiver persists the originals. Required: a block may not exist without
	// its archive.
	Archiver Archiver
	// CreatedAt is an RFC3339 timestamp; this package does not read the clock.
	CreatedAt string
	// Now is the block's creation time as a Unix timestamp, supplied for the
	// same reason.
	Now int64
	// CountTokens overrides the built-in estimator.
	CountTokens TokenCountFn
}

type ApplyResult struct {
	State            CompressionState
	BlocksCreated    []CompressionBlock
	TokensCompressed int
	Errors           []string
	Warnings         []string
	// SurvivingBlockIDs are higher-tier blocks that stayed active inside a
	// requested range. Reported so the model understands why they remain.
	SurvivingBlockIDs []string
}

type ArchiveEntry struct {
	// Block is set for an absorbed lower-tier block.
	Block *CompressionBlock
	// Message is set for an uncompressed message inside the range.
	Message *CoreMessage
	// Ref is the message's ref, when it has one.
	Ref string
}

type ArchiveRenderInput struct {
	BlockID   string
	Tier      Tier
	SessionID string
	// CreatedAt is an RFC3339 timestamp supplied by the caller — this package
	// does not read the clock.
	CreatedAt string
	StartRef  string
	EndRef    string
	Topic     string
	Summary   string
	// Entries are in VIEW ORDER: absorbed block summaries and loose messages
	// interleaved exactly as the model saw them, so a reader sees the shape of
	// the conversation rather than a regrouped digest.
	Entries []ArchiveEntry
	// OriginalTokens is the cost of what this archive replaces.
	OriginalTokens int
}

type Archiver interface {
	// Write stores content for a block and returns its absolute path and the
	// path relative to the archive root. It must be atomic: a partially written
	// archive is worse than none, because the block that points at it will claim
	// the originals are recoverable.
	Write(tier Tier, blockID, startRef, endRef string, content []byte) (abs, rel string, err error)
	// Remove deletes an archive, used to roll back a failed batch.
	Remove(abs string) error
}

type AssignRefsOptions struct {
	// Existing is the map to extend. It is copied, not mutated.
	Existing MessageRefMap
	// NextIndex is where allocation resumes; below MinRefIndex it is clamped.
	NextIndex int
	// IsProtected marks a message as hard-protected: it is recorded as BLOCKED
	// and never becomes addressable.
	IsProtected func(CoreMessage) bool
	// ShouldSkip leaves a message out of the map entirely.
	ShouldSkip func(CoreMessage) bool
}

type AssignRefsResult struct {
	Map           MessageRefMap
	NextIndex     int
	NewlyAssigned int
}

type BlockSpan struct {
	BlockID  string
	Tier     Tier
	StartRef string
	EndRef   string
}

type BoundaryKind string

type BoundaryNotFoundError struct {
	Ref  string
	Kind BoundaryNotFoundKind
	Msg  string
}

type BoundaryNotFoundKind string

type CompressConfig struct {
	// MinCompressRange is the per-batch character floor, applied atomically:
	// a batch below it is rejected whole. Block-boundary ranges are exempt —
	// tier 2/3 compress summaries, which are short by construction.
	MinCompressRange int
	MinSummaryLength int
	MaxSummaryLength int
}

type CompressParseDiagnostics struct {
	Ok             bool
	Kind           CompressParseKind
	InvalidItems   int
	InvalidReasons []string
	// RawPrefix is the first 800 characters of the raw input, for logs.
	RawPrefix string
	Length    int
	Keys      []string
	// Salvaged marks output recovered by bracket-matching rather than parsed.
	Salvaged bool
	// TailRepaired marks output fixed by appending a missing closing brace.
	TailRepaired bool
}

type CompressParseKind string

type CompressParseResult struct {
	Ranges          []CompressRange
	TopLevelTopic   string
	SummaryMaxChars *int
	Diagnostics     CompressParseDiagnostics
}

type CompressRange struct {
	StartRef string
	EndRef   string
	Summary  string
	Topic    string
	// SummaryMaxChars raises the per-summary ceiling for this entry.
	SummaryMaxChars *int
}

type CompressionBlock struct {
	BlockID string
	Tier    Tier
	Topic   string
	Summary string

	// DirectMessageIDs are the messages this block newly covers (excluding those
	// already covered by an absorbed child block).
	DirectMessageIDs []string
	// EffectiveMessageIDs are every message this block covers, inherited children
	// included. This is what prune hides and what the block span reports.
	EffectiveMessageIDs []string
	// DirectBlockIDs are the lower-tier blocks this block absorbed.
	DirectBlockIDs []string

	// ArchivePath is the absolute path of the markdown file holding the original
	// content. ArchiveRel is the same path relative to the archive root, so a
	// moved session directory can be relocated.
	ArchivePath string
	ArchiveRel  string

	// CompressedTokens is how much the absorbed content cost, for reporting.
	CompressedTokens int
	// StartRef/EndRef span the block's ACTUAL coverage (derived from
	// EffectiveMessageIDs), not the refs the model requested — otherwise the
	// model's ledger drifts from reality.
	StartRef  string
	EndRef    string
	CreatedAt int64

	Active bool
	// CompressCallID is the tool_use id of the Compress call that created this
	// block, used by hide-compress-calls to decide which calls to keep.
	CompressCallID string
}

type CompressionState struct {
	Blocks      []CompressionBlock
	MessageRefs MessageRefMap
	// TokenSnapshot freezes each ref's token count at first render. The number in
	// a ref tag must never drift: a changed tag is a changed byte is an
	// invalidated prefix cache.
	TokenSnapshot map[string]int
	Nudge         NudgeState
	Stats         Stats
	NextBlockID   int
	// ArchiveRoot is <ArchiveBaseDir>/<SessionID>, computed by the host adapter.
	ArchiveRoot string
	SessionID   string
}

type Config struct {
	ModelContextLimit int

	Tiers    TierConfig
	Nudge    NudgeConfig
	Truncate TruncateConfig
	Compress CompressConfig

	// ProtectedTools are hard-excluded from every compression range.
	ProtectedTools []string
	// IsToolProtected, when set, extends ProtectedTools with a host predicate.
	IsToolProtected func(toolName string) bool

	// PreserveRecentMessages and PreserveRecentTokens define the soft protected
	// zone at the tail of the conversation.
	PreserveRecentMessages int
	PreserveRecentTokens   int

	// MaxCompressAttempts is the consecutive failure/ignore limit before nudging
	// is suppressed. Suppression lifts once the context grows by growthFloor.
	MaxCompressAttempts int
}

type ContentType string

type CoreMessage struct {
	ID          string
	Role        Role
	ContentType ContentType
	Text        string
	ToolName    string
	ToolCallID  string
}

type DecideNudgeInput struct {
	Messages   []CoreMessage
	State      CompressionState
	Config     Config
	TokenCount int
	// Recommendation is the compressible/protected split for this turn.
	Recommendation Recommendation
	CountTokens    TokenCountFn
	// TruncatedCount is how many tool results were mechanically shortened, so
	// an emergency nudge can tell the model not to re-run them.
	TruncatedCount int
}

type MessageRefMap struct {
	ByRaw map[string]string // host id -> "m00001", or BlockedRef
	ByRef map[string]string // "m00001" -> host id
}

type NodeIO struct {
	Messages []CoreMessage
	State    CompressionState
	// Nudge is set by the nudge-inject node, nil when nothing is injected.
	Nudge *NudgeDecision
	// TruncatedCount is set by emergency-truncate: how many tool results were
	// mechanically shortened this turn. The nudge renderer uses it to tell the
	// model not to re-run those tools.
	TruncatedCount int
}

type NudgeBreakdown struct {
	Usage           float64
	Growth          int
	GrowthReference int
	GrowthFloor     int
	AdaptiveGrowth  int

	OverLimit bool
	Emergency bool

	MinPressureBenefit int

	PendingT1 int
	PendingT2 int
	PendingT3 int

	CountT1 int
	CountT2 int
}

type NudgeConfig struct {
	// MaxContextLimitPct is the bottom of the pressure band.
	MaxContextLimitPct float64
	// MinContextLimitPct is both the first-sight floor and the usage floor for
	// count-based tier triggers.
	MinContextLimitPct float64
	// EmergencyThresholdPct is where the voice turns urgent.
	EmergencyThresholdPct float64

	// GrowthRatio/Floor/Cap derive the adaptive growth unit from the window.
	GrowthRatio float64
	GrowthFloor int
	GrowthCap   int

	// MinGrowthFloor and MinGrowthRatio derive the cadence gate: how much the
	// context must grow before another nudge is warranted.
	MinGrowthFloor int
	MinGrowthRatio float64

	// Tier2GrowthMultiplier scales the adaptive growth into the pending-token
	// threshold for tier 2 and 3.
	Tier2GrowthMultiplier float64

	// MinPressureBenefitTokens is the minimum reclaimable amount worth spending a
	// turn on while under pressure. nil means max(5000, round(limit*0.01)).
	MinPressureBenefitTokens *int
}

type NudgeDecision struct {
	ShouldInject bool
	// Reason carries the decision diagnostics whether or not it injected —
	// a suppressed nudge is often the thing being debugged.
	Reason string
	// Tier is the tier being asked for; 0 when nothing is injected.
	Tier         Tier
	ContextUsage float64

	CompressibleRanges []RangeInfo
	ProtectedRanges    []ProtectedRange
	ActiveBlockSpans   []BlockSpan
	// TierTargetBlocks are the blocks a tier-2/3 nudge asks to consolidate.
	//
	// Deviation from docs §6.5, which types this []string: the renderer
	// (§6.7 formatTierTargetBlocks) prints each block's message count, token
	// delta and topic, none of which an id alone carries. §6.7 is the binding
	// requirement.
	TierTargetBlocks []CompressionBlock

	Breakdown NudgeBreakdown
	// ContextBreakdown buckets the context by kind: summaries, tool, system,
	// code, text.
	ContextBreakdown map[string]int
	// TruncatedCount is how many tool results emergency-truncate shortened this
	// turn, so the nudge can tell the model not to re-run them.
	TruncatedCount int
}

type NudgeSections struct {
	EfficiencyNote  SectionOverride
	EmergencyHeader SectionOverride
	T2Guidance      SectionOverride
	T3Guidance      SectionOverride
}

type NudgeState struct {
	// LastPerMessageNudgeTokens is the growth baseline.
	LastPerMessageNudgeTokens int
	// LastNudgeShownTokens is the token count at the last injection.
	LastNudgeShownTokens int
	// LastShownByTier paces each tier independently.
	LastShownByTier map[Tier]int
}

type NudgeVoice string

type PanelInput struct {
	Result ApplyResult
	// BeforeTokens and AfterTokens bracket the compression for the headline.
	BeforeTokens int
	AfterTokens  int
	// Messages is the post-compression view, used to mark partial coverage.
	Messages []CoreMessage
}

type PipelineContext struct {
	Config Config
	// TokenCount is the measured size of the context this turn.
	TokenCount int
	// CountTokens is the token estimator; nil means DefaultCountTokens.
	CountTokens TokenCountFn
}

type PipelineNode interface {
	Name() string
	// Enabled reports whether the node should run at all this turn. A disabled
	// node is skipped entirely, not run as a no-op.
	Enabled(io NodeIO, ctx PipelineContext) bool
	Run(io NodeIO, ctx PipelineContext) NodeIO
}

type ProcessTurnInput struct {
	// Messages is the freshly projected view of the full history.
	Messages []CoreMessage
	State    CompressionState
	Config   Config
	// TokenCount is the measured size of the context this turn, used for every
	// pressure and growth decision.
	TokenCount int
	// CountTokens overrides the built-in estimator.
	CountTokens TokenCountFn
}

type ProcessTurnResult struct {
	Messages []CoreMessage
	State    CompressionState
	// Nudge is nil when nothing was injected this turn.
	Nudge *NudgeDecision
	// TruncatedCount is how many tool results emergency-truncate shortened.
	TruncatedCount int
}

type ProtectedRange struct {
	StartRef string
	EndRef   string
	Count    int
	Tokens   int
	// Tools names the hard-protected tools responsible for the exclusion.
	Tools []string
}

type RangeInfo struct {
	StartRef string
	EndRef   string
	// Count is how many messages the span covers.
	Count int
	// Tokens and Chars size the span; Chars drives the per-batch minimum.
	Tokens int
	Chars  int
	// ToolPct and TextPct are rounded percentages of the span's composition —
	// a tool-heavy span is usually the cheapest thing to compress.
	ToolPct int
	TextPct int
	// UserMsgs counts user messages inside the span, surfaced so the model
	// treats intent-bearing spans with more care.
	UserMsgs int
	// Dangerous marks a span the model should not compress without certainty.
	Dangerous bool
}

type RebuildInput struct {
	// Messages is the full projected history, oldest first.
	Messages []CoreMessage
	// Config and Archiver mirror the live ones.
	Config   Config
	Archiver Archiver
	// SessionID and ArchiveRoot seed the rebuilt state.
	SessionID   string
	ArchiveRoot string
	CountTokens TokenCountFn
	// CreatedAt and Now stamp rebuilt blocks; this package does not read the
	// clock.
	CreatedAt string
	Now       int64
}

type RebuildResult struct {
	State CompressionState
	// Replayed is how many compressions were reapplied.
	Replayed int
	// Skipped is how many recorded calls were passed over (they failed then, and
	// replaying them would fail identically).
	Skipped  int
	Warnings []string
}

type Recommendation struct {
	CompressibleRanges []RangeInfo
	ProtectedRanges    []ProtectedRange
	NothingToCompress  bool
}

type ResolvedRange struct {
	StartIndex int
	EndIndex   int
	Kind       BoundaryKind
	// MessageIDs are the ids inside [StartIndex, EndIndex], with rendered
	// summaries excluded (they are projections, not content).
	MessageIDs []string
	// NestedBlockIDs are the active blocks whose anchor falls inside the span.
	NestedBlockIDs []string
	// Warnings records endpoints that were snapped to a containing block.
	Warnings []string
}

type Role string

type SectionOverride = *string

type Sections struct {
	NoaTags            SectionOverride
	SummariesInContext SectionOverride
	Archive            SectionOverride
}

type Stats struct {
	TokensCompressed int
	CompressionCount int
}

type Tier int

type TierConfig struct {
	Enabled bool
	// MaxTier is the terminal level, 2 or 3 (default 3). It is not an extension
	// point — the tier rule prompts are hand-written per tier and stop at 3.
	// It exists as a TEST lever: reaching the terminal-tier guard at MaxTier=3
	// needs ~100 compressions of synthetic conversation, at MaxTier=2 about ten.
	MaxTier Tier
	// Tier2Trigger is how many active tier-1 blocks trigger a tier-2 nudge.
	Tier2Trigger int
	// Tier3Trigger is how many active tier-2 blocks trigger a tier-3 nudge.
	Tier3Trigger int
}

type TierDecision struct {
	// TargetTier is the layer being compressed: the LOWEST tier present in the
	// range. It decides which blocks are absorbed.
	TargetTier Tier
	// OutputTier is the new block's tier, one above the target and capped at
	// MaxTier.
	OutputTier Tier
	// ConsumedBlockIDs are the blocks this compression absorbs — only those at
	// TargetTier.
	ConsumedBlockIDs []string
	// SurvivingBlockIDs are blocks inside the range that are NOT absorbed
	// because they sit above TargetTier. They stay active, and the panel reports
	// them so the model understands why they are still there.
	SurvivingBlockIDs []string
}

type TokenCountFn func(string) int

type TruncateConfig struct {
	Threshold float64
}

type TruncateResult struct {
	Messages       []CoreMessage
	TruncatedCount int
	SavedTokens    int
}

type TurnGroup struct {
	// ReasoningIdx are the indices of the leading reasoning run.
	ReasoningIdx []int
	// ActIdx are the assistant text / tool-call indices.
	ActIdx []int
	// ResultIdx are the tool results belonging to those acts.
	ResultIdx []int
}