A Summary That Does Not Grow With Its Age

async def _merge_standing(standing_rows: list[Any], chunk_summaries: list[str], *,
                          cache_dir: Path | None = None) -> list[str]:
    """The body of a pass that found an earlier summary: the standing summary
    merged with the new chunk summaries by one model request, cached on disk
    like a chunk. When the model is unavailable or answers nothing, the
    standing summary and the new chunk summaries side by side: nothing is
    lost, and the next pass merges them."""
    standing = "\n\n".join(body for body in (_standing_body(m) for m in standing_rows) if body)
    if not chunk_summaries:
        return [standing] if standing else []
    if not standing:
        return chunk_summaries
    prompt = _build_merge_prompt(standing, chunk_summaries)
    cache_path = _cache_path(cache_dir, "merge\n" + prompt)
    if cache_path is not None:
        try:
            cached = cache_path.read_text(encoding="utf-8").strip()
            if cached:
                return [cached]
        except OSError:
            pass
    try:
        merged = (await _call_utility_model_complete(
            prompt,
            system=(
                "You keep the standing summary of a long conversation current. Merge, "
                "fold what later turns resolved, and keep what is still open. Return only "
                "the updated summary."
            ),
            temperature=0.1,
            timeout=MERGE_TIMEOUT_SECONDS,
        )).strip()
    except Exception as exc:  # noqa: BLE001
        logger.warning("compaction merge failed: %s", exc)
        merged = ""
    if not merged:
        return [standing, "## Since the last summary", *chunk_summaries]
    if cache_path is not None:
        try:
            cache_path.parent.mkdir(parents=True, exist_ok=True)
            cache_path.write_text(merged, encoding="utf-8")
        except OSError:
            logger.debug("compaction merge cache write failed", exc_info=True)
    return [merged]

"""A minimal sketch: a pass that hands the old summary back to the chunker
nests it; a pass that merges into it keeps one. Toy summarizer, real shape."""
CHUNK_CHARS = 60  # stands in for the real threshold of 18,000 characters


def chunks_of(rows: list[str]) -> list[list[str]]:
    # Whole rows, a chunk closing before the row that would push it past the
    # threshold; a row longer than that (an old summary, soon) rides alone, whole.
    chunks: list[list[str]] = []
    current: list[str] = []
    size = 0
    for row in rows:
        if current and size + len(row) > CHUNK_CHARS:
            chunks.append(current)
            current, size = [], 0
        current.append(row)
        size += len(row)
    if current:
        chunks.append(current)
    return chunks


def summarize_chunk(rows: list[str], n: int) -> list[str]:
    # Like the real model: what already reads as a summary is kept, every
    # event becomes a bullet, and chatter is dropped.
    lines = [line for row in rows for line in row.splitlines()]
    kept = [line for line in lines if line.startswith(("## ", "- "))]
    events = [f"- {line}" for line in lines if line.startswith(("open", "closed", "Dad ruled"))]
    return [f"## Chunk {n}"] + kept + events


def rechunk_pass(summary: list[str], rows: list[str]) -> list[str]:
    # Before: the standing summary goes back in as one more row, the oldest.
    material = (["\n".join(summary)] if summary else []) + rows
    out: list[str] = []
    for n, chunk in enumerate(chunks_of(material), start=1):
        out += summarize_chunk(chunk, n)
    return out


def merge_pass(summary: list[str], rows: list[str]) -> list[str]:
    fresh: list[str] = []
    for n, chunk in enumerate(chunks_of(rows), start=1):  # only the new rows are chunked
        fresh += summarize_chunk(chunk, n)
    # The one merge request: fold what later turns resolved, keep what is
    # open and what Dad ruled, one summary with no chunk headings.
    items = [line for line in summary + fresh if line.startswith("- ")]
    closed = {line.removeprefix("- closed ") for line in items if line.startswith("- closed ")}
    items = [line for line in items if line.removeprefix("- open ") not in closed]
    return ["## Standing summary"] + list(dict.fromkeys(items))


def rows_for(k: int) -> list[str]:
    return [f"open #{k}", "chatter", f"closed #{k - 1}", "chatter", f"Dad ruled R{k}", "chatter",
            "chatter", "chatter", "chatter", "chatter", "chatter", "chatter"]


nested: list[str] = []
merged: list[str] = []
print("pass  re-chunked: lines / chunk headings   merged: lines / chunk headings")
for k in range(1, 9):
    nested = rechunk_pass(nested, rows_for(k))
    merged = merge_pass(merged, rows_for(k))
    heads = lambda summary: sum(line.startswith("## Chunk") for line in summary)
    print(f"{k:>4}  {len(nested):>13} / {heads(nested):<16} {len(merged):>11} / {heads(merged)}")