ctxbudget

const (
	// DefaultFillPercent is the law's number: fill to 60% of the window,
	// then compact. CODEAF_CONTEXT_FILL_PCT overrides it (clamped 10–90).
	DefaultFillPercent = 60

	// DefaultCompletionReserveTokens is the room every call keeps for its
	// visible answer plus reasoning. It is deliberately high: a reasoning
	// pass routinely spends more thinking than writing, and a ceiling only
	// costs on the turns that use it. CODEAF_COMPLETION_RESERVE overrides.
	DefaultCompletionReserveTokens = 65536

	// DefaultWorkingSetTokens is the ceiling on the LIVE WORKING SET — how much
	// material one agent may keep quoted in front of it at once — applied before
	// the fill law, and it is the correction to a category error in the law's own
	// first sentence.
	//
	// Fill-to-60% was written as a statement about a window. A window is what the
	// provider will accept in one request; it is not a statement that carrying
	// that much material is useful, and the two parted company the moment
	// million-token windows arrived. Measured on a 1M-context model, the fill law
	// alone granted a leaf a 2.2MB observation window against 181KB of tool output
	// across twelve whole nodes: the decayer fired ZERO times all run, nothing
	// ever left the transcript, and the leaf's bill — Σ over turns of (base + all
	// prior growth) — carried a duplication factor of 7.45x, with 90% of every
	// input token a re-send of something the model had already been shown.
	//
	// So the pot the law fills is min(window, this) rather than the window. The
	// number is not this program's invention: another agent engine, measured
	// independently, caps its live working set at 160,000 tokens and applies that
	// cap BEFORE the same 0.6 trigger. Two engines reaching the same shape from
	// different evidence is the strongest argument available for it, and
	// CODEAF_WORKING_SET is here for the operator who has evidence of their own.
	//
	// A model whose whole window is smaller than this is unaffected: the minimum
	// keeps the law exactly what it was for it.
	DefaultWorkingSetTokens = 160_000

	// DefaultReusePercent is how many times over one agent loop may re-send its
	// whole working set before it has to land, as a percentage.
	//
	// It is the one bound that reads the quantity a leaf is actually billed for.
	// Cost meters discount the cache-served prefix, which is honest about money
	// and blind to runaway: a measured node carrying 265k raw tokens metered at
	// 54% of its grant, its raw count sat at 58% of the raw ceiling, and neither
	// bound ever bound — the node stopped itself at turn 17, after a verification
	// spiral nothing in the harness could see coming.
	//
	// 250% is where the measurement puts it. On a 1M-context model the working set
	// above fills to 96k tokens, so this lands a leaf at ~240k cumulative prompt
	// tokens — the 0.25x-of-window threshold the trace ledgers show would have
	// landed every runaway node just after its real work and before its spiral,
	// while sitting well clear of an honest leaf (8-16 turns at a measured ~11k
	// per turn is 88k-176k). Writing it against the working set rather than
	// against the window is what keeps it sane on a small model, where a quarter
	// of the window would land an ordinary leaf at turn three.
	//
	// Below 100 it would stop a leaf before it had sent its own context once,
	// which is not a governor but a refusal; the clamp says so.
	DefaultReusePercent = 250
)

const (
	// ObservationFloorBytes is the minimum the unknown-context default may fall
	// to, and nothing else. It is deliberately not a floor under the computed
	// window: when a model's context really is small, the honest answer is a
	// small window, and clamping it upwards would size a prompt past what the
	// model accepts in order to look generous.
	ObservationFloorBytes = 24 << 10

	// MinObservationBytes is arithmetic protection rather than policy. Below it
	// the fixed floor and the completion reserve have already eaten the model's
	// whole context and a worker cannot run there at all; the window stops at a
	// value the decay pass can still reason about instead of going to zero or
	// negative.
	MinObservationBytes = 4 << 10

	// DefaultObservationBytes is the window a worker carries when nothing can
	// say how much context its model actually has.
	//
	// The number is conservative on purpose, and that is the correction to the
	// obvious first instinct. Not knowing a model's context length is not
	// evidence that it is large: an offline catalog, an unrecognised slug and a
	// row cached before the field was kept all look identical here, and a
	// small-context model is exactly the kind that goes unrecognised. A generous
	// default would be a silent regression for it — prompts sized past what it
	// accepts, failing as provider rejections rather than as degradation.
	DefaultObservationBytes = 32 << 10

	// ObservationFixedFloorTokens is the measured per-turn cost of everything
	// that is not observations — the standing contract, the tool schemas, the
	// brief. Measured at ~3,778 tokens across 332 leaf turns; rounded up,
	// because the window must not be sized from an optimistic floor.
	ObservationFixedFloorTokens = 4_000
)

const BytesPerToken = 4

const ToolResultWindowShare = 10