Strategic Compact for Offensive Security

CTF and offsec sessions are long-form by nature — multi-hour engagements with heavy tool output, iterative exploitation, and chained attack paths. Auto-compaction is destructive in this context because it fires at arbitrary points and silently drops exploit state, payload bytes, and enumeration results. This skill teaches when and how to compact strategically so you keep attacking momentum without context rot.

When to Activate

• Any CTF challenge, HTB machine, or pentest session
• Session approaching context limits (responses getting shorter, losing track of prior findings)
• After hitting a natural phase boundary (see below)
• After 3+ failed strategies in the same category — compact the dead-end reasoning

Why This Matters for Offsec

Auto-compaction in a CTF session can:

• Mangle CVE payloads — null bytes, backticks, escape sequences get stripped by markdown summarization
• Lose enumeration context — which ports you already checked, which creds you already tried
• Break multi-step exploit chains — partial state from stage 1 vanishes before stage 2
• Repeat failed strategies — without the failure context, you try the same dead-end again

Strategic compaction at phase boundaries avoids all of this because Neo4j graph data and workspace files persist independently.

CTF Phase Model and Compact Points

Recon --> Enumeration --> Initial Access --> Post-Exploit Enum --> Lateral/Privesc --> Flag

Natural Compact Points

Never Compact During

Pre-Compact Checklist

Before running /compact, verify all of these. Skipping any item means losing that state permanently:

1. Neo4j graph updated — All findings (ports, creds, vulns, shells) written via mcp__neo4j__write_cypher; all attempt outcomes current
2. Failed approaches documented — Every failed or abandoned attempt updated in Neo4j with outcome: 'failed' and output_summary
3. Working exploits saved — Any exploit script saved to /workspace/ (not just in conversation history)
4. CVE payloads preserved — Payloads with special characters (null bytes, backticks, binary data) saved to file, not just in chat
5. Credential chain documented — Which creds grant access to which services recorded as credential nodes with AUTHENTICATES_TO relationships
6. Current hypothesis noted — What you think the next step is — include in compact summary message

Post-Compact Recovery

After compacting, compact-state.md (auto-generated by PreCompact hook) provides orientation — target name, actual credential/service data, failed attempts, and recent command history. Run this sequence:

1. Read compact-state.md (if it exists)         <- target name + actual data snapshot
2. mcp__neo4j__read_cypher:                      <- full structured state
   MATCH (t:target)-[r*1..3]-(n)
   UNWIND r AS rel
   RETURN DISTINCT labels(n)[0] AS type, n.key AS key, properties(n) AS props
   ORDER BY type, key
3. ls /workspace/                               <- saved exploit scripts and notes
4. Read MEMORY.md                               <- auto-loaded, check for target-specific notes

compact-state.md gives you the quick orientation (creds, shells, what failed, recent commands). The recovery Cypher gives the full structured data. Together = full continuity.

Compact Summary Messages

Always use /compact with a targeted summary. Generic summaries lose critical state.

Bad: /compact (no message) Bad: /compact Working on HTB machine Good: /compact Got shell as www-data via SQLi on port 80. Creds for mysql user in DB. Next: enumerate internal services for lateral movement to user tom. Exploit script at /workspace/sqli.py

The summary becomes your session's "load-bearing context" — everything else is rebuilt from Neo4j and files.

What Survives Compaction

Controlling Auto-Compaction (Claude Code Internals)

Auto-compaction cannot be fully replaced — disabling it causes "prompt is too long" hard errors that permanently kill the session. The correct strategy is to tune auto-compact as a safety net and manually compact before it fires.

Token Budget Reality (200K Window)

With heavy MCP server load (kali + neo4j), usable context drops to ~120K. Auto-compact fires at ~83.5% usage (~167K tokens used).

Configuration

1. Tune auto-compact threshold (recommended: 70% for offsec):

# In shell profile (~/.zshrc or ~/.bashrc)
export CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=70

# Or in project settings (.claude/settings.local.json)
{
  "env": {
    "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "70"
  }
}

Lower = fires earlier = preserves more context quality. At 70%, you get a larger buffer zone to manually compact before auto takes over.

2. Add Compact Instructions to CLAUDE.md (tells the summarizer what to keep):

## Compact Instructions

When compacting, always preserve:
- Target IP/hostname and current attack phase
- All discovered credentials and which services they access
- Current shell access (user, method, path)
- Active exploit chain state (what worked, what's next)
- File paths of saved exploit scripts in /workspace/
- Any CVE identifiers being exploited

These instructions survive compaction (they're in CLAUDE.md which reloads every turn) and guide the summarizer to keep attack-critical context.

3. PreCompact hook (pre-compact-save.sh — auto-saves Neo4j state):

The PreCompact hook fires before every compaction (auto or manual). It cannot block compaction, but it queries Neo4j and writes a rich compact-state.md so the post-compact agent can orient quickly.

What it does:

1. Queries Neo4j via HTTP API (batched — single POST, multiple statements)
2. Writes compact-state.md with: