Day 2 – The Method

The default Claude Code context window is 1,000,000 tokens (1M). But there is a problem:

• Agent quality degrades after ~50% fill
• At 800K+ the agent starts to ignore instructions
• Without memory management, the HOT file grows to 80KB+ per day

Each folder in .claude/ handles its own layer:

.claude/
├── CLAUDE.md              # SOUL – persona, role, style, boundaries
├── settings.json          # Settings: env, hooks, permissions
├── core/
│   ├── USER.md            # Owner profile
│   ├── rules.md           # Operational rules and boundaries
│   ├── AGENTS.md          # Agent directory (on-demand)
│   ├── MEMORY.md          # Cold memory, lessons index
│   ├── LEARNINGS.md       # Archive of lessons from mistakes
│   ├── warm/
│   │   └── decisions.md   # Key decisions (14 days)
│   └── hot/
│       ├── handoff.md     # Last 10 entries (in context)
│       ├── recent.md      # Full log (NOT loaded into session)
│       └── archive/       # Old logs by date
├── tools/
│   └── TOOLS.md           # Tools reference (on-demand)
├── skills/                # Skills – reusable abilities
├── hooks/                 # Shell scripts for automation
└── scripts/               # Cron scripts for memory rotation

Each layer loads differently:

• IDENTITY + WARM + HOT – automatically at startup via @include
• COLD – agent reads via Read tool when old context is needed
• L4 – agent queries via curl when information is older than 24 hours

The gateway automatically writes every interaction to recent.md:

### 2026-04-14 15:03 [own_voice]
Prince: (voice transcription, 200 chars)
Agent: (compressed reply, 200 chars)

Source tags:

Hooks are shell commands tied to Claude Code lifecycle events. CLAUDE.md is a recommendation (~80% compliance). Hooks are enforcement (100%).

Base hooks (any agent):

• block-dangerous.sh (PreToolUse → Bash) – blocks rm -rf, git push --force, DROP TABLE, curl | bash. Exit 2 = operation canceled.
• protect-files.sh (PreToolUse → Edit|Write) – protects .env, .pem, .key, secrets/*, package-lock.json from accidental changes.
• log-commands.sh (PostToolUse → Bash) – logs every command to command-log.txt. Audit.

Advanced hooks (multi-agent system):

• session-bootstrap.sh (SessionStart) – loads top-5 lessons from episodes.jsonl, checks inbox, sets heartbeat online.
• auto-recall.mjs (UserPromptSubmit) – sends the prompt to OpenViking, returns relevant memories.
• correction-detector.sh (UserPromptSubmit) – catches phrases like "don't", "wrong" – and triggers a lesson capture.
• review-reminder.sh (PostToolUse) – after 10+ edits reminds to run code review before commit.
• flush-to-openviking.sh (PreCompact) – before compaction saves HOT+WARM to OpenViking. Nothing is lost.
• write-handoff.sh (Stop) – generates handoff.md. Next session starts where the previous ended.

Configuration in settings.json:

{
  "hooks": {
    "PreToolUse": [{
      "matcher": "Bash",
      "hooks": [{
        "type": "command",
        "command": ".claude/hooks/block-dangerous.sh"
      }]
    }]
  }
}

You only need one env variable in settings.json:

{
  "env": {
    "CLAUDE_CODE_AUTO_COMPACT_WINDOW": "400000"
  }
}

No other env variables need changing. Do not set MAX_THINKING_TOKENS, SUBAGENT_MODEL, AUTOCOMPACT_PCT – leave defaults. Models are managed by strategy, not by env.

Terse Mode: save on output. Output tokens cost 5x input (Opus: $15 vs $75 per 1M tokens). In a 400K working window every token matters. Add to rules.md:

## Output style
Drop: articles (a/an/the), filler, pleasantries, hedging.
Fragments OK. Short synonyms.
Pattern: [thing] [action] [reason]. [next step].

Before: "Sure! I'd be happy to help you with that. The issue is likely caused by a problem in the auth middleware."

After: "Bug in auth middleware. Token expiry check uses < not <=. Fix:"

Savings: ~75%. The agent writes full code and exact errors – only prose gets compressed.

On the Max plan ($100–200/mo) all models are included. Cost = rate-limit spend, not dollars. Sonnet for subagents = faster replies + less context.

L4 is a local semantic database for long-term memory. The agent searches by meaning, not keywords.

How it works:

1. Stop hook or cron (06:30 UTC) uploads HOT + WARM to OpenViking
2. OpenViking creates embeddings automatically
3. On the next session auto-recall.mjs fetches relevant information

# Search
curl -X POST "http://localhost:1933/api/v1/search/find" \
  -H "X-API-Key: $KEY" \
  -d '{"query": "what did we decide about the API", "limit": 10}'

Each agent writes to its own namespace but searches across all. Cross-agent search out of the box.

The agent records lessons from mistakes. Not just "remember this", but systemically changing itself so the mistake does not repeat.

How detection works. The correction-detector.sh hook (UserPromptSubmit) scans every user message for trigger words:

On match the hook injects a reminder: "CORRECTION DETECTED. Record a learning via learnings-engine.mjs capture".

Pipeline: from mistake to systemic change:

Correction from user
  → correction-detector.sh (catches trigger)
  → learnings-engine.mjs capture (records to episodes.jsonl)
  → learnings-engine.mjs score (computes rating)
  → learnings-engine.mjs lint (finds HOT/STALE/PROMOTE)
  → learnings-engine.mjs promote (changes the system)

Record format (episodes.jsonl):

{
  "id": "EP-20260414-001",
  "ts": "2026-04-14T15:03:00Z",
  "type": "correction",
  "source": "prince",
  "context": "what happened",
  "error": "what was wrong",
  "rule": "rule for the future",
  "impact": "high",
  "tags": ["workflow", "git"],
  "freq": 1,
  "status": "active"
}

Scoring. Each episode gets a composite score (0–1):

Reliability pyramid:

Where it promotes by tags:

Green zone (TOOLS.md, SKILL.md) – agent edits autonomously. Red zone (rules.md, CLAUDE.md) – only with owner's approval.

With a 400K working window: after cron memory takes 7%, without cron – 15%. If cron is broken for a week – 29%, already noticeable. Compression exists to preserve context cleanliness and agent quality.

1. public-architecture-claude-code – architecture, templates, scripts, install.sh. github.com/qwwiwi/public-architecture-claude-code

2. jarvis-telegram-gateway – Gateway: Telegram → Claude Code. github.com/qwwiwi/jarvis-telegram-gateway

3. architecture-brain-tests – 800 tests verifying everything described above. github.com/qwwiwi/architecture-brain-tests

Test categories:

• T20: security (no secrets in templates, .gitignore)
• T26: models (correct IDs, bans, double review)
• T27: COMPACT_WINDOW (400K, 1M context)
• T28: Learnings v2 (engine, scoring, pyramid)
• And 25+ more categories

Copy and send to your agent. It will check itself against all rules:

Memory:

1. Is there a CLAUDE.md? How many lines? (target: up to 200)
2. Is there @include for USER.md, rules.md, decisions.md?
3. Is there core/hot/recent.md? What size?
4. Is there core/warm/decisions.md?
5. Are cron scripts configured for memory rotation?

Settings:

6. CLAUDE_CODE_AUTO_COMPACT_WINDOW set? (target: 400000)

Models:

7. Is Opus used for code and review?
8. Is Sonnet used for subagents?
9. Is double review configured (Opus + Codex GPT-5.5)?

Hooks:

10. Is there a PreToolUse hook blocking dangerous commands?
11. Is there a PostToolUse hook for logging?
12. Is there a Stop hook writing handoff?

Security:

13. Are .env, .key, .pem files in .gitignore?
14. Are secrets stored in secrets/ or shared/secrets/?
15. No hardcoded tokens/keys in files?

Token optimization:

16. CLAUDE.md under 200 lines?
17. AGENTS.md and TOOLS.md load on-demand, not via @include?
18. Is /compact used between tasks?

Result format: Passed: X/18, Failed: [list with recommendations].