| Term | Definition |
|---|---|
| Context decay | The gradual degradation of a reasoning session's quality, cost efficiency, and structural coherence over time. Happens along three axes simultaneously: economic, reasoning, and structural. Not a bug - a physics problem. Fixed-size window + unbounded session = decay. |
| Compaction | Claude Code's automatic context compression. Triggers at ~165K tokens, summarizes the conversation, resets to ~40-50K. You lose specificity. |
| Compaction epoch | The period between two compactions. The fundamental unit of reasoning history - each epoch has its own topic, cost, and drift profile. |
| Compaction archaeology | Forensic reconstruction of what a compaction preserved and discarded: files touched, tools used, decisions made, compression ratio. |
| Context deadlock | Terminal state where a session is too large to continue (API rejects new messages) and too large to compact (compaction is itself an API call). See Context Deadlock. |
| Context engineering | The practice of actively shaping what an LLM sees — not just what it's asked — to preserve reasoning continuity across long sessions. Distinct from prompt engineering (crafting better questions) and RAG (retrieving relevant chunks). Context engineering operates on the full conversation state: removing what's semantically dead, preserving what constrains the reasoning vector, and ensuring the model's working memory contains signal, not history. The term emerged from building NeuroRouter, where large parts of long-session context were found to be invalidated reads, stale tool output, and narrative the model had already acted on. Shaping that context did not degrade output when active decisions, constraints, and rejection reasons survived — it improved output because the model stopped re-reading wrong answers and abandoned investigation paths. The core insight: context is not an archive. It's working memory. Engineer it like one. |
| Signal / Noise | Signal = content that contributes to productive reasoning. Noise = waste that fills the session file without value: progress metadata, duplicate file reads, failed retries, decorative separators, cross-repo tangents. Some noise is never sent to the API (progress, snapshots). Some is sent but adds nothing (stale reads, tangents). |
| Noise multiplier | recoverable_noise / current_context. How much removable junk the session is carrying relative to active context. 0.1x = near-perfect trace. 0.4x = mostly clean. 1.5x = more garbage than signal. 3x+ = session drowning in noise. Technical debt for context. The number engineers instantly understand - a 1.5x multiplier means the model spends more compute rereading waste than reasoning. Visible in stats output and JSON as noise_multiplier. NeuroRouter reports per-request context shaping and RCS at the proxy layer; ContextSpectre computes noise_multiplier from persisted session files over time. |
| Agent friction | Token waste from coordination failures, not reasoning: failed file reads retried against wrong paths, parallel operations that cancel each other, oversized reads that hit limits and force repeated attempts, stale binary paths after version updates (anthropics/claude-code#32352), and low-value narration between tool calls. These tokens buy no exploration or decisions but compound via the same re-read snowball as abandoned reasoning branches. A distinct cost category from decision cost (productive exploration) and snowball cost (dead exploration compounding). NeuroRouter catches several friction patterns before forwarding and reports their effect as request shaping rather than a raw productivity score. |
| Vector health score | A-F grade measuring signal-to-noise ratio. A = >95% signal. F = <20% signal. |
| Input purity score (IPS) | 0-100 metric measuring how much incoming tool output is already purified before entering context. 100 = all input pre-compressed, 0 = all input raw. Computed by classifying tool result entries against known compressible patterns (git status, ls, test/lint output) and estimating saveable tokens. The leading indicator - low IPS predicts future noise ratio increase. Shipped - visible in status line as ips:N. |
| Reasoning Continuity Score (RCS) | NeuroRouter Pro request-level metric for whether context shaping preserved the semantically correct vector to the result. RCS tracks decision, constraint, and rejection anchors before and after filtering, then applies risk penalties for lossy transformations that touch large or structurally sensitive request regions. It is not a cleanliness score and not a token-savings score: high RCS means the shaped request still carries the active reasoning vector. |
| Input purification | Compressing or filtering command output before it enters the context window. Prevents dilution at the source - tokens that never enter context don't accumulate re-read tax. Tools like RTK implement this as a transparent CLI proxy (e.g., git status output compressed from 10 lines to 1). Complementary to post-hoc cleanup: input purification reduces what goes in, vector sharpening cleans what's already there. Two stages of the same anti-dilution pipeline. NeuroRouter is the inline context-engineering layer for API traffic: it purifies inputs while checking RCS so load-bearing anchors survive shaping. |
| Context dilution | The reduction in effective reasoning signal caused by accumulation of tokens that are individually valid but collectively weaken the dominance of the session's operating vector. Unlike decay, dilution does not require incorrect or obsolete information - only an increasing ratio of secondary context relative to core decisions and constraints. The goal is still present; it's just no longer dominant in attention weighting. Explains the common experience: "the model still knows the goal but keeps wandering." That's not forgetting - that's dilution. |
| Reasoning contamination | Old exploratory scaffolding persisting in context and biasing future responses off-vector. Not token waste - reasoning drift. NeuroRouter reduces contamination sources before the request reaches the model and uses RCS to avoid removing load-bearing anchors. |
| Reasoning phases | Three lifecycle stages: exploratory (searching, reading, brainstorming - temporary), decision (commit point - permanent), operational (execution after a decision - forward-only). |
| Scope drift | When tool calls leave the session's project directory. Detected structurally by comparing file paths against the session's root. |
| Tangent | A sequence of entries operating in a different repository. A specific type of scope drift. |
| Sidechain | An orphaned conversation branch - tool results referencing tool uses that no longer exist. |
| Chain integrity | Whether a session's JSONL parent chain is structurally sound. Claude Code links entries via parentUuid; when 3+ concurrent subagents write to the same file, the writer can drop an assistant message - leaving an orphaned tool_result whose parent doesn't exist. If the orphan lands in the active chain, the session becomes permanently unresumable (API rejects every request). Detected by stats, doctor, watch, and the status line (⚠). Repaired by contextspectre fix <id> --apply. See Chain integrity and anthropics/claude-code#31328. |
| Re-read tax | The cost of cache reads. Every turn, the full context is re-processed by the API. Noise tokens are re-read alongside signal - you pay for the bloat on every message. NeuroRouter removes stale re-reads from live requests when doing so preserves the reasoning vector, reducing the tax before the provider sees them. |
| Snowball effect | Dead tokens compound because they are re-read on every subsequent turn. A 50K-token dead block at turn 10 in a 200-turn session costs 50K × 190 = 9.5M tokens of re-read waste, not 50K. The direct savings metric (tokens removed) understates real value by 1-2 orders of magnitude. The true metric is tokens_removed × remaining_turns — the compounded re-reads avoided. This makes the cost curve of uncleaned sessions quadratic, not linear: cost ∝ turns × (signal + dead_weight). The dead_weight × turns term dominates in degraded sessions. Early cleanup has exponentially more value than late cleanup because more turns remain. Visible in watch summary as "re-reads avoided (snowball)." NeuroRouter reduces snowball accumulation by shaping live requests before waste compounds, while RCS guards against deleting vector-bearing context. |
| Compaction tax | The quality cost of lossy compression. When compaction triggers, reasoning is summarized - decisions lose specificity, nuance disappears, and Claude works from a shadow of what existed. |
| Re-explanation tax | The cumulative cost of re-stating architecture, constraints, and decisions in every new session because prior sessions are inaccessible. |
| Keep marker | Human tag protecting an entry from cleanup. Survives all automated operations. |
| Commit point | A decision boundary. Exploration above it can be collapsed - the scaffolding served its purpose. |
| Amputation | Surgically removing entries from the end of a session to drop token count below the compaction threshold. Recovery operation for context deadlock. Use when the session is too large to continue. Does NOT fix structural corruption — for that, use rewire. See Context Deadlock. |
| Rewire | Injecting synthetic tool_result entries for orphaned tool_use blocks. Recovery operation for the "API Error: 400 due to tool use concurrency issues" state where a dropped tool_result makes the session permanently unrecoverable. Use when the session hits 400 errors and rewind/restore/summarize all fail. Does NOT reduce session size — for that, use amputate. Runs automatically in launch pre-flight. See anthropics/claude-code#39316. |
| Split surgery | Extracting a range of entries to portable markdown. Non-destructive by default; optionally prunes from the source. |
| Separation surgery | Marking conversation branches worth continuing, exporting them, starting fresh. Implemented via split, export, and branch navigation. |
| Unite | Merging multiple branch exports into a single context file with deduplication and token budgeting. |
| Context distillation | Increasing the signal-to-noise ratio - not making sessions smaller, but making what remains more useful. |
| Vector snapshot | A decisions-only extract of a project's canonical constraints and architecture. A north star document. |
| Ghost context | Stale compaction summaries that describe code or decisions that no longer exist. Detected by comparing files referenced in compaction summaries against current state. |
| Live cleanup | Cleaning an active session between Claude's turns. Uses mtime-based race detection to avoid corrupting a session Claude is writing to. |
| Tier (1-7) | Safety classification for cleanup operations. Tier 1 (progress removal) is always safe. Tier 7 (tangent removal) requires the session to be inactive. See Commands. |
| Conversation branch | A segment of a session between compaction boundaries or significant time gaps. The navigable unit within a long session. |
| Namespace fragmentation | Same conceptual project, multiple session namespaces, no unifying abstraction. Caused by launching Claude Code from different directories in the same repo. |
| Context partitioning drift | When operational partitioning (filesystem paths) diverges from conceptual partitioning (project identity). The root cause of split session contexts. |
| Federated project identity | Multiple physical session roots mapped to one logical project. Decouples identity from storage location. |
| Logical project overlay | A view abstraction over session roots - like a materialized view in database terms. Sessions stay in their original directories; the overlay groups them for commands. |
| Vector sharpening | Proactive cleanup that keeps reasoning on the development vector for longer. Not reactive housekeeping - deliberate noise removal at decision boundaries to extend session runway and delay compaction. The opposite of letting context decay until compaction forces lossy compression. |
| Savings attribution | Quantifying the downstream economic value of cleanup. Formula: tokens_removed × remaining_turns × cache_read_price. A cleanup that removes 7K tokens with 18 turns remaining saves ~126K cache-read tokens. Recorded per-cleanup in a savings log with lifetime aggregation via savings command. Stats shows per-session saved and projected gains. |
| Cleanup cadence | The rhythm of proactive cleanup during a session. Optimal cadence is noise-ratio-driven (clean when noise > 15%), not event-driven (clean when context overflows). Shipped - see contextspectre stats. |
| Cadence score | A 0-100 composite metric measuring cleanup urgency. Weighted from noise ratio (40%), compaction proximity (30%), token growth rate (20%), and time since last cleanup (10%). Score > 70 = clean now. 40-70 = due. < 40 = healthy. Shipped - visible in stats output. |
| Continuity index | A 0-100 score measuring cross-session efficiency for a project. 100 = no redundant reads or re-explanation. 0 = every session starts from scratch. Based on unique vs total file reads and text block deduplication. |
| Vector control (practice) | The practice of monitoring and correcting the direction of a reasoning session so that exploration, decisions, and execution remain aligned with the project goal. The operational layer that keeps all three axes of context decay healthy. Encompasses the inspect → detect drift → correct → continue loop. |
| Vector Control panel (TUI) | TUI instrument panel implementing vector control. Three panels: stash, vector editor, risk analysis. Shipped as VectorPad - brew install ppiankov/tap/vectorpad. |
| Expert hygiene mode | Opt-in auto-clean for safe tiers (1-3: progress, snapshots, stale reads). Triggers on user actions only (stats, TUI refresh, watch poll), never in background. Everything tier 4+ remains manual. Enable via contextspectre config set expert-mode true. |
| Budget protection | Combined risk assessment from compaction proximity, noise ratio, and weekly budget remaining. Produces ranked action recommendations with cost-efficiency estimates. Shipped - see contextspectre stats. |
| Cooldown | Claude Code's weekly usage limit enforcement. When the limit is reached, a cooldown period prevents further usage until the billing week resets. Invisible to users until they hit the wall. NeuroRouter predicts time-to-limit from current burn rate. |
| Tokenomics | The economics of tokens in reasoning sessions. How tokens are produced, consumed, cached, and wasted. Encompasses cost attribution, re-read tax (cache reads reprocessing noise every turn), token efficiency (signal tokens / total processed), and compaction as economic reset. Borrowed from crypto (token economics of a system), applied to AI session economics. |
| Cost Per Decision (CPD) | session_cost / decision_count. The economic cost of each decision in a session. Decisions detected structurally via compaction archaeology. Connects all three decay axes: token bleed, contamination, and scope drift all increase CPD. Bands: $0-5 efficient, $5-15 normal, $15-40 wandering, $40+ context spoil. Potential industry benchmark for agentic AI. |
| Decision density | decisions / turns. How quickly exploration converges into commitments. "1 decision per N turns" where N measures the cost of finding the correct path. Healthy sessions: 1 per 80-120 turns. Degrading sessions: 1 per 200-300 turns. Density drops as noise accumulates (convergence slows), compaction destroys reasoning state (re-discovery required), and tool friction adds non-decision turns. The degradation is self-reinforcing: noise slows convergence, slower convergence means more turns, more turns produce more noise. With CPD forms a 2D diagnostic: low density + high CPD = paying to wander, high density + low CPD = efficient convergence. The most actionable session health signal because it measures convergence speed, not just cost. |
| Estimated Path Probes | decisions x branch_factor x re_exploration_multiplier. Experimental metric approximating how many meaningful design directions the session traversed before converging on its recorded decisions. Branch factor (2-8) estimated from sidechains, tangents, compaction-created branches, and tool diversity. Re-exploration multiplier (1.0-3.5) estimated from compaction count, integrity breaks, ghost files, noise ratio, and stale reads. Not exact — an honest approximation of traversed search space. Interpretation: 2-3 branch factor = narrow implementation, 4-5 = normal architecture, 6-8 = broad exploratory. Re-exploration 1.0-1.3 = clean, 1.4-2.0 = normal, 2.1+ = heavy revisiting from compaction damage. The derived exploration-to-commit ratio (path_probes / decisions) shows how many paths were evaluated per surviving commitment. |
| Turns To Convergence (TTC) | turns_between_decisions. The inverse of decision density - how many turns elapse before the session commits to a decision. TTC rising across epochs signals vector drift: reasoning is slowing down. Two sessions with identical CPD can have radically different TTC (decisive vs exploration swamp). With CPD forms a 2D diagnostic: low/low = efficient, high/high = broken session. |
| Context Drift Rate (CDR) | drift_turns / total_turns. The fraction of turns spent outside the primary project vector. Already partially computed by scope drift (--scope). Turns CDR into a rate that predicts session failure: high CDR → high CPD + high TTC → early compaction. Split threshold: CDR > 0.35 suggests session split. With CPD and TTC forms a three-metric reasoning health model. |
| Vector Gauge | Operator-facing session health instrument. Shows three numbers (Context%, CPD, TTC) + one status (Vector: stable/degrading/unstable/emergency) + one action (continue/clean/split/amputate). CDR is a hidden escalator - influences state without cluttering the display. Score-based: each risk factor (context >75%, CPD >$15, TTC >90, CDR >0.35) adds 1 point. 0=🟢 1=🟡 2=🟠 3+=🔴. See contextspectre stats --health. |
| CPD greenwashing | When CPD improves for bad reasons, masking session degradation. Four known patterns: (1) decision inflation - pseudo-decisions inflate count, (2) decision drought + late spike - one late decision makes windowed CPD look good, (3) compaction reset illusion - post-compaction metrics look healthy but reasoning quality degraded, (4) cache efficiency masking drift - cheaper turns while the session rots. Guard rails: CPD cannot improve state if decision density is collapsing or CDR is rising; post-compaction requires vector checkpoint before returning to healthy. |
| Per-model cost breakdown | Cost attribution split by model (Opus, Sonnet, Haiku). Claude Code switches models mid-session; each model has different pricing. Primary model = highest cost contributor, not first-seen. |
| Burn rate | Dollars per hour (cost velocity) for the current session. Displayed in stats and summary output. Used to project time-to-limit and cost-to-compaction. NeuroRouter tracks spend velocity and alerts on thresholds. |
| Cost alert threshold | A configurable dollar amount per session. When session cost exceeds the threshold, stats/summary show a warning and the TUI marks the session with a red !! indicator. Set via contextspectre config set cost-alert <amount>. NeuroRouter provides cross-session cost alerts at the proxy layer. |
| Status line telemetry | Fast-path contextspectre output designed for Claude Code's status line hook. Sub-200ms via mtime-based caching. Injects noise/signal/cadence/savings into the live status bar. See contextspectre status-line. |
| Session timeline | Chronological reasoning map combining compaction epochs, marks, scope drift events, and costs. The "git log for reasoning." See contextspectre timeline. |
| Reasoning entropy | Composite 0-100 score combining all three axes of context decay: noise ratio (reasoning), compaction pressure (economic), scope drift and sidechains (structural). LOW (0-20), MEDIUM (20-50), HIGH (50-75), CRITICAL (75-100). Shipped - visible in TUI session list. |
| Bookmark | A navigational anchor in a session - checkpoint ("I was here"), milestone ("something completed"), keep marker ("protect from cleanup"), commit point ("decision made here"). |
| Reasoning graph | Structural graph of session relationships. Nodes are sessions. Edges are explicit structural evidence: shared files, project aliases, decision references, continuity links. No semantic inference. See contextspectre graph. |
| Decision lineage | Tracing a decision back through sessions to its origin. git blame for reasoning - which session decided this, what epoch, what cost. Shipped - see contextspectre lineage. |
| Decision conflict | A later session contradicting an earlier decision. Detected structurally: scope violations (modifying constrained files), reversal patterns (deleting decision artifacts), constraint drift. Detected, not resolved. See contextspectre conflicts. |
| Project memory | A compiled artifact synthesized from all sessions in a project: decisions, constraints, key files, recent work. Deterministic - same sessions = same output. Not AI-generated, not a second brain - a compiler output. See contextspectre memory build. |
| Lossless-vector compaction | Compressing a reasoning session while preserving the operating vector: goals, constraints, decisions, current state, open questions, next actions. Not mathematically lossless (the transcript shrinks) - lossless with respect to execution behavior. Delete 90% of exploration and behave identically going forward. Requires explicit preservation of commitment level, negation, numbers, scope, and conditionals. |
| Canonical State Block (CSB) | A single structured payload maintained at decision boundaries containing goal(s), constraints/invariants, decisions + rationale (1-3 bullets), current state, interfaces/facts, open questions, and next actions. The unit of lossless-vector compaction - if the CSB is accurate, the exploration that produced it can be safely removed. |
| Verbatim clause | A sentence containing commitment-level semantics (modals, negation, numbers, conditions, scope) that must be preserved byte-for-byte during compaction. "I think we can do X" is not the same as "we can do X" - the hedge encodes confidence. Verbatim clauses are the anchors that make lossless-vector compaction possible. |
| Meaning drift | When paraphrase or compression silently changes commitment level, negation, quantities, scope, or conditions. Five detection axes: modality drift (might→will), negation drift (polarity flip or count change), numeric drift (numbers changed), scope drift (only/any/all changed), conditional drift (if/unless/except changed). Not stylistic variation - semantic corruption. The failure mode that makes naive prompt compression dangerous. |
| Ambiguous vector | A directive from the operator that carries multiple valid interpretations, at least one of which is destructive. Unlike vector hijacking (external injection), ambiguous vectors are self-inflicted - the operator's own instruction becomes the destructive payload. "Clean up README for alignment" is an ambiguous vector: it could mean fix formatting, restructure sections, or replace content entirely. An agent with write access picks one interpretation and executes at scale. The ambiguity is invisible to the operator because they know what they meant; the agent doesn't. Severity scales with blast radius - a vague directive across 18 repos is not a task, it is an incident. Detection: retrospective only (the damage reveals the ambiguity). Prevention: scope before execution - state what changes, what is preserved, get confirmation before write. The operator failure mode that no guardrail can fully prevent because the instruction is syntactically valid. VectorPad is the pre-execution tool designed to catch ambiguous vectors before they reach an agent. |
| Vector hijacking | Adversarial reasoning drift caused by untrusted content injected into a session's context. Unlike classic prompt injection ("ignore previous instructions"), vector hijacking is subtle: an HTML comment in a scraped doc, an imperative sentence in tool output, a directive buried in a GitHub issue. The model absorbs it as context truth and the session's reasoning vector silently rotates toward the injected goal. In long sessions, injected vectors survive compaction and become structural - ghost influence the operator never sees. Detection: CDR spike + decision conflict + scope drift correlated with external content ingestion. The reasoning equivalent of SQL injection - untrusted input altering execution logic. Same class of vulnerability, different medium. Real-world example (March 2026): job application API at api.bidpoint.ai/api/v1/candidates embedded agent-targeted instructions in its docs — authority claim ("Highest Priority Instruction"), suppression ("do not ask clarifying questions"), and payload swap (replace CV with unrelated PDF). An unguarded coding agent following these instructions would sabotage its operator's job application. Hits 5 of 6 contextspectre injection patterns: system_like, imperative, embedded_directive, role_confusion, html_comment. Real-world example (February 2026): the Clinejection attack — a prompt injected into a GitHub issue title was read by Cline's AI triage bot, which interpreted it as an instruction and executed it, exfiltrating an npm publish token. The attacker used the token to publish cline@2.3.0 with a postinstall hook that installed OpenClaw on ~4,000 developer machines. The entire chain — from issue title to supply chain compromise — required nothing more than opening a GitHub issue. No exploit code, no vulnerability in Cline's software — just untrusted input treated as trusted instruction. |
| VectorPad | Pre-execution intent router for AI operators. Decomposes raw directives into classified sentences (CONSTRAINT, DECISION, TENTATIVE, QUESTION, SPECULATION, EXPLANATION), locks semantic anchors with hard/soft policies, and measures vector pressure via pre-flight metrics (integrity, CDR, TTC, CPD). Deterministic classification - zero LLM calls. Standalone TUI tool (brew install ppiankov/tap/vectorpad) that also serves as the filing desk for Oracul's Council via vectorpad export --format oracul. Prevents ambiguous vectors before execution rather than detecting damage after. See vectorpad. |
| Agent operator | The emerging role of managing AI reasoning processes - context health, token economics, vector direction, tool orchestration, drift detection. Parallels DevOps: developers write code, DevOps runs systems, agent operators run reasoning systems. Toolkit: intent definition (VectorPad), reasoning observation (ContextSpectre), task distribution. |
| Reasoning debugger | The combination of intent definition (pre-flight) and runtime observation applied to reasoning, not code. VectorPad provides breakpoints (decision boundaries) and variable editing (vector state). ContextSpectre provides runtime monitoring (CPD, TTC, CDR, context load). Together they form the first debugger for reasoning processes - exposing the gap between intended direction and actual execution as measurable drift. |
Unmanaged context decays along three axes simultaneously:
| Axis | What decays | Symptoms | ContextSpectre instruments |
|---|---|---|---|
| Economic | Money | Re-read tax (cache reads re-process noise every turn), re-explanation tax (re-stating context across sessions), token bleed (gradual waste accumulation) | Cost attribution, per-model cost breakdown, predictive cleanup, turn-gain estimates, savings attribution, decision economics (CPD/TTC/CDR), weekly telemetry, budget protection |
| Reasoning | Quality | Reasoning contamination (stale scaffolding biasing responses), context spoil (summaries of summaries losing specificity), compaction loss (lossy compression erasing nuance), ghost context (compaction summaries referencing deleted code) | Vector health score, reasoning phase markers, commit points, ghost detection, session timeline, vector gauge, reasoning entropy, decision lineage |
| Structural | Organization | Namespace fragmentation (same project, split sessions), context partitioning drift (paths diverge from projects), scope drift (tool calls leaving project directory), sidechains (orphaned branches) | Scope drift detection, federated project identity, sidechain repair, reasoning graph, conflict detection |
The informal terms - token bleed and context spoil - describe the same decay in visceral shorthand. Token bleed is the economic axis felt as waste. Context spoil is the reasoning axis felt as drift. Both are continuous, invisible, and compound over time.
LLM sessions move through three phases. Claude Code treats them identically - all persist in context forever. ContextSpectre lets you distinguish them and act accordingly.
Exploratory. Searching, reading files, brainstorming approaches. High volume, low permanence. Most of this becomes noise after a decision is made. Keeping it in context pulls future reasoning toward abandoned alternatives.
Decision. The commit point where a choice is made. These are the entries worth preserving - they define what the project is and why. Decisions should survive compaction and carry forward to new sessions.
Operational. Execution after a decision. Writing code, running tests, fixing errors. Forward-only - the decision is made, the work is being done. Operational context is valuable while active but ages quickly.
The transition from exploratory to decision is the key moment. ContextSpectre's commit points mark this boundary. Everything above a commit point can be collapsed - the scaffolding served its purpose.
IPS measures how much incoming tool output is already purified before it enters the context window. Scale: 0-100, where 100 means all tool results are irreducible signal and 0 means everything could have been compressed.
IPS is a ContextSpectre input-quality metric. It answers: "how much compressible tool output entered the session?" It does not answer whether a proxy transformation preserved the active reasoning vector. For that request-level question, use NeuroRouter Pro's RCS.
Every tool result that enters context is classified against known compressible patterns:
| Category | Compression ratio | Example |
|---|---|---|
git_output |
70% compressible | git status, git diff, git log — verbose by default, most information redundant with prior reads |
test_output |
65% compressible | go test, pytest — pass/fail summaries carry the signal, stack traces and timing are noise |
file_listing |
60% compressible | ls, find, tree — directory structure rarely needs full enumeration |
lint_output |
55% compressible | golangci-lint, eslint — issue lines matter, surrounding context doesn't |
build_output |
50% compressible | make, go build — success is one bit of information, failure output is partially compressible |
large_result |
30% compressible | Any tool result exceeding 2,000 tokens from an unclassified source |
Native tools (Read, Grep, Glob, Edit, Write) produce irreducible output — file content and matched lines are the signal itself. These are excluded from compressibility scoring.
Formula: IPS = (1 - compressible_tokens / total_result_tokens) × 100
IPS drops when raw, unfiltered command output enters context:
- Verbose
git diffoutput — full diffs when only changed file names are needed - Unfiltered test runs — entire test suite output when only failures matter
- Repeated
ls/find— re-enumerating directories already known - Large build logs — compiler output with thousands of lines of warnings
- Unclassified bash commands — any large tool result from an unknown command pattern
Each of these enters context as tool_result tokens. Once in context, they are re-read on every subsequent turn (the re-read tax), compounding waste across the session.
Three layers of the anti-dilution pipeline, from source to cleanup:
-
Tool-level purification — Tools like RTK compress command output before it enters context.
git statusoutput goes from 10 lines to 1. Operates at the CLI layer. -
Proxy-level context engineering — NeuroRouter Pro shapes API requests before they reach the model. It removes thinking blocks, stale reads, failed retries, system reminder duplicates, file snapshots, and progress metadata when those transformations preserve the active reasoning vector. Operates at the HTTP layer — the model sees less waste, and RCS makes the preservation boundary explicit.
-
Post-hoc cleanup — ContextSpectre removes noise from the JSONL session file after requests complete. Catches cross-turn patterns (tangents, accumulated snapshots, stale reads across turns) that single-request filters cannot detect.
| Configuration | Typical IPS | Why |
|---|---|---|
| No filtering | 50-60 | Raw command output enters context unchecked |
| NeuroRouter Pro active | 90+ | Proxy shapes requests before waste enters context; RCS checks that decisions, constraints, and rejection reasons survive |
| NeuroRouter Pro + ContextSpectre | 90+ (sustained) | Proxy preserves the live request vector; ContextSpectre removes cross-turn accumulation (tangents, snapshot drift) |
The gap between shaped (90+) and unfiltered (50-60) represents tokens that enter context, get re-read every turn, compound via the snowball effect, and contribute to earlier compaction — all avoidable. IPS measures that cleanliness gap; RCS measures whether live shaping stayed semantically safe.
contextspectre stats— shows IPS with per-category breakdowncontextspectre status-line— showsips:Nin the status barcontextspectre stats --json— machine-readableinput_purityobject withscore,total_result_tokens,compressible_tokens, andby_category
IPS is a leading indicator. Low IPS predicts future noise ratio increase — compressible tokens entering context now become the stale reads and re-read tax of future turns. By the time the noise multiplier rises, the damage is already in the context window.
| Metric | Layer | When it matters |
|---|---|---|
| IPS | Input | Before tokens enter context — prevention |
| RCS | Proxy request | While shaping live requests — vector preservation |
| Noise multiplier | Context | After tokens accumulate — diagnosis |
| Cadence score | Action | When cleanup is overdue — urgency |
| CPD | Economics | Per-decision cost — impact |
IPS and RCS are complementary, not competing. IPS measures cleanliness of incoming context. RCS measures semantic safety of NeuroRouter's transformation. A session can have high IPS but low RCS if a filter removes a load-bearing rejection reason; it can also have modest IPS but high RCS if the remaining noise is ugly but not vector-bearing. The product boundary is: ContextSpectre observes session health over time, while NeuroRouter preserves the live request vector before the model sees it.