How to analyze DeepSeek Harness context usage with dsh-context

Harness reports context as one number, and that number hides the composition. When a window fills, the cause is usually not the conversation itself. It is a large tool result, a verbose plugin's schema, or a skill's injected documentation. The plugin's job is to make that composition visible without leaving the web UI, which is where the rest of your session work already happens.

dsh-context is a TypeScript plugin, licensed Apache-2.0, with about 3,700 GitHub stars and version 0.77.0 on npm as of October 27, 2026. The project lives at github.com/bowenliang123/dsh-context. Context stops being a single percentage and becomes an object you can inspect at request level, category level, file level, and agent level.

You can reach the same data five ways. The Context Insights page in the sidebar covers all sessions. The Context tab inside a session covers that session, and the Fleet tab covers the whole agent family. Typing /context in chat opens an overlay, and a settings card controls where the panel sits and how granular it is.

Install the plugin from the Harness command line:

Updates use update dsh-context@latest, and dsh web starts the interface. There is no compile step and no restart. Refreshing the page is enough.

Compatibility is the one prerequisite. The plugin reads the V4 session log format. The 0.77.0 package metadata lists @deepseek-ai/dsh 0.2.0-rc.2 and 0.2.1-rc.2 as compatible; earlier releases also documented 0.1.7-rc.2. Below the supported floor the plugin neither crashes nor shows an empty table. It registers fallback units that report zero and displays an upgrade notice. When the probe cannot detect a version at all, the plugin takes the normal path, on the reasoning that a failed probe should not blank out a deployment that works.

It hooks the projection registry instead. dsh-context intercepts nothing and reads no database. The host half is an ordinary Cordis plugin on the Node side; the client half is a browser bundle inside the web UI. The host half registers three projection units on ctx.sessionProjections, a timeline, request headers, and an activity ledger, and Harness pushes the computed values to the browser.

Each committed session/event runs apply(state, event) once. The framework compares state with Object.is and pushes only when the reference changes, so an event the plugin does not care about must return the same object it received. Returning anything else re-triggers the entire change stream. State also has to be plain JSON, because it feeds a checkpoint cache.

The cost of this design is defensive code throughout. The registry has no error boundary, so a single throw inside a unit would freeze its pushes and leave the browser showing a spinner forever.

Both ends of every chart are anchored. Top-line occupancy and category shares read Harness's official contextPressure and contextBreakdown projections. They therefore always match the ring above the input box; you will never see the plugin report 47% while the input box says 52%.

The fine-grained split is estimated, using the same accounting as the Harness token meter: four characters per token, plus four for each content block, plus four for role framing. Images are priced separately through the vision model's pixel formula. The estimated numerator is then scaled against the official total, so the estimate sets the proportions and the official figure sets the scale.

Heavy work runs on demand, behind a gate. Pushing a full log to the browser is not viable: a session with ten thousand events decodes into an object graph of several hundred megabytes. The browser receives a thin header and pulls details per card when you open one. Every cold read decodes the entire log, so a global gate admits one read at a time and only while V8 heap usage stays below two-thirds of its limit. Under pressure the read is skipped, the card reports no data, and nothing errors out or blocks the interface.

The Context tab holds eight cards. The denominator for every figure is the current model's window, not a fixed value: models such as deepseek-flash and MiniMax-M3 expose 1M windows, and switching to a smaller window stretches the same conversation's bar immediately.

The composition bar answers a familiar complaint: you barely typed anything, and the window is full. In one observed session, tool results held 65% of the window while user messages held 0%. The two striped segments at the end are compaction reserve. They hold headroom plus the output window the next request needs, they stay out of the occupancy figure, and they cap what space remains.

The trend chart cuts by model request: one bar per request, not one per message. A tool result that returns fifty thousand words counts as one new message in message terms, and as a jump from, say, 30k to 80k tokens in request terms. The request view is the one that hits the ceiling. Compaction events get their own markers, so a bar that suddenly drops comes with its reason attached. The chart switches between Step and Turn views and between Total and Delta, and three lines of plain-language summary underneath cover what you said, what was added, and what the reply called. Clicking a line jumps to the matching message.

The browser splits every request into seven categories: system prompt, tool definitions, user messages, injected context, skill injections, assistant replies, and tool results. Skills get their own category on purpose. The available_skills catalog, the documentation a slash command pulls in, and anything a skill tool loads are all injections. Merging them into the other categories would make it impossible to answer why installing one skill raised the bill.

The tool source column is determined at runtime. Session logs record each tool's schema but not who registered it, so the plugin listens on Cordis's internal/get channel and captures the owner's name the moment a plugin reads the tools service. When that fails, it walks the call stack to the nearest package.json. MCP tools are labeled mcp:<server> directly. Once a few plugins have doubled your tool count, this column is the only place that answers where forty-odd tools came from.

File Activity lists which files the agent touched and groups them per file. Native tools, the Minimal preset's str_replace_editor, and calls nested inside PTC run_code all land in the same row.

Fleet draws one picture: the current agent, its parent, and every child agent as a network. The accounting matters more than the drawing. The main session's Context tab counts only its own usage, and what the sub-agents spent never appears there. Fleet is the only place where that total becomes visible.

Four situations come up again and again. Each maps to a specific card.

It only reads. Apart from the Prefix and Suffix fields in settings, which wrap every session's system prompt (sub-agents included), it will not slim your context. Seeing clearly and cutting down are different jobs.

The estimates are estimates. Category splits assume four characters per token, and the official numbers guarantee only the total. One example request showed an estimate of 104.5k against an actual of 108.5k, a 3.8% gap. That is precise enough to identify the dominant category and too loose for invoice reconciliation.

It serves dsh only. There is no OpenAI SDK adapter, no support for other harnesses, and no export interface. Where the session lives, the data lives.

The codebase is substantial. At version 0.74.0 it spanned 160 source files at 1.37 MB, of which the client bundle was about four fifths, plus 193 test files at 2.18 MB, larger than the source itself. For a tool whose numbers have to be right, that coverage is appropriate. The price is that contributing means a long reading investment first.