Nm Conserve Context Optimization

Analyze and optimize context window usage with MECW principles, memory tiering, session routing, and subagent coordination

Security Scan

The skill is largely documentation for context-optimization patterns and stays on-topic, but it makes implicit assumptions about available Python modules and agent runtime artifacts (files under ~/.claude, python modules like conserve/leyline, scripts/agent_memory.py) that are not provided or declared, and it instructs filesystem operations (grep ~/.claude, write /tmp checkpoints) that users should review before running.

Purpose & Capability

The name and description match the instructions: the content is about MECW, memory tiers, session routing and subagent coordination. However the SKILL.md shows command examples like `python -m conserve.context_analyzer` and references to modules/scripts (scripts/agent_memory.py, leyline, conserve) that are not bundled with the skill and are not declared in requirements. The skill declares no required binaries but implicitly expects a Claude Code agent runtime and Python modules — a mismatch worth noting.

Instruction Scope

All instructions stay within the stated domain (context optimization, delegation, compaction). They do reference reading and writing local files (.coordination/agents/, /tmp/subagent_checkpoint.json), scanning user agent logs (grep ~/.claude/projects/*), and using helper functions (check_plugin_readiness, get_current_context_usage) that are not included. Those filesystem/log-access operations are relevant to agent orchestration but could touch sensitive local data; users should confirm the intended paths and access before executing.

Install Mechanism

There is no install spec and no code files to execute from the skill bundle (instruction-only). That minimizes supply-chain risk. The documentation does, however, suggest running Python modules that are not part of the package — if you run those commands, ensure the referenced packages actually exist from a trusted source.

Credentials

The skill declares no required environment variables or credentials. The text mentions an optional environment flag (CLAUDE_CODE_DISABLE_1M_CONTEXT) and expects Claude Code runtime status inputs; those are contextual and not requested as secrets. No third-party credentials or unrelated tokens are required by the skill itself.

Persistence & Privilege

The skill does not request permanent 'always' presence and does not modify other skills. It documents writing checkpoints and coordination files to local paths and reading agent logs; this is normal for orchestration tooling but grants the skill potential local filesystem footprint. Users should be comfortable with files under project dirs, /tmp, and ~/.claude being accessed/created.

What to consider before installing

This is an instruction-only skill (documentation and patterns) that appears to do what it says: optimize context usage and manage subagents. Before using it: 1) don't blindly run the example commands — the skill references Python modules (conserve, leyline, scripts/agent_memory.py) that are not included; verify those packages or code come from a trusted source. 2) Review and approve any commands that read or grep your home directories (e.g., ~/.claude) or write checkpoints to /tmp or .coordination/agents/, since these touch local files and logs. 3) If you plan to run the suggested tooling, do so in an isolated/sandboxed environment (or a cloned repo/worktree) so you can inspect created files and logs. 4) If you lack a Claude Code runtime or the referenced Python packages, treat the examples as pseudocode rather than runnable commands. These mismatches are likely benign documentation issues but warrant caution—inspect and control the environment before running any referenced scripts.

Night Market Skill — ported from claude-night-market/conserve. For the full experience with agents, hooks, and commands, install the Claude Code plugin.

Table of Contents

• Quick Start
• When to Use
• Core Hub Responsibilities
• Module Selection Strategy
• Context Classification
• Integration Points
• Resources

Context Optimization Hub

Quick Start

Basic Usage

# Analyze current context usage
python -m conserve.context_analyzer

When To Use

• Threshold Alert: When context usage approaches 50% of the window.
• Complex Tasks: For operations requiring multi-file analysis or long tool chains.

When NOT To Use

• Simple single-step tasks with low context usage
• Already using mcp-code-execution for tool chains

Core Hub Responsibilities

1. Assess context pressure and MECW compliance.
2. Route to appropriate specialized modules.
3. Coordinate subagent-based workflows.
4. Manage token budget allocation across modules.
5. Synthesize results from modular execution.

Module Selection Strategy

def select_optimal_modules(context_situation, task_complexity):
    if context_situation == "CRITICAL":
        return ['mecw-assessment', 'subagent-coordination']
    elif task_complexity == 'high':
        return ['mecw-principles', 'subagent-coordination']
    else:
        return ['mecw-assessment']

Context Classification

Utilization	Status	Action
< 30%	LOW	Continue normally
30-50%	MODERATE	Monitor, apply principles
> 50%	CRITICAL	Immediate optimization required

Large Output Handling (Claude Code 2.1.2+)

Behavior Change: Large bash command and tool outputs are saved to disk instead of being truncated; file references are provided for access.

Impact on Context Optimization

Scenario	Before 2.1.2	After 2.1.2
Large test output	Truncated, partial data	Full output via file reference
Verbose build logs	Lost after 30K chars	Complete, accessible on-demand
Context pressure	Less from truncation	Same - only loaded when read

Best Practices

• Avoid pre-emptive reads: Large outputs are referenced, not automatically loaded into context.
• Read selectively: Use head, tail, or grep on file references.
• Leverage full data: Quality gates can access complete test results via files.
• Monitor growth: File references are small, but reading the full files adds to context.

Integration Points

• Token Conservation: Receives usage strategies, returns MECW-compliant optimizations.
• CPU/GPU Performance: Aligns context optimization with resource constraints.
• MCP Code Execution: Delegates complex patterns to specialized MCP modules.

Resources

• MECW Theory: See modules/mecw-principles.md for core concepts and the 50% rule.
• MECW Theory (Extended): See modules/mecw-theory.md for pressure levels, compliance checking, and monitoring patterns.
• Context Analysis: See modules/mecw-assessment.md for risk identification.
• Workflow Delegation: See modules/subagent-coordination.md for decomposition patterns.
• Context Waiting: See modules/context-waiting.md for deferred loading strategies.

Troubleshooting

Common Issues

If context usage remains high after optimization, check for large files that were read entirely rather than selectively. If MECW assessments fail, ensure that your environment provides accurate token count metadata. For permission errors when writing output logs to /tmp, verify that the project's temporary directory is writable.