Symptom

Agent repeatedly executes old instructions. User messages appear duplicated in the assembled context, causing the agent to see the same instruction twice and act on it again.

Root Cause

Three factors combine to produce duplicate messages:

1. Safeguard mode re-injects compressed messages

When compaction.mode is safeguard, OpenClaw's built-in compaction keeps the original messages in the JSONL transcript as a "safety net" after compressing them into a summary. This is by design — safeguard mode's purpose is to never lose data.

2. Lossless-claw afterTurn ingests both the summary AND the original messages

Lossless-claw's afterTurn hook receives params.autoCompactionSummary (the safeguard summary) and dedupedNewMessages (new messages from the JSONL, including the ones safeguard kept). It ingests both:

const ingestBatch = [];
if (params.autoCompactionSummary) {
    ingestBatch.push({role: "user", content: params.autoCompactionSummary});
}
ingestBatch.push(...dedupedNewMessages);

This causes the same user message to appear in LCM's messages table twice — once from the safeguard summary, once from the retained original.

3. OpenClaw 4.29 changed compaction trigger timing

4.29 fixed a tool-result overflow check to use the resolved runtime context token budget instead of the native contextWindow. This means compaction now triggers more readily in long tool-heavy sessions. Before 4.29, many sessions never triggered compaction at all, so the safeguard + lossless-claw interaction was never exercised.

Evidence

• LCM messages table for coder agent (conv 895): 198 messages, but JSONL source only has 151 — 47 extra messages from compaction re-injection
• 4 pairs of duplicate user messages found in assembled context
• context_items table shows the same user message at different ordinals (e.g., ordinal 80 and 88 both contain the same "submit changes" instruction)
• Built-in compaction-duplicate-user-messages dedup module only catches duplicates within a 60-second window (DUPLICATE_USER_MESSAGE_WINDOW_MS = 60000), so it misses safeguard re-injected messages that arrive later

Workaround

Changed agents.defaults.compaction.mode from safeguard to default in openclaw.json:

{
  "agents": {
    "defaults": {
      "compaction": {
        "mode": "default"
      }
    }
  }
}

default mode performs true rolling-window compression without re-injecting old messages.

Why It Worked Before 4.29

1. Compaction triggered less often due to the old token budget calculation, so safeguard's re-injection path was rarely exercised
2. Earlier lossless-claw versions may not have had the autoCompactionSummary ingestion logic
3. Custom config parameters (contextThreshold: 0.75, leafChunkTokens: 25000, delegationTimeoutMs: 600000) may have further increased compaction frequency

Suggested Fix

Lossless-claw's afterTurn hook should skip ingesting dedupedNewMessages that are already covered by autoCompactionSummary, or the built-in dedup window should be expanded to catch safeguard re-injected messages. Alternatively, when compaction.mode is safeguard, the autoCompactionSummary content should be deduplicated against dedupedNewMessages before ingestion.

Environment

• OpenClaw 4.29.x
• lossless-claw extension
• compaction.mode: "safeguard"