PickSkill
← Back

Context Recovery

GitHubOpen Entry↗ManusRun Skill in Manus↗
How to load & run skills
ClaudeClaude Code↗OpenAIOpenAI Codex↗CursorCursor↗AntigravityAntigravity↗
GitHubRepo↗Homepage↗ClawHubClawHub
SKILL.md
Rendered from GitHub raw
View raw ↗
On this page
Context RecoverySafety BoundariesTriggersAutomatic TriggersManual TriggersExecution ProtocolStep 1: Detect Active ChannelStep 2: Fetch Channel History (Adaptive Depth)If threadId is present, fetch thread messages firstThen fetch parent channel for broader contextStep 3: Fetch Session Context (safe mode)List recent sessions (if tool exists)Pull last messages from likely matching sessionStep 4: Optional Memory Check (explicitly scoped)Step 5: Synthesize ContextRecovered ContextActive Project/TaskRecent Work TimelinePending/Incomplete ActionsLast User RequestStep 6: Optional Persistence (consent-first)Step 7: Respond with ContextChannel-Specific NotesDiscordSlackTelegram / Signal / OthersConstraintsAuto-Trigger DetectionPseudocode for trigger detectionExample

name: context-recovery description: Automatically recover working context after session compaction or when continuation is implied but context is missing. Works across Discord, Slack, Telegram, Signal, and other supported channels. homepage: https://github.com/PSPDFKit-labs/agent-skills repository: https://github.com/PSPDFKit-labs/agent-skills metadata: { "openclaw": { "emoji": "🔄", }, }

Context Recovery

Automatically recover working context after session compaction or when continuation is implied but context is missing. Works across Discord, Slack, Telegram, Signal, and other supported channels.

Use when: Session starts with truncated context, user references prior work without specifying details, or compaction indicators appear.

Safety Boundaries

  • This skill prioritizes channel/session API history to recover context.
  • It does NOT perform broad filesystem scans or shell glob searches by default.
  • It does NOT send recovered context to external services.
  • It does NOT write to disk unless the user explicitly asks to persist recovered state.

Triggers

Automatic Triggers

  • Session begins with a <summary> tag (compaction detected)
  • User message contains compaction indicators: "Summary unavailable", "context limits", "truncated"

Manual Triggers

  • User says "continue", "did this happen?", "where were we?", "what was I working on?"
  • User references "the project", "the PR", "the branch", "the issue" without specifying which
  • User implies prior work exists but context is unclear
  • User asks "do you remember...?" or "we were working on..."

Execution Protocol

Step 1: Detect Active Channel

Extract from runtime context:

  • channel — discord | slack | telegram | signal | etc.
  • channelId — the specific channel/conversation ID
  • threadId — for threaded conversations (Slack, Discord threads)

Step 2: Fetch Channel History (Adaptive Depth)

Initial fetch:

message:read
  channel: <detected-channel>
  channelId: <detected-channel-id>
  limit: 50

Adaptive expansion logic:

  1. Parse timestamps from returned messages
  2. Calculate time span: newest_timestamp - oldest_timestamp
  3. If time span < 2 hours AND message count == limit:
    • Fetch additional 50 messages (using before parameter if supported)
    • Repeat until time span ≥ 2 hours OR total messages ≥ 100
  4. Hard cap: 100 messages maximum (token budget constraint)

Thread-aware recovery (Slack/Discord):

# If threadId is present, fetch thread messages first
message:read
  channel: <detected-channel>
  threadId: <thread-id>
  limit: 50

# Then fetch parent channel for broader context
message:read
  channel: <detected-channel>
  channelId: <parent-channel-id>
  limit: 30

Parse for:

  • Recent user requests (what was asked)
  • Recent assistant responses (what was done)
  • URLs, file paths, branch names, PR numbers
  • Incomplete actions (promises made but not fulfilled)
  • Project identifiers and working directories

Step 3: Fetch Session Context (safe mode)

Use platform/session APIs only (no shell filesystem scans):

# List recent sessions (if tool exists)
sessions_list:
  limit: 5
 
# Pull last messages from likely matching session
sessions_history:
  sessionKey: <candidate-session-key>
  limit: 80
  includeTools: true

If session APIs are unavailable, skip this step and proceed with channel-only evidence.

Step 4: Optional Memory Check (explicitly scoped)

Only inspect memory if the agent runtime already provides a scoped memory tool/path. Do not run shell glob scans across home directories.

Step 5: Synthesize Context

Compile a structured summary:

## Recovered Context
 
**Channel:** #<channel-name> (<platform>)
**Time Range:** <oldest-message> to <newest-message>
**Messages Analyzed:** <count>
 
### Active Project/Task
- **Repository:** <repo-name>
- **Branch:** <branch-name>
- **PR:** #<number> — <title>
 
### Recent Work Timeline
1. [<timestamp>] <action/request>
2. [<timestamp>] <action/request>
3. [<timestamp>] <action/request>
 
### Pending/Incomplete Actions
- ⏳ "<quoted incomplete action>"
- ⏳ "<another incomplete item>"
 
### Last User Request
> "<quoted request that may not have been completed>"

Step 6: Optional Persistence (consent-first)

Do not write to disk by default. If persistence is useful, ask first:

"I can cache this recovered context to memory for later continuity. Should I save it?"

Step 7: Respond with Context

Present the recovered context, then prompt:

"Context recovered. Your last request was [X]. This action [completed/did not complete]. Shall I [continue/retry/clarify]?"

Channel-Specific Notes

Discord

  • Use channelId from the incoming message metadata
  • Guild channels have full history access
  • Thread recovery: check for threadId in message metadata
  • DMs may have limited history

Slack

  • Use channel parameter with Slack channel ID
  • Thread context requires threadId — always check for thread context first
  • Parent channel fetch provides surrounding conversation context
  • May need workspace-level permissions for full history

Telegram / Signal / Others

  • Same message:read interface
  • History depth may vary by platform
  • Group vs. DM context may differ

Constraints

  • Prefer this protocol before declaring "insufficient data" when context appears missing
  • Adaptive depth: start with 50, expand to 100 max
  • Time-based goal: capture at least 2 hours of context when possible
  • If recovery fails, state what was attempted and what data sources were unavailable
  • Avoid broad filesystem scans or writes without explicit user consent

Auto-Trigger Detection

At session start, scan for compaction indicators:

# Pseudocode for trigger detection
if message contains "<summary>":
    trigger_context_recovery()
elif message contains any of ["Summary unavailable", "context limits", "truncated", "compacted"]:
    trigger_context_recovery()
elif message matches continuation_patterns:
    # "continue", "where were we", "did this happen", etc.
    trigger_context_recovery()

Do not wait for user to ask — if compaction is detected, proactively recover and present context.

Example

Scenario: Session starts with compaction summary

User message: "<summary>Summary unavailable due to context limits...</summary>"
User message: "did this happen?"

Agent executes:

  1. Detects compaction via <summary> tag
  2. message:read channel=discord channelId=1460342116516364533 limit=50
  3. Calculates time span: 2.5 hours — sufficient, no expansion needed
  4. Parses messages, finds last action: "Now let me extract the key orchestration decisions..."
  5. Checks session context APIs — extracts recent user requests
  6. Responds:

"Context recovered. Your last request was to extract orchestration decisions from Nexus archived sessions for PR #137 (Skills & Agents System). This action did not complete before context was truncated.

Recovered state:

  • PR #137: 15,053 additions, 91 files, CONFLICTING merge state
  • Spec location: content/spec-skills-agents-system.md (2,067 lines)

Shall I proceed with the extraction?"