/context-surfing

name: context-surfing
description: >
  Monitors context window health during large, long-running, multi-session, or
  explicitly context-sensitive work. Uses bounded external anchors, one
  cold-context review when self-recovery is uncertain, and a clean handoff on
  real drift. Do not auto-activate merely because a medium task has an intent
  frame and plan.

Context Surfing

Install

gh skill install pskoett/pskoett-skills context-surfing

Fallback using the Agent Skills CLI:

npx skills add pskoett/pskoett-skills/skills/context-surfing

The agent rides the wave of peak context. When the wave crests, it commits. When it detects drift, it pulls out cleanly — saving state, handing off, and letting the next session catch the next wave.

No wipeouts. No zombie sessions. Only intentional, high-fidelity execution.

---

Mental Model

Think of context like an ocean wave:

• **Paddling in** = loading the intent frame, plan, and initial context. Energy is building.
• **The peak** = full context coherence. The agent knows exactly what it's doing and why. This is when to execute.
• **The shoulder** = context starting to flatten. Still rideable, but output density is dropping.
• **The close-out** = drift. Contradiction, hedging, second-guessing, or hallucinated details. Wipe-out territory.

The skill's job: ride as long as the wave is good, exit before it closes out.

---

Lifecycle Position

[plan-interview] → [intent-framed-agent] → [context-surfing ACTIVE] → [verify-gate] → [simplify-and-harden] → [self-improvement]

Context Surfing is an optional execution layer for work with meaningful context pressure. It wraps execution between intent capture and post-completion review only when the task is Large, Long-running, multi-session, explicitly requests context monitoring, or shows concrete drift risk.

Relationship with intent-framed-agent

When context-surfing is activated, both skills are live during execution. They monitor different failure modes:

• **intent-framed-agent** monitors *scope* drift — am I doing the right thing? It fires structured Intent Checks when work moves outside the stated outcome.
• **context-surfing** monitors *context quality* drift — am I still capable of doing it well? It fires when the agent's own coherence degrades (hallucination, contradiction, hedging).

They are complementary, not redundant. An agent can be perfectly on-scope while its context quality degrades (e.g., it's doing the right thing but starting to hallucinate details). Conversely, scope drift can happen with perfect context quality (the agent deliberately chases a tangent). Intent-framed-agent's Intent Checks continue firing alongside context-surfing's wave monitoring.

**Precedence rule:** If both skills fire simultaneously (an Intent Check and a drift exit at the same time), context-surfing's exit takes precedence. Degraded context makes scope checks unreliable — resolve the context issue first, then resume scope monitoring in the next session.

**Cadence separation:** Intent checks fire at scope boundaries — *"before touching a new area/file, before starting a new logical work unit, when current action feels tangential"* (`intent-framed-agent/SKILL.md`). Context-surfing's pre-commit anchor check fires at side-effecting-action moments — specific tool calls, writes, commits, commit-level output. Don't run both in the same beat: if an Intent Check has just fired and resolved cleanly, the next side-effecting action inside that same work unit doesn't need a fresh anchor check — you already re-grounded.

When to Use the Full Pipeline

Not every task needs every skill in the pipeline. Match pipeline depth to task complexity:

| Task Type | Skills to Use | |-----------|---------------| | Trivial (rename, typo fix) | None — just do it | | Small (isolated bug fix, single-file change) | `verify-gate` + `simplify-and-harden` | | Medium (feature in known area, multi-file) | `intent-framed-agent` + `verify-gate` + `simplify-and-harden` | | Large (complex refactor, new architecture, unfamiliar codebase) | Full pipeline | | Long-running (multi-session, high context pressure) | Full pipeline with `context-surfing` as the critical skill |

This table matches `skill-pipeline`'s task classification, which is the canonical routing source.

When in doubt, start light. Add skills if you notice drift or quality issues mid-task.

---

Activation

Activate this skill when the task is Large or Long-running, work spans sessions, the user explicitly requests context monitoring, or concrete behavior indicates drift risk. An intent frame plus a plan is not sufficient by itself; do not auto-activate for an ordinary Medium task.

At activation, load the smallest useful anchor:

1. The user's current task and latest scope change 2. The applicable agent instruction file(s) 3. The approved intent frame and plan, when present 4. A prior handoff, when resuming 5. The current session state from Entire, when available

If neither an intent frame nor a plan exists (standalone mode), use the user's original task description combined with project context files as the wave anchor. This is sufficient — the skill degrades gracefully, not catastrophically.

Entire CLI Integration

Entire CLI ([github.com/entireio/cli](https://github.com/entireio/cli)) provides persistent session state that serves as external ground truth for drift checks and handoff files.

At activation, detect Entire:

entire status 2>/dev/null

• If it succeeds and the active host adapter supports the relevant lifecycle

events, Entire captures those supported events passively via hooks. Do not infer full transcript or checkpoint coverage from `entire status` alone. Use `entire status` and `entire explain --session <id>` to inspect available state and record unsupported host coverage explicitly.

• If unavailable or failing, record the optional integration as unavailable

with the bounded rea