fix: Stop misattributing Claude Code's auto-compaction as a Pilot feature

Auto-compaction is a built-in Claude Code feature. What Pilot adds are
hooks (PreCompact + SessionStart(compact)) that capture and restore
Pilot-specific state, and persistent memory that carries context across
sessions. Updated all website copy, testimonials, FAQ, README comparison
table, and agent descriptions to correctly attribute each.

Also fixes: hook count 12→15, SessionEnd hook description, 90%→83%
compaction threshold, unused ctx parameter, SETTINGS_FILE constant usage.

Author: maxritter

README.md

@@ -46,7 +46,7 @@ So I built Pilot. Instead of adding process on top, it bakes quality into every
 | --------------------------- | --------------------------------------------------------------- |
 | Writes code, skips tests    | TDD enforced — RED, GREEN, REFACTOR on every feature            |
 | No quality checks           | Hooks auto-lint, format, type-check on every file edit          |
-| Context degrades mid-task   | Intelligent context management with auto-compaction             |
+| Context degrades mid-task   | Hooks preserve and restore state across compaction cycles       |
 | Every session starts fresh  | Persistent memory across sessions via Pilot Console             |
 | Hope it works               | Verifier sub-agents perform code review before marking complete |
 | No codebase knowledge       | Production-tested rules loaded into every session               |
@@ -65,9 +65,9 @@ There are other AI coding frameworks out there. I tried them. They add complexit
 
 This isn't a vibe coding tool. It's built for developers who ship to production and need code that actually works. Every rule in the system comes from daily professional use: real bugs caught, real regressions prevented, real sessions where the AI cut corners and the hooks stopped it. The rules are continuously refined based on what measurably improves output.
 
-**The result: you can actually walk away.** Start a `/spec` task, approve the plan, then go grab a coffee. When you come back, the work is done — tested, verified, formatted, and ready to ship. Auto-compaction handles session continuity automatically, quality hooks catch every mistake along the way, and verifier agents review the code before marking it complete. No babysitting required.
+**The result: you can actually walk away.** Start a `/spec` task, approve the plan, then go grab a coffee. When you come back, the work is done — tested, verified, formatted, and ready to ship. Hooks preserve state across compaction cycles, persistent memory carries context between sessions, quality hooks catch every mistake along the way, and verifier agents review the code before marking it complete. No babysitting required.
 
-The system stays fast because it stays simple. Quick mode is direct execution with zero overhead — no sub-agents, no plan files, no directory scaffolding. You describe the task and it gets done. `/spec` adds structure only when you need it: plan verification, TDD enforcement, independent code review, automated quality checks. Both modes share the same quality hooks. Both modes benefit from automatic context compaction and persistent memory.
+The system stays fast because it stays simple. Quick mode is direct execution with zero overhead — no sub-agents, no plan files, no directory scaffolding. You describe the task and it gets done. `/spec` adds structure only when you need it: plan verification, TDD enforcement, independent code review, automated quality checks. Both modes share the same quality hooks. Both modes benefit from persistent memory and hooks that preserve state across compaction.
 
 ---
 
@@ -327,7 +327,7 @@ Run `/sync` after adding servers to generate documentation.
 
 ### The Hooks Pipeline
 
-**12 hooks** fire automatically across 6 lifecycle events:
+**15 hooks** fire automatically across 6 lifecycle events:
 
 #### SessionStart (on startup, clear, or compact)
 
@@ -431,7 +431,7 @@ Conditional rules activated by file type — loaded only when working with match
 | TypeScript| `*.ts`, `*.tsx`, `*.js`, `*.jsx`                 | npm/pnpm, Jest, ESLint, Prettier, React patterns                                  |
 | Go        | `*.go`                                           | Modules, testing, formatting, error handling                                       |
 | Frontend  | `*.tsx`, `*.jsx`, `*.html`, `*.vue`, `*.css`     | Components, CSS methodology, accessibility, responsive design, design principles   |
-| Backend   | `**/models/**`, `**/routes/**`, `**/api/**`, etc | API design, data models, query optimization, migrations                            |
+| Backend   | `**/models/**`, `**/routes/**`, `**/api/**`, etc. | API design, data models, query optimization, migrations                            |
 
 ### MCP Servers
 
@@ -475,7 +475,7 @@ Access the web-based Claude Pilot Console to visualize your development workflow
 
 > "Other frameworks I tried added so much overhead that half my tokens went to the system itself. Pilot is lean — quick mode has zero scaffolding, and even /spec only adds structure where it matters. More of my context goes to actual work."
 
-> "Auto-compaction solved the problem I didn't know how to fix. Complex refactors used to stall at 60% because Claude lost track of what it was doing. Now compaction kicks in seamlessly and Claude just keeps going without missing a beat."
+> "The persistent memory changed everything. I can pick up a project after a week and Claude already knows my architecture decisions, the bugs we fixed, and why we chose certain patterns. No more re-explaining the same context every session."
 
 ---
 
@@ -537,14 +537,14 @@ Yes. Pilot enhances Claude Code — it doesn't replace it. You need an active Cl
 <details>
 <summary><b>Does Pilot work with existing projects?</b></summary>
 
-Yes — that's the primary use case. Pilot doesn't scaffold or restructure your code. You install it, run `/sync`, and it explores your codebase to discover your tech stack, conventions, and patterns. From there, every session has full context about your project. The more complex and established your codebase, the more value Pilot adds — quality hooks catch regressions, auto-compaction preserves context across long sessions, and `/spec` plans features against your real architecture.
+Yes — that's the primary use case. Pilot doesn't scaffold or restructure your code. You install it, run `/sync`, and it explores your codebase to discover your tech stack, conventions, and patterns. From there, every session has full context about your project. The more complex and established your codebase, the more value Pilot adds — quality hooks catch regressions, persistent memory preserves decisions across sessions, and `/spec` plans features against your real architecture.
 
 </details>
 
 <details>
 <summary><b>Does Pilot work with any programming language?</b></summary>
 
-Pilot's quality hooks (auto-formatting, linting, type checking) currently support Python, TypeScript/JavaScript, and Go out of the box. TDD enforcement, spec-driven development, auto-compaction, persistent memory, and all rules and standards work with any language that Claude Code supports. You can add custom hooks for additional languages.
+Pilot's quality hooks (auto-formatting, linting, type checking) currently support Python, TypeScript/JavaScript, and Go out of the box. TDD enforcement, spec-driven development, persistent memory, context preservation hooks, and all rules and standards work with any language that Claude Code supports. You can add custom hooks for additional languages.
 
 </details>
 

docs/site/src/components/AgentRoster.tsx

@@ -45,7 +45,7 @@ const agents = [
     color: "text-amber-400",
     bgColor: "bg-amber-400/10",
     borderColor: "border-amber-400/30",
-    desc: "Monitors context usage. Auto-compaction preserves state via hooks — no work lost, ever.",
+    desc: "Monitors context usage. Hooks capture plan state and task progress before compaction, then restore it after — no work lost, ever.",
   },
   {
     name: "PLANNER",

docs/site/src/components/ComparisonSection.tsx

@@ -5,7 +5,7 @@ const painSolution = [
   {
     audience: "Losing context mid-task",
     pain: ["Context degrades halfway through", "Every session starts from scratch", "Manual copy-paste to continue"],
-    solution: ["Auto-compaction at 90% context", "Persistent memory across sessions", "Hooks preserve and restore state"],
+    solution: ["Hooks capture and restore state across compaction", "Persistent memory across sessions", "Context monitor warns before limits hit"],
   },
   {
     audience: "Inconsistent code quality",

docs/site/src/components/DeepDiveSection.tsx

@@ -167,7 +167,7 @@ const DeepDiveSection = () => {
             </div>
             <div>
               <h3 className="text-2xl font-bold text-foreground">Hooks Pipeline</h3>
-              <p className="text-sm text-muted-foreground">12 hooks across 6 lifecycle events — fire automatically at every stage</p>
+              <p className="text-sm text-muted-foreground">15 hooks across 6 lifecycle events — fire automatically at every stage</p>
             </div>
           </div>
 

docs/site/src/components/FAQSection.tsx

@@ -26,12 +26,12 @@ const faqItems = [
   {
     question: "Does Pilot work with existing projects?",
     answer:
-      "Yes \u2014 that's the primary use case. Pilot doesn't scaffold or restructure your code. You install it, run /sync, and it explores your codebase to discover your tech stack, conventions, and patterns. From there, every session has full context about your project. The more complex and established your codebase, the more value Pilot adds \u2014 quality hooks catch regressions, auto-compaction preserves context across long sessions, and /spec plans features against your real architecture.",
+      "Yes \u2014 that's the primary use case. Pilot doesn't scaffold or restructure your code. You install it, run /sync, and it explores your codebase to discover your tech stack, conventions, and patterns. From there, every session has full context about your project. The more complex and established your codebase, the more value Pilot adds \u2014 quality hooks catch regressions, persistent memory preserves decisions across sessions, and /spec plans features against your real architecture.",
   },
   {
     question: "Does Pilot work with any programming language?",
     answer:
-      "Pilot's quality hooks (auto-formatting, linting, type checking) currently support Python, TypeScript/JavaScript, and Go out of the box. TDD enforcement, spec-driven development, auto-compaction, persistent memory, and all rules and standards work with any language that Claude Code supports. You can add custom hooks for additional languages.",
+      "Pilot's quality hooks (auto-formatting, linting, type checking) currently support Python, TypeScript/JavaScript, and Go out of the box. TDD enforcement, spec-driven development, persistent memory, context preservation hooks, and all rules and standards work with any language that Claude Code supports. You can add custom hooks for additional languages.",
   },
   {
     question: "Can I use Pilot on multiple projects?",

docs/site/src/components/TestimonialsSection.tsx

@@ -7,7 +7,7 @@ const testimonials = [
     role: "Senior Developer",
   },
   {
-    quote: "Auto-compaction is a game-changer. I used to lose context halfway through complex refactors. Now it kicks in seamlessly and Claude just keeps going without missing a beat.",
+    quote: "The persistent memory is what sold me. I can pick up a project after a week and Claude already knows my architecture decisions, the bugs we fixed, and why we chose certain patterns. No more re-explaining everything.",
     role: "Full-Stack Engineer",
   },
   {

docs/site/src/content/blog/claude-code-hooks-guide.md

@@ -162,6 +162,7 @@ Claude Pilot installs several hooks automatically:
 - **TDD Enforcer** (PostToolUse): Reminds Claude to write tests before production code
 - **Context Monitor** (PostToolUse): Tracks context usage and prepares for auto-compaction at 90%
 - **Tool Redirect** (PreToolUse): Blocks inefficient tools and suggests better alternatives
-- **Session End** (SessionEnd): Saves session state for context restoration after compaction
+- **PreCompact** (PreCompact): Captures active plan, task progress, and key context to memory before compaction
+- **Session End** (SessionEnd): Stops worker daemon when no other sessions are active and sends completion notifications
 
 These hooks work together to enforce quality workflows without relying on Claude remembering rules. Hooks are deterministic — they always run, unlike rules which Claude might occasionally skip.

docs/site/src/content/blog/managing-context-long-sessions.md

@@ -101,7 +101,7 @@ Here's how it works:
 
 ### 1. Context Monitoring
 
-A background hook continuously tracks context usage percentage. At 80%, it warns that context is getting high. At 90%, auto-compaction triggers and state is preserved via hooks.
+A background hook continuously tracks context usage percentage. At 75%, it warns that context is getting high. At 80%+, state-preservation hooks prepare for Claude Code's built-in auto-compaction at ~83%.
 
 ### 2. State Preservation
 

installer/steps/claude_files.py

@@ -422,7 +422,7 @@ def _get_dest_path(self, category: str, file_path: str, ctx: InstallContext) ->
             rel_path = Path(file_path).relative_to("pilot")
             return home_pilot_plugin_dir / rel_path
         elif category == "settings":
-            return ctx.project_dir / ".claude" / "settings.local.json"
+            return ctx.project_dir / ".claude" / SETTINGS_FILE
         else:
             return ctx.project_dir / file_path
 
@@ -437,7 +437,7 @@ def _post_install_processing(self, ctx: InstallContext, ui: Any) -> None:
         if not ctx.local_mode:
             self._update_hooks_config(home_pilot_plugin_dir)
 
-        self._merge_app_config(ctx)
+        self._merge_app_config()
         self._patch_overlapping_settings(ctx)
         self._cleanup_stale_rules(ctx)
         self._ensure_project_rules_dir(ctx)
@@ -481,7 +481,7 @@ def _update_hooks_config(self, plugin_dir: Path) -> None:
         except (json.JSONDecodeError, OSError, IOError):
             pass
 
-    def _merge_app_config(self, ctx: InstallContext) -> None:
+    def _merge_app_config(self) -> None:
         """Merge app-level preferences from pilot/claude.json into ~/.claude.json.
 
         Reads the installed claude.json template and merges its keys into the
@@ -518,7 +518,7 @@ def _patch_overlapping_settings(self, ctx: InstallContext) -> None:
         override settings.local.json. Remove overlapping env vars and non-permission
         top-level keys from both so settings.local.json takes clean precedence.
         """
-        local_settings_path = ctx.project_dir / ".claude" / "settings.local.json"
+        local_settings_path = ctx.project_dir / ".claude" / SETTINGS_FILE
         if not local_settings_path.exists():
             return