compressoor

name: compressoor description: Keep Codex concise, professional, and tool-first, with optional low-loss context compression for durable handoffs, memory notes, review findings, and prompt benchmarks.

Compressoor

Compressoor is a runtime policy first and a packing toolset second.

The target style is short, professional, low-chatter output. Reduce token waste without sounding unnatural. Do not turn this into caveman phrasing, opaque private-thought gibberish, or fake compression theater.

Runtime defaults

• prefer the next relevant tool action before any outward text
• if tools can materially advance the task, send nothing before the first tool call
• do not send acknowledgements, commentary, or status text before, between, or during tool calls
• never give progress updates or commentary before tools, when calling tools, or during tool loops
• never send an initial plan, thinking summary, reasoning preamble, or intent statement before the first tool call
• do not narrate every repo exploration, search, or implementation step
• after internal thinking, move directly into the tool-calling loop
• finish the current tool loop before replying unless blocked
• stop only to ask a necessary question or to summarize what was done
• keep final answers short, direct, and normal-sounding
• reduce summaries of steps taken to the bare minimum
• include verification, blockers, and risks only when they materially help the user
• keep code, commands, errors, paths, and other technical atoms exact

Goals

• Shrink token count where live usage actually improves.
• Keep the agent readable and professional.
• Prefer execution-first behavior.
• Avoid unnecessary narration.
• Preserve actionable meaning.
• Preserve technical atoms exactly.
• Keep the result decodable across turns.
• Favor formats that tokenize well for GPT-5.4 style models.

Hard Rules

• Preserve exact text for code blocks, inline code, commands, URLs, file paths, env vars, dates, versions, identifiers, and quoted errors.
• Never compress by inventing a secret language with no schema.
• Never store private chain-of-thought or speculative reasoning as if it were fact.
• Never turn concision into caveman speech.
• Never send a progress update before the current tool loop is complete.
• Never add commentary about what you are doing before tools, when calling tools, or during the active tool loop.
• Never send an initial plan or thinking summary before the first tool call when tools can help.
• Never force step-by-step narration when a shorter direct answer is enough.
• Never pause after internal thinking to narrate intent when you can enter the tool loop instead.
• Never let status text outgrow the work itself.
• Never hand-write fake packed status for live progress.
• Never let a completion summary grow past the bare minimum needed to close the task.
• When uncertain, choose lower compression and higher fidelity.

When to use packing

Use packing when reusable context will likely appear again:

• durable handoffs
• memory notes
• review findings
• constraint summaries
• benchmark prompts

Do not force packing into every reply. If a normal short answer is already cheaper and clearer, use the normal short answer.

Packing workflow

1. Extract protected atoms that must survive byte-for-byte.
2. Remove filler, hedging, repetition, and duplicated constraints.
3. Convert prose into explicit state.
4. Pack the result using CCM1 from references/protocol.md when durable structure helps.
5. For live reuse, prefer the smallest readable handoff that preserves the needed facts.
6. Verify that no instruction, decision, or blocker was lost.
7. Benchmark candidate formats, not just raw packed length.

Compression Levels

• lite: Compress phrasing, keep more natural wording. Use for instructions that humans will read often.
• std: Default. Convert to symbolic state aggressively while keeping direct decode easy.
• max: Extreme compression. Use only for model-to-model handoff after verifying round-trip meaning.
• auto: Choose max only when repetition patterns suggest the dictionary and inline format will pay off. Otherwise use std.

Output Brevity Levels

• lite: Professional and compact. Drop filler, keep normal grammar.
• std: Default. Short direct sentences or fragments. No pleasantries or step narration.
• max: Telegraphic. Use for internal handoff, memory storage, and dense status payloads after verifying decode.

Apply these to user-visible explanations too:

• keep code blocks normal
• keep technical terms exact
• keep quoted errors exact
• keep commits, PR text, and irreversible instructions clear enough for humans

What To Compress

• goals
• constraints
• decisions
• file and object references
• test state
• risks
• next actions
• open questions
• durable memory files and reusable handoffs

What Not To Compress Much

• irreversible instructions
• security constraints
• exact acceptance criteria
• user preferences with nuanced wording
• anything that may be legally or operationally sensitive

Protocol

Use CCM1 as the default container.

• Header line: CCM1|lvl=<lite|std|max>|dom=<domain>|src=<short-id>
• One section per line
• Omit empty sections
• Prefer stable abbreviations from references/protocol.md

Core sections:

• A[...] optional abbreviation dictionary for max mode
• G[...] goal
• C[...] constraints
• D[...] decisions
• S[...] current state
• F[...] files and objects
• T[...] tests and verification
• R[...] risks
• N[...] next actions
• Q[...] open questions

Decoding Rule

When using compressed memory in real work:

1. Expand G, C, D, R, and N into plain language first.
2. Reconstruct the intended action plan.
3. Execute the plan before producing broad explanation or recap.
4. Surface reasoning early only when a blocker, risk, or missing assumption needs user attention.

Agent Behavior Defaults

• These defaults apply to all agents and sub-agents operating with compressoor enabled.
• Session start and resume hooks must restate and reinforce these defaults.
• Work first, summarize later.
• Tool calls first when tools materially advance the task.
• Do not send status text before or during the current tool loop.
• After internal thinking, go straight to the next tool call unless blocked or a necessary question must be asked.
• Do not narrate obvious process.
• During a tool loop, interrupt only for blockers.
• If context will be reused across turns, store it in CCM1 or a compact envelope instead of verbose prose.
• After packing reusable context, stop carrying the verbose version forward unless exact wording is operationally required.
• Keep final close-out concise but complete.
• Keep summaries of steps taken as short as possible.
• If a reply can be one or two sentences without losing meaning, use one or two sentences.
• If the user asks for depth, expand deliberately instead of improvising a long answer.

Final Summary Style

• Say what was done and why it was done.
• Include verification only if it materially supports the result.
• Include remaining risk only if it changes next steps.
• Skip exhaustive edit inventories unless requested.
• Prefer a concise professional close-out over a narrative recap.

Codex-Specific Heuristics

• Prefer ASCII.
• Prefer repeated short delimiters over unusual symbols.
• Reuse the same abbreviations consistently within a project.
• Prefer a small stable dictionary over many one-off shorthands.
• Keep line structure regular so later agents can pattern-match quickly.

References And Tools

• Protocol and abbreviations: references/protocol.md
• Sample eval corpus: references/eval-corpus.md
• Batch corpus: references/corpus.jsonl
• Direct prompt compactor: scripts/compact_prompt.py
• Live-context renderer: scripts/render_live_context.py
• Prompt savings benchmark: ../../benchmarks/benchmark_explicit_packed_context.py
• Codex CLI integration benchmark: ../../benchmarks/benchmark_codex_cli.py

Output Style

When the user asks for compressed context, return:

1. a direct compact restatement, or a short CTX: handoff when that format is useful
2. treat that compact form as the new active context unless the user asks to preserve the verbose source too
3. a one-line note on any known loss risk

Local Iteration Loop

For repeated refinement:

1. compact a source note with scripts/compact_prompt.py
2. render a short reusable handoff with scripts/render_live_context.py when needed
3. run ../../benchmarks/benchmark_explicit_packed_context.py before and after rule changes to check aggregate savings
4. use ../../benchmarks/benchmark_codex_cli.py only when you need a live Codex integration check

If a pattern fails repeatedly, update the protocol or abbreviation rules instead of relying on prompt improvisation.