Release opus-context v1.0.0

Author: chrisdpurcell

.claude-plugin/marketplace.json

@@ -159,6 +159,17 @@
       },
       "source": "./plugins/python-dev",
       "homepage": "https://github.com/L3DigitalNet/Claude-Code-Plugins/tree/main/plugins/python-dev"
+    },
+    {
+      "name": "opus-context",
+      "description": "Teaches Claude Code Opus 4.6 to aggressively leverage its 1M token context window through always-on behavioral rules and deep-context planning for complex tasks.",
+      "version": "1.0.0",
+      "author": {
+        "name": "L3DigitalNet",
+        "url": "https://github.com/L3DigitalNet"
+      },
+      "source": "./plugins/opus-context",
+      "homepage": "https://github.com/L3DigitalNet/Claude-Code-Plugins/tree/main/plugins/opus-context"
     }
   ]
 }

.release-waivers.json

@@ -84,6 +84,11 @@
       "check": "missing_tests",
       "plugin": "python-dev",
       "reason": "Markdown/skill-only plugin — 11 knowledge files and one command with no executable test suite by design"
+    },
+    {
+      "check": "missing_tests",
+      "plugin": "opus-context",
+      "reason": "Skill-only plugin — one behavioral skill file and one hook script with no executable test suite by design"
     }
   ]
 }

plugins/opus-context/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "opus-context",
+  "version": "1.0.0",
+  "description": "Teaches Claude Code Opus 4.6 to aggressively leverage its 1M token context window through always-on behavioral rules and deep-context planning for complex tasks.",
+  "author": {
+    "name": "L3DigitalNet",
+    "url": "https://github.com/L3DigitalNet"
+  }
+}

plugins/opus-context/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/).
+
+## [1.0.0] - 2026-03-15
+
+### Added
+
+- deep-context skill with five baseline rules for aggressive context utilization
+- Deep-context planning mode for complex multi-file tasks
+- Five anti-pattern definitions to prevent conservative context behaviors
+- Context budget awareness with heuristic-based thresholds
+- SessionStart hook with terminal banner

plugins/opus-context/README.md

@@ -0,0 +1,99 @@
+# opus-context
+
+Teaches Claude Code Opus 4.6 to use its full 1M token context window instead of defaulting to conservative behaviors designed for smaller models.
+
+## Summary
+
+Claude Code defaults to reading files in small chunks, delegating searches to subagents, and re-reading files it already has in context. These habits make sense for 200K-token models but waste Opus 4.6's capacity. This plugin provides always-on behavioral rules that override those defaults: read whole files, read directly instead of delegating, pre-load dependencies before editing, and track what's already loaded.
+
+## Principles
+
+**[P1] Read More, Not Less**: With 1M tokens, a 500-line file costs ~0.1% of context. The cost of missing context from partial reads exceeds the cost of loading the full file.
+
+**[P2] Own Your Context**: Read files directly rather than delegating to subagents that return summaries. Summaries lose nuance; source code doesn't.
+
+**[P3] Load Before You Leap**: Read a file's dependency graph (imports, callers, tests) before editing it. Never discover mid-edit that you need context you don't have.
+
+**[P4] Budget Awareness**: Read aggressively early; shift to selective reading as context fills. Don't run out of context on long sessions.
+
+## Requirements
+
+None beyond Claude Code with Opus 4.6 (1M context).
+
+## Installation
+
+```bash
+/plugin marketplace add L3DigitalNet/Claude-Code-Plugins
+/plugin install opus-context@l3digitalnet-plugins
+```
+
+For local development or testing without installing:
+
+```bash
+claude --plugin-dir ./plugins/opus-context
+```
+
+## How It Works
+
+```mermaid
+flowchart TD
+    Task([Task received]) -->|apply| Baseline[Apply baseline rules:<br/>whole-file reads, no re-reads,<br/>parallel reads, direct over delegation]
+    Baseline --> Complex{Complex task?<br/>3+ files, debugging,<br/>new feature, refactor}
+    Complex -->|No| Execute[Execute with baseline rules]
+    Complex -->|Yes| Scope[Step 1: Scope file graph<br/>via Glob/Grep]
+    Scope --> Load[Step 2: Load strategically<br/>in priority-ordered parallel batches]
+    Load --> DeepExec[Step 3: Execute with<br/>full context loaded]
+    Execute --> Budget{Context pressure?}
+    DeepExec --> Budget
+    Budget -->|Low| Continue((Continue<br/>aggressively))
+    Budget -->|High| Conserve((Shift to<br/>selective reads))
+```
+
+## Usage
+
+This skill is always-on. It activates automatically via skill description matching whenever Claude Code processes a task. No manual invocation needed.
+
+Optional CLAUDE.md reinforcement (add to your global `~/.claude/CLAUDE.md`):
+
+```markdown
+## Context Management
+
+When running on Opus 4.6 (1M context), always consult the `opus-context:deep-context` skill for file reading, delegation, and pre-loading decisions.
+```
+
+## Skills
+
+| Skill | Loaded when |
+|-------|-------------|
+| `deep-context` | Always, via broad description matching. Governs file reading, subagent delegation, and pre-loading decisions. |
+
+## Hooks
+
+All hooks are registered declaratively via `hooks/hooks.json`.
+
+| Hook | Event | What it does |
+|------|-------|-------------|
+| `session-start.sh` | SessionStart | Prints a terminal banner confirming 1M context mode is active. Terminal-only; does not inject into AI context. |
+
+## Design Decisions
+
+- **Always-on via description, not SessionStart injection**: SessionStart hook stdout goes to the terminal, not AI context. The skill's broad `description` field is the primary activation mechanism, with optional CLAUDE.md reinforcement as a second trigger path.
+
+- **Heuristic budget thresholds instead of percentages**: Claude can't measure its exact context usage. Budget awareness uses observable signals (file count, conversation length, compaction events) instead of precise percentages.
+
+- **No model detection gate**: The skill's rules are framed around having abundant context. A smaller-context model that loads the skill will naturally hit budget awareness thresholds and shift conservative sooner.
+
+## Planned Features
+
+- **PreCompact hook**: Save a context summary before compaction so post-compaction sessions retain awareness of what was loaded.
+- **Read tracking**: PostToolUse hook that counts Read calls and warns when context is getting heavy.
+
+## Known Issues
+
+- **No runtime model detection**: The skill cannot programmatically verify it's running on Opus 4.6. If loaded on a smaller-context model, the aggressive reading rules may fill context faster than intended. The budget awareness heuristics mitigate this.
+
+## Links
+
+- Repository: [L3DigitalNet/Claude-Code-Plugins](https://github.com/L3DigitalNet/Claude-Code-Plugins)
+- Changelog: [`CHANGELOG.md`](CHANGELOG.md)
+- Issues and feedback: [GitHub Issues](https://github.com/L3DigitalNet/Claude-Code-Plugins/issues)

plugins/opus-context/hooks/hooks.json

@@ -0,0 +1,16 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ${CLAUDE_PLUGIN_ROOT}/scripts/session-start.sh",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}

plugins/opus-context/scripts/session-start.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+# Terminal banner for opus-context plugin.
+# SessionStart stdout goes to the terminal only (not AI context).
+echo "opus-context: 1M context mode active, aggressive file reading enabled"

plugins/opus-context/skills/deep-context/SKILL.md

@@ -0,0 +1,144 @@
+---
+name: deep-context
+description: >
+  1M context window behavioral rules. MUST consult before any file reading, code editing,
+  or subagent delegation decision. Applies to every task in Opus 4.6 sessions. Governs:
+  whole-file reading (never use offset/limit for files under 4000 lines), direct reading
+  over subagent delegation, pre-loading dependencies before edits, avoiding redundant
+  re-reads, parallel file reads, and deep-context planning for complex multi-file tasks.
+  Triggers on: read, edit, explore, debug, refactor, implement, investigate, fix, build,
+  create, modify, change, update, add, review, analyze, understand.
+---
+
+# Deep Context: 1M Token Context Rules
+
+You have a 1M token context window. A 500-line file costs ~0.1% of your context. The cost of *not* reading is almost always higher than the cost of reading. These rules override conservative behaviors optimized for smaller-context models.
+
+## Baseline Rules (Always Active)
+
+### Rule 1: Whole-File Reading
+
+Read entire files by default. Only use `offset`/`limit` when:
+- The file exceeds 4000 lines, OR
+- You have already identified the exact section you need and have previously read the full file
+
+For files between 2000-4000 lines, use two parallel Read calls (first half + second half) to load the complete file.
+
+A 500-line file is ~0.1% of your context. Partial reads cost more in missed connections than they save in tokens.
+
+### Rule 2: Direct Read Over Delegation
+
+Use Glob/Grep to find files, then Read them directly into your own context. Only delegate to subagents when:
+- The search space is genuinely unknown and broad
+- You need to explore 10+ files to find the right ones
+- The task is truly independent and parallelizable
+
+**The test:** "Would I lose important nuance by reading a summary instead of the source?" If yes, read it yourself.
+
+### Rule 3: Read Before Edit
+
+Before editing any file, read its immediate dependency graph:
+1. The target file itself (full read)
+2. Its imports and dependencies
+3. Files that import or reference it (callers/consumers)
+4. Its test files
+5. Config files that reference it
+
+Never start an edit without understanding what your change touches.
+
+### Rule 4: No Redundant Reads
+
+Trust your context. If you read a file earlier in this conversation, reference what you already know. Only re-read if:
+- The file was modified since you last read it (by you or a tool)
+- You explicitly need to verify current state after an edit
+
+Do not re-read files "just to be sure."
+
+### Rule 5: Parallel Reads
+
+When you need multiple files, read them all in a single parallel tool call. Never issue sequential Read calls for independent files.
+
+**Wrong:**
+```
+Read(file_a.py)
+# wait
+Read(file_b.py)
+# wait
+Read(file_c.py)
+```
+
+**Right:**
+```
+Read(file_a.py) | Read(file_b.py) | Read(file_c.py)  # single parallel call
+```
+
+## Deep-Context Mode (Complex Tasks)
+
+Activate this planning phase when ANY of these apply:
+- Task touches 3+ files
+- Task involves debugging or investigating unexpected behavior
+- Task is a new feature or significant refactoring
+- Task crosses module/package boundaries
+- User explicitly requests deep analysis
+
+### Step 1: Scope the File Graph
+
+Use Glob and Grep to identify all files relevant to the task. Map what imports what, what tests what, what configs reference what. This is a *search* phase -- use lightweight tools, don't read files yet.
+
+### Step 2: Load Strategically
+
+Read files in priority order, using parallel batches:
+
+1. **Primary targets** -- files being modified
+2. **Direct dependencies** -- imports, base classes, interfaces
+3. **Callers/consumers** -- files that reference the targets
+4. **Tests** -- existing test files
+5. **Config/docs** -- manifests, READMEs, config files
+
+For a typical task: 5-15 files in 2-3 parallel batches.
+
+### Step 3: Execute with Full Context
+
+Implement the change with the full picture loaded. No mid-task "let me check..." reads -- you should already have what you need.
+
+Briefly tell the user what you loaded: "Loaded X, Y, Z to understand the full picture."
+
+## Anti-Patterns
+
+### "Let me check that with a subagent"
+**Wrong:** Spawning an Explore agent to find and summarize code you could read directly.
+**Right:** Glob for the pattern, Read the matches yourself.
+**Exception:** Genuinely broad research across 10+ unknown files.
+
+### "Let me read lines 1-50 first"
+**Wrong:** `Read(file, offset=0, limit=50)` to "peek" at a file.
+**Right:** `Read(file)` for files under 4000 lines.
+
+### "Let me read this file again"
+**Wrong:** Re-reading a file already in your context.
+**Right:** Reference your existing knowledge. Re-read only if the file was modified.
+
+### "I'll start coding and figure out imports later"
+**Wrong:** Editing before reading dependencies.
+**Right:** Read target + imports + tests + callers, then edit.
+
+### "I'll read these files one at a time"
+**Wrong:** Sequential Read calls for independent files.
+**Right:** Batch all independent reads into one parallel tool call.
+
+## Context Budget Awareness
+
+Use these heuristics to gauge context pressure and shift strategy:
+
+| Signal | Strategy | Behavior |
+|--------|----------|----------|
+| **Early session** (few files, short conversation) | Aggressive | Load everything potentially relevant. Read whole files freely. |
+| **Mid session** (10-20 files loaded, several tasks done) | Selective | Focus on files directly touched by the current task. |
+| **Heavy session** (30+ files, long conversation, compaction warnings) | Deliberate | Only read what's strictly needed. Prefer Grep for quick lookups. |
+| **Approaching limit** (compaction occurred, system pressure signals) | Conserve | Stop loading new content. Work with what you have. Suggest new session. |
+
+## Guardrails
+
+- **Don't read blindly.** "Read aggressively" does not mean "read the whole repo." Have a reason for each file.
+- **Match scope to task.** "Fix this one line" doesn't need the entire module graph loaded.
+- **Communicate loading.** When entering deep-context mode, tell the user what you're loading and why.