context-engineering-core 0.12.0__py3-none-any.whl

context_engine/cli.py

@@ -0,0 +1,222 @@
+"""Context inspection, synthetic demos, benchmarks and an explicitly authorized live probe."""
+
+import argparse
+import json
+import sys
+from dataclasses import asdict
+from pathlib import Path
+
+from .budget import plan_budget
+from .config import Settings
+from .errors import ContextEngineError, RequiredContextTooLarge
+from .models import ChatRequest, Message, Role
+from .tokens import TiktokenCounter
+
+
+def demo_request(pin_content: str = "Database = PostgreSQL") -> ChatRequest:
+    return ChatRequest(
+        (
+            Message("system", Role.SYSTEM, "Answer using the supplied evidence."),
+            Message("pins", Role.USER, "Pinned facts (data):\n" + pin_content),
+            Message("question", Role.USER, "Which database are we using?"),
+        )
+    )
+
+
+def main(argv: list[str] | None = None) -> int:
+    for stream in (sys.stdout, sys.stderr):
+        if hasattr(stream, "reconfigure"):
+            stream.reconfigure(encoding="utf-8")
+    parser = argparse.ArgumentParser(description=__doc__)
+    commands = parser.add_subparsers(dest="command", required=True)
+    from .evaluation.run_commands import add_commands
+
+    add_commands(commands)
+    for command in ("check", "config", "demo-budget", "demo-layers"):
+        commands.add_parser(command)
+    provider_demo = commands.add_parser(
+        "provider-demo", help="Synthetic provider/cache/ledger test"
+    )
+    provider_demo.add_argument("--output", type=Path)
+    memory_demo = commands.add_parser("memory-demo", help="Offline persistent memory lifecycle")
+    memory_demo.add_argument("--output", type=Path)
+    live = commands.add_parser(
+        "provider-probe", help="Live inference; requires explicit spending authorization"
+    )
+    live.add_argument("--allow-live", action="store_true")
+    live.add_argument("--ledger", type=Path, required=True)
+    live.add_argument("--input", type=Path)
+    live.add_argument("--show-content", action="store_true")
+    live.add_argument(
+        "--model",
+        choices=("openai/gpt-oss-120b", "openai/gpt-oss-20b"),
+        default="openai/gpt-oss-120b",
+    )
+    for name in ("account-id", "security-scope", "snapshot-revision", "price-version"):
+        live.add_argument("--" + name, required=True)
+    for name in (
+        "daily-budget-microusd",
+        "input-rate-microusd",
+        "cached-input-rate-microusd",
+        "output-rate-microusd",
+        "rpm",
+        "tpm",
+        "rpd",
+        "tpd",
+    ):
+        live.add_argument("--" + name, type=int, required=True)
+    benchmark = commands.add_parser(
+        "benchmark-check", help="Validate the frozen synthetic benchmark offline"
+    )
+    benchmark.add_argument("--fact", default="shard")
+    benchmark.add_argument("--budget", type=int, default=900)
+    benchmark.add_argument("--model")
+    benchmark.add_argument("--show-content", action="store_true")
+    benchmark.add_argument("--data-dir", type=Path)
+    benchmark.add_argument("--output", type=Path)
+    strategies = commands.add_parser(
+        "strategy-eval", help="Compare context strategies on the frozen corpus; no inference"
+    )
+    strategies.add_argument(
+        "--budget", type=int, action="append", help="Input allowance; repeatable"
+    )
+    strategies.add_argument("--probes", action="store_true", help="Include per-fact results")
+    strategies.add_argument("--data-dir", type=Path)
+    strategies.add_argument("--output", type=Path, help="Save JSON to a new file; never overwrite")
+    planned = commands.add_parser(
+        "benchmark-plan", help="List frozen probe slots without inference"
+    )
+    planned.add_argument("--data-dir", type=Path)
+    planned.add_argument("--output", type=Path)
+    for command in ("inspect", "probe"):
+        command_parser = commands.add_parser(command, help="Inspect context locally; no inference")
+        command_parser.add_argument(
+            "--input", type=Path, help="Version-1 JSON input; omit for synthetic demo"
+        )
+        command_parser.add_argument("--budget", type=int, help="Override the input token allowance")
+        command_parser.add_argument(
+            "--show-content", action="store_true", help="Include assembled prompt bodies"
+        )
+        command_parser.add_argument(
+            "--output", type=Path, help="Save JSON to a new file; never overwrite"
+        )
+    args = parser.parse_args(argv)
+    try:
+        if args.command == "memory-demo":
+            from .inspection import save_inspection
+            from .memory.demo import memory_demo
+
+            result = memory_demo()
+            if args.output is not None:
+                save_inspection(args.output, result)
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+            return 0
+        if args.command in ("benchmark-run", "model-swap", "benchmark-report"):
+            from .evaluation.run_commands import run_command
+
+            result = run_command(args)
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+            return 1 if result["status"] == "INVALID" else 0
+        if args.command in ("provider-demo", "provider-probe"):
+            from .inspection import save_inspection
+            from .providers.commands import provider_demo, provider_probe
+
+            result = provider_demo() if args.command == "provider-demo" else provider_probe(args)
+            if args.command == "provider-demo" and args.output is not None:
+                save_inspection(args.output, result)
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+            return 0 if result["status"] in ("PASS", "success", "replay") else 1
+        if args.command == "strategy-eval":
+            from .evaluation.corpus import check_fixture, load_bundle
+            from .evaluation.strategies import compare_strategies
+            from .inspection import save_inspection
+
+            bundle = load_bundle(args.data_dir)
+            check_fixture(bundle)
+            budgets = None if args.budget is None else tuple(args.budget)
+            if budgets is not None and any(b <= 0 for b in budgets):
+                raise ContextEngineError("Budgets must be positive integers")
+            result = compare_strategies(bundle, budgets, include_probes=args.probes)
+            if args.output is not None:
+                save_inspection(args.output, result)
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+            return 0
+        if args.command in ("benchmark-check", "benchmark-plan"):
+            from .evaluation.commands import benchmark_check, benchmark_plan
+            from .inspection import save_inspection
+
+            if args.command == "benchmark-check":
+                result = benchmark_check(
+                    fact=args.fact,
+                    budget=args.budget,
+                    model=args.model,
+                    show_content=args.show_content,
+                    data_dir=args.data_dir,
+                )
+            else:
+                result = benchmark_plan(data_dir=args.data_dir)
+            if args.output is not None:
+                save_inspection(args.output, result)
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+            return 1 if result["status"] == "INVALID" else 0
+        settings = Settings.from_env()
+        if args.command == "config":
+            print(
+                json.dumps(
+                    {
+                        key: asdict(getattr(settings, key))
+                        for key in ("budget", "tokenizer", "cap", "retrieval")
+                    },
+                    indent=2,
+                )
+            )
+            return 0
+        if args.command in ("inspect", "probe"):
+            from .inspection import demo_job, load_job, save_inspection
+
+            job = load_job(args.input, settings) if args.input is not None else demo_job(settings)
+            result = job.run(input_cap=args.budget).to_dict(include_content=args.show_content)
+            result.update(
+                mode="offline_probe" if args.command == "probe" else "offline_inspection",
+                synthetic_input=job.synthetic,
+                inference_calls=0,
+            )
+            if args.output is not None:
+                save_inspection(args.output, result)
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+            return 0
+        counter = TiktokenCounter(settings.tokenizer)
+        if args.command == "check":
+            from rank_bm25 import BM25Plus
+
+            BM25Plus([["setup"]]).get_scores(["setup"])
+            counter.count_request(demo_request())
+            print("deps ok")
+            return 0
+        if args.command == "demo-layers":
+            from .demo import layer_demo
+
+            print(json.dumps(layer_demo(counter), indent=2, ensure_ascii=False))
+            return 0
+        plan = plan_budget(required_request=demo_request(), config=settings.budget, counter=counter)
+        print(json.dumps({"valid_request": plan.to_dict()}, indent=2))
+        # Synthetic, bounded fixture: enough tokens to exceed the allowance.
+        if settings.budget.input_allowance > 10000:
+            raise ContextEngineError("Demo accepts input allowances up to 10,000 tokens")
+        try:
+            plan_budget(
+                required_request=demo_request("oversized pin " * settings.budget.input_allowance),
+                config=settings.budget,
+                counter=counter,
+            )
+        except RequiredContextTooLarge as error:
+            print(json.dumps({"expected_failure": error.to_dict()}, indent=2))
+            return 0
+        raise ContextEngineError("Oversized demo fixture unexpectedly fit")
+    except ContextEngineError as error:
+        print(json.dumps(error.to_dict()), file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

context_engine/config.py

@@ -0,0 +1,193 @@
+"""Validated scalar configuration; no models, tokenizer, provider or benchmark imports."""
+
+import math
+import os
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .errors import ConfigurationError
+
+CONFIG_DIRECTORY = Path(__file__).resolve().parent
+MAX_INSPECTION_BYTES = 2_000_000
+MAX_INSPECTION_TURNS = 10_000
+
+
+def nonnegative_integer(name: str, value: int, *, minimum: int = 0) -> None:
+    if type(value) is not int or value < minimum:
+        raise ConfigurationError("Expected an integer within range", field=name, minimum=minimum)
+
+
+@dataclass(frozen=True, slots=True)
+class BudgetConfig:
+    input_cap: int = 3000
+    model_capacity: int = 131072
+    completion_reservation: int = 256
+    retrieval_reserve: int = 280
+    summary_reserve: int = 80
+    provider_input_cap: int | None = None
+
+    def __post_init__(self) -> None:
+        for name in ("input_cap", "model_capacity", "completion_reservation"):
+            nonnegative_integer(name, getattr(self, name), minimum=1)
+        for name in ("retrieval_reserve", "summary_reserve"):
+            nonnegative_integer(name, getattr(self, name))
+        if self.provider_input_cap is not None:
+            nonnegative_integer("provider_input_cap", self.provider_input_cap, minimum=1)
+        if self.completion_reservation >= self.model_capacity:
+            raise ConfigurationError("Completion reservation leaves no input capacity")
+        if self.retrieval_reserve + self.summary_reserve > self.input_allowance:
+            raise ConfigurationError("Layer reserves exceed the input allowance")
+
+    @property
+    def input_allowance(self) -> int:
+        ceilings = [self.input_cap, self.model_capacity - self.completion_reservation]
+        if self.provider_input_cap is not None:
+            ceilings.append(self.provider_input_cap)
+        return min(ceilings)
+
+
+@dataclass(frozen=True, slots=True)
+class TokenizerConfig:
+    encoding_name: str = "o200k_harmony"
+    calibration_factor: float = 1.07
+    adapter_overhead_tokens: int = 0
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.encoding_name, str) or not self.encoding_name.strip():
+            raise ConfigurationError("Tokenizer name must be non-empty", field="encoding_name")
+        factor = self.calibration_factor
+        if (
+            type(factor) not in (int, float)
+            or factor < 1
+            or (isinstance(factor, float) and not math.isfinite(factor))
+        ):
+            raise ConfigurationError("Calibration factor must be finite and at least one")
+        nonnegative_integer("adapter_overhead_tokens", self.adapter_overhead_tokens)
+
+
+@dataclass(frozen=True, slots=True)
+class CapConfig:
+    max_tokens: int = 35
+    head_tokens: int = 22
+    tail_tokens: int = 8
+
+    def __post_init__(self) -> None:
+        for name in ("max_tokens", "head_tokens", "tail_tokens"):
+            nonnegative_integer(name, getattr(self, name), minimum=1)
+        if max(self.head_tokens, self.tail_tokens) > self.max_tokens:
+            raise ConfigurationError("CAP head/tail limits exceed the message cap")
+
+
+@dataclass(frozen=True, slots=True)
+class RetrievalConfig:
+    chunk_characters: int = 360
+    overlap_characters: int = 80
+    top_k: int = 4
+    minimum_score: float = 0.0
+    k1: float = 1.5
+    b: float = 0.75
+    recover_capped_window: bool = True
+
+    def __post_init__(self) -> None:
+        if type(self.recover_capped_window) is not bool:
+            raise ConfigurationError("WINDOW recovery must be an explicit boolean")
+        nonnegative_integer("chunk_characters", self.chunk_characters, minimum=1)
+        nonnegative_integer("overlap_characters", self.overlap_characters)
+        nonnegative_integer("top_k", self.top_k, minimum=1)
+        if self.overlap_characters >= self.chunk_characters:
+            raise ConfigurationError("Chunk overlap must be smaller than chunk size")
+        for name in ("minimum_score", "k1", "b"):
+            value = getattr(self, name)
+            try:
+                valid = type(value) in (int, float) and math.isfinite(value) and value >= 0
+            except OverflowError:
+                valid = False
+            if not valid:
+                raise ConfigurationError("Invalid retrieval parameter", field=name)
+        if self.k1 <= 0 or self.b > 1:
+            raise ConfigurationError("BM25 requires positive k1 and b between zero and one")
+
+
+@dataclass(frozen=True, slots=True)
+class Settings:
+    budget: BudgetConfig = field(default_factory=BudgetConfig)
+    tokenizer: TokenizerConfig = field(default_factory=TokenizerConfig)
+    output_dir: Path = CONFIG_DIRECTORY / "output"
+    cap: CapConfig = field(default_factory=CapConfig)
+    retrieval: RetrievalConfig = field(default_factory=RetrievalConfig)
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.budget, BudgetConfig) or not isinstance(
+            self.tokenizer, TokenizerConfig
+        ):
+            raise ConfigurationError(
+                "Settings require validated budget and tokenizer configuration"
+            )
+        if not isinstance(self.cap, CapConfig) or not isinstance(self.retrieval, RetrievalConfig):
+            raise ConfigurationError("Settings require validated layer configuration")
+        try:
+            path = Path(self.output_dir).expanduser()
+            if not path.is_absolute():
+                path = CONFIG_DIRECTORY / path
+            object.__setattr__(self, "output_dir", path.resolve())
+        except (TypeError, ValueError, OSError, RuntimeError):
+            raise ConfigurationError("Invalid output directory", field="output_dir") from None
+
+    @classmethod
+    def from_env(cls, environ: Mapping[str, str] | None = None) -> "Settings":
+        env = os.environ if environ is None else environ
+
+        def integer(key: str, default: int) -> int:
+            try:
+                return int(env[key]) if key in env else default
+            except (ValueError, TypeError):
+                raise ConfigurationError(
+                    "Environment setting must be an integer", field=key
+                ) from None
+
+        def number(key: str, default: float) -> float:
+            try:
+                return float(env[key]) if key in env else default
+            except (TypeError, ValueError, OverflowError):
+                raise ConfigurationError("Environment setting must be numeric", field=key) from None
+
+        try:
+            factor = float(env.get("TOKENIZER_FUDGE", "1.07"))
+        except (ValueError, TypeError):
+            raise ConfigurationError(
+                "Environment setting must be numeric", field="TOKENIZER_FUDGE"
+            ) from None
+        return cls(
+            budget=BudgetConfig(
+                input_cap=integer("CONTEXT_BUDGET_TOKENS", 3000),
+                model_capacity=integer("MODEL_CONTEXT_TOKENS", 131072),
+                completion_reservation=integer("MAX_COMPLETION_TOKENS", 256),
+                retrieval_reserve=integer("RETRIEVAL_RESERVE_TOKENS", 280),
+                summary_reserve=integer("SUMMARY_RESERVE_TOKENS", 80),
+                provider_input_cap=(
+                    integer("PROVIDER_INPUT_CAP_TOKENS", 0)
+                    if "PROVIDER_INPUT_CAP_TOKENS" in env
+                    else None
+                ),
+            ),
+            tokenizer=TokenizerConfig(
+                encoding_name=env.get("TOKENIZER_NAME", "o200k_harmony"),
+                calibration_factor=factor,
+                adapter_overhead_tokens=integer("ADAPTER_OVERHEAD_TOKENS", 0),
+            ),
+            output_dir=Path(env.get("CONTEXT_OUTPUT_DIR", str(CONFIG_DIRECTORY / "output"))),
+            cap=CapConfig(
+                max_tokens=integer("CAP_MAX_TOKENS", 35),
+                head_tokens=integer("CAP_HEAD_TOKENS", 22),
+                tail_tokens=integer("CAP_TAIL_TOKENS", 8),
+            ),
+            retrieval=RetrievalConfig(
+                chunk_characters=integer("RETRIEVAL_CHUNK_CHARACTERS", 360),
+                overlap_characters=integer("RETRIEVAL_OVERLAP_CHARACTERS", 80),
+                top_k=integer("RETRIEVAL_TOP_K", 4),
+                minimum_score=number("RETRIEVAL_MINIMUM_SCORE", 0.0),
+                k1=number("BM25_K1", 1.5),
+                b=number("BM25_B", 0.75),
+            ),
+        )

context_engine/context.py

@@ -0,0 +1,116 @@
+"""Typed, immutable carrier snapshots and composable layer contract."""
+
+from dataclasses import dataclass
+from typing import Protocol
+
+from .budget import BudgetPlan
+from .errors import ContractError
+from .models import (
+    ChatRequest,
+    Chunk,
+    ContextBlock,
+    KeyedPins,
+    Message,
+    Role,
+    Scope,
+    Turn,
+    freeze_sequence,
+    integer_value,
+    text_value,
+)
+from .work import Cancellation, validate_cancellation
+
+
+@dataclass(frozen=True, slots=True)
+class LayerDiagnostic:
+    layer: str
+    reason_code: str
+    changed_turn_ids: tuple[str, ...] = ()
+    input_text_tokens: int = 0
+    output_text_tokens: int = 0
+
+    def __post_init__(self) -> None:
+        text_value("layer", self.layer)
+        text_value("reason_code", self.reason_code)
+        ids = freeze_sequence(self, "changed_turn_ids", str)
+        if len(set(ids)) != len(ids) or any(not value.strip() for value in ids):
+            raise ContractError("Diagnostic turn IDs must be unique and nonempty")
+        integer_value("input_text_tokens", self.input_text_tokens)
+        integer_value("output_text_tokens", self.output_text_tokens)
+
+
+@dataclass(frozen=True, slots=True)
+class ContextCarrier:
+    scope: Scope
+    original_turns: tuple[Turn, ...]
+    working_turns: tuple[Turn, ...]
+    pins: KeyedPins
+    question: Message
+    plan: BudgetPlan | None = None
+    blocks: tuple[ContextBlock, ...] = ()
+    diagnostics: tuple[LayerDiagnostic, ...] = ()
+    required_request: ChatRequest | None = None
+    prepared_fingerprint: str | None = None
+    window_planned: bool = False
+    retrieved_chunks: tuple[Chunk, ...] = ()
+    cancellation: Cancellation | None = None
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.scope, Scope):
+            raise ContractError("Carrier requires a scope")
+        originals = freeze_sequence(self, "original_turns", Turn)
+        working = freeze_sequence(self, "working_turns", Turn)
+        blocks = freeze_sequence(self, "blocks", ContextBlock)
+        diagnostics = freeze_sequence(self, "diagnostics", LayerDiagnostic)
+        chunks = freeze_sequence(self, "retrieved_chunks", Chunk)
+        if any(chunk.source.scope != self.scope for chunk in chunks):
+            raise ContractError("Retrieved chunk scope mismatch")
+        if self.required_request is not None and not isinstance(self.required_request, ChatRequest):
+            raise ContractError("Carrier requires a validated mandatory request")
+        if self.prepared_fingerprint is not None:
+            text_value("prepared_fingerprint", self.prepared_fingerprint)
+        if type(self.window_planned) is not bool:
+            raise ContractError("window_planned must be boolean")
+        if any(turn.scope != self.scope for turn in (*originals, *working)):
+            raise ContractError("Carrier history scope mismatch")
+        if not isinstance(self.pins, KeyedPins) or self.pins.scope != self.scope:
+            raise ContractError("Carrier pin scope mismatch")
+        if not isinstance(self.question, Message) or self.question.role != Role.USER:
+            raise ContractError("Current question must be a user message")
+        if self.plan is not None and not isinstance(self.plan, BudgetPlan):
+            raise ContractError("Carrier requires a validated budget plan")
+        if len({block.kind for block in blocks}) != len(blocks):
+            raise ContractError("Carrier block kinds must be unique")
+        if any(source.scope != self.scope for block in blocks for source in block.sources):
+            raise ContractError("Carrier block source scope mismatch")
+        original_ids = [turn.turn_id for turn in originals]
+        working_ids = [turn.turn_id for turn in working]
+        if len(set(original_ids)) != len(original_ids):
+            raise ContractError("Original turn IDs must be unique")
+        if working_ids != original_ids:
+            raise ContractError("Working copies must preserve original turn order and IDs")
+        original_messages = [m.message_id for turn in originals for m in turn.messages]
+        if len(set(original_messages)) != len(original_messages):
+            raise ContractError("History message IDs must be unique")
+        if self.question.message_id in original_messages:
+            raise ContractError("Current question must not already occur in history")
+        for original, copy in zip(originals, working, strict=True):
+            if original.revision != copy.revision or original.timestamp != copy.timestamp:
+                raise ContractError("Working copies must preserve source revision and timestamp")
+            if [
+                (m.message_id, m.role, m.tool_call_id, m.tool_calls) for m in original.messages
+            ] != [(m.message_id, m.role, m.tool_call_id, m.tool_calls) for m in copy.messages]:
+                raise ContractError(
+                    "Working copies must preserve message identity and tool metadata"
+                )
+        if self.plan is not None and not set(self.plan.window_turn_ids).issubset(original_ids):
+            raise ContractError("Planned window contains unknown turns")
+        if any(not set(item.changed_turn_ids).issubset(original_ids) for item in diagnostics):
+            raise ContractError("Layer diagnostic references unknown turns")
+        validate_cancellation(self.cancellation)
+
+
+class Layer(Protocol):
+    """Implementations return a new snapshot and never mutate source history."""
+
+    def apply(self, context: ContextCarrier) -> ContextCarrier: ...

context_engine/demo.py

@@ -0,0 +1,98 @@
+"""Synthetic C02 layer walkthrough. No provider or answer generation."""
+
+from datetime import UTC, datetime
+
+from .budget import validate_request
+from .config import BudgetConfig, CapConfig, RetrievalConfig
+from .context import ContextCarrier
+from .layers import CapLayer, PinLayer, RetrieveLayer, SummaryLayer, SummarySnapshot, WindowLayer
+from .layers.common import render_request
+from .layers.summarize import FrozenSummaryPolicy
+from .models import BlockKind, KeyedPins, Message, Pin, Role, Scope, Turn
+from .tokens import TokenCounter
+
+
+def demo_context():
+    at = datetime(2026, 9, 7, tzinfo=UTC)
+    scope = Scope("demo", "incident")
+    old = Turn(
+        "t1",
+        scope,
+        (
+            Message(
+                "m1",
+                Role.TOOL,
+                "BEGIN "
+                + "routine telemetry. " * 60
+                + "The partition carrying the blame was shard-19. "
+                + "routine telemetry. " * 60
+                + " END",
+                tool_call_id="historical-call",
+            ),
+        ),
+        timestamp=at,
+    )
+    recent = tuple(
+        Turn(
+            f"t{i}",
+            scope,
+            (
+                Message(
+                    f"m{i}", Role.USER, f"Recent update {i}: " + "routine checks continue. " * 40
+                ),
+            ),
+            timestamp=at,
+        )
+        for i in range(2, 13)
+    )
+    turns = (old,) + recent
+    pins = KeyedPins(
+        scope, (Pin(scope, "environment", "production", "application", effective_at=at),)
+    )
+    context = ContextCarrier(
+        scope,
+        turns,
+        turns,
+        pins,
+        Message("question", Role.USER, "Which partition carried the blame?"),
+    )
+    budget = BudgetConfig(input_cap=900, retrieval_reserve=280, summary_reserve=80)
+    return context, budget, at
+
+
+def layer_demo(counter: TokenCounter) -> dict:
+    context, budget, at = demo_context()
+    turns = context.original_turns
+    old = turns[0]
+    scope = context.scope
+    capped = CapLayer(counter, CapConfig()).apply(context)
+    prepared = PinLayer(counter, budget, "Use the supplied evidence to answer.", at).apply(capped)
+    retrieved = RetrieveLayer(counter, RetrievalConfig()).apply(prepared)
+    windowed = WindowLayer(counter).apply(retrieved)
+    omitted = tuple(t for t in turns if t.turn_id not in windowed.plan.window_turn_ids)
+    snapshot = SummarySnapshot.from_history(
+        scope=scope,
+        content="Earlier discussion concerned an incident and routine telemetry.",
+        history=omitted,
+        policy_version="demo-v1",
+        created_at=at,
+    )
+    completed = SummaryLayer(counter, FrozenSummaryPolicy(snapshot), at).apply(windowed)
+    request = render_request(completed.blocks, completed.question, completed.required_request.tools)
+    estimate = validate_request(request=request, config=budget, counter=counter)
+    evidence = next(b for b in completed.blocks if b.kind == BlockKind.RETRIEVED)
+    return {
+        "inference_calls": 0,
+        "input_allowance": budget.input_allowance,
+        "original_message_tokens": counter.count_text(old.messages[0].content),
+        "capped_message_tokens": counter.count_text(capped.working_turns[0].messages[0].content),
+        "original_preserved": completed.original_turns == context.original_turns,
+        "capped_middle_fact_present": "shard-19" in capped.working_turns[0].messages[0].content,
+        "retrieved_middle_fact_present": "shard-19" in evidence.content,
+        "retrieved_turn_ids": sorted({c.source.turn_id for c in completed.retrieved_chunks}),
+        "window_turn_ids": list(completed.plan.window_turn_ids),
+        "summary_used": any(b.kind == BlockKind.SUMMARY and b.content for b in completed.blocks),
+        "estimated_request_tokens": estimate.estimated_tokens,
+        "layer_order": [d.layer for d in completed.diagnostics],
+        "retrieved_evidence": evidence.content,
+    }