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.
• INLINECODE2 — the specific channel/conversation ID
• INLINECODE3 — for threaded conversations (Slack, Discord threads)

Step 2: Fetch Channel History (Adaptive Depth)

Initial fetch:
CODEBLOCK0

Adaptive expansion logic:

1. 1. Parse timestamps from returned messages
2. Calculate time span: INLINECODE4
3. If time span < 2 hours AND message count == limit:

1. 4. Hard cap: 100 messages maximum (token budget constraint)

Thread-aware recovery (Slack/Discord):
CODEBLOCK1

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):

CODEBLOCK2

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:

CODEBLOCK3

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:

CODEBLOCK4

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

Example

Scenario: Session starts with compaction summary

CODEBLOCK5

Agent executes:

1. 1. Detects compaction via <summary> tag
2. INLINECODE12
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?"