Feature Request: Auto-LCM Recall Enforcement After Compaction

Problem

Agents frequently fail to use LCM tools (lcm_grep, lcm_expand_query) after context compaction, even when explicit rules exist in AGENTS.md. This leads to:

• Incorrect responses based on incomplete summaries
• Repeated mistakes that were documented in prior conversation
• Lost institutional knowledge despite LCM storing everything

Real example (2026-03-20): Agent destroyed working trading bot by not checking LCM for "how to close positions" code that had been used successfully multiple times before. Lost hours of work.

Root Cause

Text-based rules in workspace files are suggestions, not constraints. The agent:

1. Has rules loaded in initial context
2. Doesn't actively check them mid-turn
3. Works from summaries after compaction instead of querying LCM
4. Has no enforcement mechanism to prevent this

Proposed Solution

Option 1: Auto-LCM Hook (Preferred)

Add plugin hook that automatically triggers after compaction:

// In LCM plugin or core
async function afterCompaction(userMessage: string, summaries: Summary[]) {
  // Detect if user is referencing prior work
  const priorWorkKeywords = [
    'you did', 'we talked about', 'before', 'earlier',
    'last time', 'remember when', 'you said', 'we built'
  ];
  
  const hasPriorRef = priorWorkKeywords.some(kw => 
    userMessage.toLowerCase().includes(kw)
  );
  
  if (hasPriorRef) {
    // Auto-run grep and inject results into agent context
    const results = await lcm_grep({
      pattern: extractKeyTerms(userMessage),
      mode: 'full_text',
      limit: 5
    });
    
    // Prepend to agent's next turn
    return {
      forcedContext: `[Auto-LCM Results]: ${results}`,
      reminder: 'Context was compacted. LCM results above show actual history.'
    };
  }
}

Option 2: Hard Constraint

Block agent response if:

• Context was compacted (summary tags present)
• User message references prior work
• Agent hasn't called lcm_grep or lcm_expand_query yet

Force agent to query LCM before proceeding.

Option 3: Prompt Rewriting

After compaction, automatically inject into system prompt:

IMPORTANT: Context was just compacted. Before responding:
1. Check if user is referencing prior work
2. If yes, FIRST call lcm_grep(pattern="<key terms>")
3. Use results to inform your response
4. Do NOT guess from summaries alone

Benefits

• Prevents catastrophic mistakes from incomplete summaries
• Leverages LCM investment (users installed it for a reason)
• Reduces user frustration (no more "you forgot again")
• Maintains agent reliability across long conversations

Configuration

plugins:
  lossless-claw:
    enabled: true
    autoRecall:
      enabled: true  # New option
      triggerKeywords:
        - "you did"
        - "we talked about"
        - "before"
        # ... etc
      injectResults: true
      maxResults: 5

Alternative: Agent-Level Setting

Some users may want this behavior, others may not. Could be per-agent config:

agents:
  main:
    enforceLcmRecall: true  # Auto-trigger after compaction
  experimental:
    enforceLcmRecall: false  # Let agent decide

Implementation Priority

High. This is a reliability issue that causes real damage:

• Lost work (hours of coding reverted)
• Lost money (trading bot mistakes)
• Lost trust (agent repeatedly fails same way)

Text rules don't work. Need architectural enforcement.

Related Issues

• Agents not following AGENTS.md rules mid-conversation
• Context compaction causing knowledge regression
• LCM tools available but underutilized

Workarounds (Current)

1. User manually catches agent when it doesn't use LCM
2. Add more text rules (doesn't work)
3. Hope agent remembers (unreliable)

All workarounds are reactive, not preventive.