ctx-compact

name	ctx-compact
description	Sweeps everything decided in the current session into its correct source-of-truth home — progress, decisions, spec — and verifies the knowledge base is current and internally consistent before a context reset, so a /compact or a new session loses nothing. Use before running /compact, before ending a session, or whenever the user says they are about to reset or hand off and wants a safety checkpoint. A thin orchestrator over ctx-progress, ctx-merge, ctx-spec, and the consistency gate — it introduces no new rules, it runs the existing ones as a checklist. Not for routine mid-session saves — that is sink-same-turn in ctx-progress.
license	MIT
metadata	{"author":"motiful","version":"1.2"}

ctx-compact — the pre-reset checkpoint sweep

A user-invoked safety ritual, not a new mechanism. It runs the sink discipline that already lives in the companions — ctx-progress (tracking), ctx-spec/ctx-merge (SOT), the consistency gate — across both gates at once, so nothing decided this session is left only in chat when context resets. Lifetime model in ../ctx.

Execution Procedure

The risk this addresses is asymmetric and catastrophic: a /compact or a new session loses whatever was decided but never written to disk. Mid-session that is handled continuously by sink-same-turn (ctx-progress); this skill is the explicit, user-triggered second check right before the reset, and — unlike sink-same-turn — it is cross-cutting: it sweeps not just progress but decisions and spec too.

checkpoint_before_reset() → nothing decided is left only in chat; the base is current + consistent

# STEP 1 — Sweep the TRACKING gate (progress) — the common case
result = Skill("ctx-progress")            # run its pre-reset checkpoint (EP4): sink decided work-state;
                                          # verify active leaf current, next step written, nothing only-in-chat
assert result.delivered                   # GATE — do not report "safe to /compact" on an unconfirmed sink

# STEP 2 — Sweep the SOT gate (decisions / spec) — what progress does NOT own
for each thing DECIDED this session that has crossed the SOT gate (defined in ctx-progress § Sink same-turn):
    if durable product truth:  result = Skill("ctx-spec", thing)                    # edit spec/ in place
    if a made choice + why:    result = Skill("ctx-spec", thing)                    # append decisions/NNNN
                                # (or Skill("ctx-merge", thing) when reconciling multiple sources into one)
    assert result.delivered                  # GATE — do not report "safe to /compact" on an unconfirmed sink
# an agent-synthesized-this-turn design the owner has NOT reviewed does NOT cross — it stays a report proposal
# (the two gates are defined once in ctx-progress; this step RUNS them, it does not redefine them)

# STEP 3 — Verify the base is current + internally consistent
apply("../ctx/references/consistency.md") # single-source (incl. index-sync: reports/README matches what's
                                          # on disk right now — NOT a trigger to archive; that's ctx-report's
                                          # own state-driven rule, orthogonal to a reset) · same-change
                                          # (incl. code↔doc) · verify-against-canonical · the gate

# STEP 4 — Confirm safe to reset
report: what was swept · what is still open (and where it is tracked) · indexes in sync → "safe to /compact"

What it is (and is not)

• It is the ctx-progress pre-reset checkpoint promoted to a user-invocable, cross-SOT entry — you say "I'm about to compact" (or run /ctx-compact) and it sweeps progress and decisions and spec, then verifies the indexes, in one deliberate pass.
• It is not a new sink rule. Every rule it applies is defined elsewhere: the two gates and sink-same-turn in ctx-progress, distillation in ctx-merge, ADR/spec form in ctx-spec, index-sync and the gate in consistency.md. This skill references them; it never restates them (single-source).
• It is not the tool's compaction mechanism. How a tool summarizes history when you run /compact is vendor-owned and changes; ctx-compact owns only that the durable state is externalized first, so the summary is a convenience, not a single point of failure.
• It is not a report-archival trigger. Whether a reviewed report should move to reports/archive/ is ctx-report's own state-driven rule (its § Archiving — state-driven), unrelated to a session reset — an unarchived-but-spent report carries no reset risk, since its keep-worthy content already crossed the SOT gate in STEP 2. STEP 3 only confirms the index matches whatever is currently on disk.

The two gates it respects

Sink the tracking gate every time; sink the SOT gate only for what has passed review. Both gates and their exact criteria are defined once in ctx-progress § Sink same-turn — ctx-compact enforces them across all SOT homes at reset time, it does not re-author them. That distinction is what stops this sweep from over-committing a half-formed, unreviewed design just because the session is ending.

Honest limits

ctx-compact cannot rescue a decision that was never externalized in any form — if a conclusion lived only in the agent's reasoning and never surfaced (not even as a report proposal), the sweep has nothing to find. It is a checklist, not magic: it makes the pre-reset discipline explicit and user-triggerable, but the discipline still has to run. And it verifies structural currency (state on disk, indexes synced) — it does not judge whether the decisions themselves were correct.