Preserve durable context across repeated compactions

Describe the feature or problem you'd like to solve

Each compaction re-summarizes the previous summary, so early decisions and gotchas degrade with every cycle

Proposed solution

Repeated context compaction is recursively lossy. After one compaction replaces the active conversation history with an LLM-generated summary, a later compaction summarizes that prior summary together with newer turns. Users need a supported way to maintain an additive, durable handoff that is not itself repeatedly summarized.

Add first-class pre- and post-compaction support for a session-scoped durable handoff.

The current behavior is documented and observable:

• The context-management documentation says compaction snapshots the current conversation, sends the full conversation to the model, and replaces the old active history with the generated summary.
• The same documentation warns that important context may be lost after many compactions.
• In a local Copilot CLI 1.0.79 session, the first compaction reported 196 active messages and removed 195; the second reported 473 and removed 472. Each cycle therefore reduced the active history to one replacement message before newer turns accumulated.

The existing preCompact hook is a useful start. It receives transcriptPath, trigger, and customInstructions, so a command can inspect the transcript and persist a handoff. However, its output is not processed, it cannot prevent compaction when handoff generation fails, and there is no postCompact event that can inject the handoff into the newly compacted context.

Suggested minimal contract:

1. Let preCompact return a blocking failure decision and/or additionalContext that is included in the compaction input.
2. Add postCompact, fired after successful compaction, with trigger, checkpointNumber, checkpointPath, and summaryContent.
3. Let postCompact return additionalContext that is injected exactly once into the new active context.
4. Optionally provide a built-in session-scoped handoff ledger so users do not need to launch a nested model from a shell hook.
5. Treat durable facts, decisions, constraints, evidence, and gotchas as additive records with provenance. Keep current state and next steps as replaceable sections, with explicit superseding/tombstone support so stale statements do not accumulate forever.

This would preserve continuity without requiring every later compaction to further compress all earlier knowledge.

Example prompts or workflows

1. Before manual /compact, update the durable handoff from the transcript. If that update fails, stop compaction and show the failure.
2. After compaction, inject the latest handoff exactly once so the agent resumes with the preserved facts and current state.
3. At the next compaction, add only newly learned decisions, constraints, evidence, and gotchas; replace only the current-state and next-steps sections.
4. Apply the same flow to automatic background compaction without interrupting normal work.
5. Use /session handoff to inspect entries, provenance, superseded facts, and the handoff's token cost.

Additional context

Checkpoints are valuable for audit and recovery, but they are passive: earlier phases are no longer in active context unless the user explicitly reads a checkpoint. They do not provide additive durable memory across compactions.

Official references:

• https://docs.github.com/en/copilot/concepts/agents/copilot-cli/context-management
• https://docs.github.com/en/copilot/reference/hooks-reference

I found related requests for configurable compaction thresholds, but no existing issue covering additive handoff state or a post-compaction hook.

Start with the context-management and hooks-reference documentation, then trace the existing preCompact hook and the /compact flow. Define and implement the agreed pre- and post-compaction contract, including failure handling and one-time context injection, and verify the behavior for manual and automatic compaction.