lcmp_recommendation

Type: ANALYSIS-ONLY DAIC Modes: DISCUSS, ALIGN, IMPLEMENT, CHECK (all modes) Priority: Low

Trigger Reference

This skill activates on:

• •Keywords: "/squish", "compaction", "LCMP", "context cleanup", "context compaction"
• •Intent patterns: "compact.?context", "LCMP.(compaction|cleanup)", "/squish"

From: skill-rules.json - lcmp_recommendation configuration

Purpose

Suggest LCMP (Lean Context Master Pattern) compaction when explicitly requested by the user. This skill NEVER auto-compacts but provides guidance on what information should be promoted to LCMP Tier-1 docs (decisions.md, insights.md, gotchas.md).

Core Behavior

In any DAIC mode, when explicitly requested:

1. •

   Compaction Opportunity Analysis

   • •Review recent work context (completed tasks, discussions, learnings)
   • •Identify information that:
     • •Survived at least one DAIC cycle
     • •Affects future work (designs, constraints, tradeoffs)
     • •Represents recurring patterns or expensive gotchas
   • •Flag information that's ephemeral vs. durable
2. •

   LCMP Categorization Suggestions

   • •decisions.md - Architectural decisions, tradeoffs, rationale
   • •insights.md - Patterns, learnings, best practices discovered
   • •gotchas.md - Pitfalls, failure modes, edge cases encountered
3. •

   Recommendation Presentation

   • •List candidate information for each LCMP file
   • •Explain why each item is worth preserving
   • •Show proposed format/structure
   • •Wait for user approval before any action
4. •

   User-Driven Compaction

   • •Only compact when user explicitly says "yes" / "squish" / "do it"
   • •Never auto-compact based on context usage or heuristics
   • •After user approval, suggest specific edits to LCMP files
   • •Verify user reviews and approves actual changes

Safety Guardrails

ANALYSIS-ONLY RULES:

• •✓ NEVER call write tools (Edit, Write, MultiEdit)
• •✓ NEVER auto-compact without explicit user approval
• •✓ NEVER bypass user review of proposed changes
• •✓ Only provide analysis and recommendations
• •✓ Safe to run in any DAIC mode

LCMP Preservation Rules:

• •Only suggest promoting durable information
• •Avoid promoting ephemeral details (e.g., specific file paths that change often)
• •Preserve existing LCMP content (additive, not replacement)
• •Maintain chronological order in LCMP files
• •Include context dates and references

Anti-Auto-Compaction:

• •NEVER trigger on context percentage thresholds
• •NEVER trigger on elapsed time
• •NEVER trigger on task count
• •ONLY trigger on explicit user request

Examples

When to Activate

✓ User explicitly types: "/squish" ✓ "Compact the context into LCMP files" ✓ "What should we preserve from this session?" ✓ "Squish this into decisions.md" ✓ After major epic completes and user asks: "What did we learn?"

Typical Output

Scenario: Compaction Recommendation After Feature

### LCMP Compaction Recommendation

I've reviewed the recent work on the authentication feature. Here's what I suggest preserving in LCMP files:

---

#### For `context/decisions.md`:

**1. JWT vs. Session Cookies Decision**
```markdown
### Authentication Strategy: 2025-11-15
- **Decision:** Use JWT with httpOnly cookies instead of localStorage
- **Rationale:**
  - XSS protection (cookies not accessible to JS)
  - CSRF mitigation with SameSite=Strict
  - Refresh token rotation for security
- **Tradeoffs:**
  - ✓ More secure than localStorage
  - ✗ More complex token refresh logic
  - ✗ Requires backend cookie management
- **Alternative Considered:** Session cookies (rejected due to scalability concerns)
- **Context:** Task m-implement-auth-2025-11-15

2. Password Hashing Choice

### Password Hashing: bcrypt vs. argon2: 2025-11-15
- **Decision:** Use bcrypt with cost factor 12
- **Rationale:**
  - Well-tested, widely supported
  - Good balance of security and performance
  - Node.js bcrypt library is mature
- **Tradeoffs:**
  - ✓ Standard choice, no surprises
  - ✗ argon2 is slightly more secure
  - ✗ bcrypt sensitive to long passwords (>72 bytes)
- **Prevention:** Document max password length (72 chars)
- **Context:** Auth implementation discussion

For context/insights.md:

1. Express Async Error Handling Pattern

### Async Handler Wrapper Pattern: 2025-11-15
**Learning:** All async Express routes need error boundary

**Pattern Discovered:**
```javascript
const asyncHandler = (fn) => (req, res, next) => {
  Promise.resolve(fn(req, res, next)).catch(next);
};

Why This Matters:

• •Unhandled promise rejections crash the server
• •Express doesn't catch async errors by default
• •This pattern standardizes error handling

Application:

• •Use for all async routes
• •Combine with Sentry for error tracking
• •Document in API development guide

---

#### For `context/gotchas.md`:

**1. bcrypt Async Import Gotcha**
```markdown
### bcrypt Must Use Async Methods: 2025-11-15
**Problem:** Using bcrypt.hashSync() in async functions blocks event loop

**Symptom:**
- API requests hang during password hashing
- Server becomes unresponsive under load

**Root Cause:**
- bcrypt.hashSync() is CPU-intensive and blocks Node.js event loop
- Should use bcrypt.hash() (async) instead

**Fix:**
```javascript
// ❌ WRONG - blocks event loop
const hash = bcrypt.hashSync(password, 12);

// ✅ CORRECT - non-blocking
const hash = await bcrypt.hash(password, 12);

Prevention:

• •Always use async bcrypt methods in async functions
• •Lint rule: no-sync-in-async-function
• •Document in auth implementation guide

---

**Would you like me to add these to LCMP files?**
(Requires explicit approval and IMPLEMENT mode)

Scenario: User Declines

### LCMP Compaction: User Declined

No problem! I won't make any changes to LCMP files.

**When to compact:**
- After completing major features/epics
- When patterns are solidified (not while experimenting)
- When learnings are durable (not one-off fixes)

You can always trigger compaction later with: /squish

When NOT to Activate

✗ Context usage high (never auto-suggest based on %) ✗ Task completed (never auto-suggest based on completion) ✗ User didn't explicitly request compaction ✗ User is just asking about LCMP files (not requesting compaction)

Compaction Criteria

Information Worth Preserving

YES - Promote to LCMP:

• •Architectural decisions with rationale
• •Patterns that apply to multiple features
• •Gotchas that are expensive to rediscover
• •Constraints that affect future work
• •Tradeoffs between competing approaches

NO - Keep Ephemeral:

• •Specific file paths (change often)
• •Temporary workarounds
• •One-off debugging steps
• •Implementation details (belong in code comments)
• •Task-specific TODOs

Decision Quality Check

Before suggesting a decision for LCMP:

• •✓ Decision affects multiple features
• •✓ Rationale is clear and documented
• •✓ Tradeoffs are explained
• •✓ Alternatives were considered
• •✓ Context is provided

Insight Quality Check

Before suggesting an insight for LCMP:

• •✓ Pattern applies broadly
• •✓ Learning is non-obvious
• •✓ Costs significant time to rediscover
• •✓ Example code helps explain it
• •✓ Application guidance is clear

Gotcha Quality Check

Before suggesting a gotcha for LCMP:

• •✓ Problem is recurring or expensive
• •✓ Root cause is explained
• •✓ Fix is clear and tested
• •✓ Prevention strategy noted
• •✓ Context helps identify similar issues

LCMP File Formats

decisions.md Format

### [Decision Title]: [YYYY-MM-DD]
- **Decision:** [What was decided]
- **Rationale:** [Why this decision]
- **Tradeoffs:**
  - ✓ [Advantage 1]
  - ✗ [Disadvantage 1]
- **Alternatives Considered:** [What else was considered]
- **Context:** [Task/issue reference]

insights.md Format

### [Pattern/Learning Title]: [YYYY-MM-DD]
**Learning:** [One-line summary]

**Pattern Discovered:**
[Code example or description]

**Why This Matters:**
[Explanation of importance]

**Application:**
[How/when to use this]

gotchas.md Format

### [Gotcha Title]: [YYYY-MM-DD]
**Problem:** [What goes wrong]

**Symptom:**
[Observable behavior]

**Root Cause:**
[Why it happens]

**Fix:**
[Code or solution]

**Prevention:**
[How to avoid in future]

User Approval Flow

1. •Analyze → Review context, identify candidates
2. •Suggest → Present recommendations with formatting
3. •Wait → User must explicitly approve
4. •Implement → Only after approval (requires IMPLEMENT mode)
5. •Verify → User reviews actual LCMP changes

Never skip steps 3 & 4 (user approval is mandatory).

Decision Logging

When compaction is performed:

### LCMP Compaction Performed: [Date]
- **Trigger:** User explicitly requested ("/squish")
- **Files Updated:** decisions.md, insights.md, gotchas.md
- **Items Added:** 2 decisions, 1 insight, 1 gotcha
- **Context Saved:** ~45% reduction in session context
- **Review:** User approved all additions

Related Skills

• •framework_health_check - Checks LCMP freshness (but doesn't suggest compaction)
• •cc-sessions-core - For understanding DAIC/LCMP relationship
• •framework_repair_suggester - If LCMP files are corrupted or missing

Last Updated: 2025-11-15 Framework Version: 2.0