dsh-vorssaint 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rúben Garrido
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,150 @@
-# Temporary Holding Version
+# dsh-vorssaint
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm](https://img.shields.io/npm/v/dsh-vorssaint)](https://www.npmjs.com/package/dsh-vorssaint)
+[![ci](https://github.com/RGarrido03/dsh-vorssaint/actions/workflows/ci.yml/badge.svg)](https://github.com/RGarrido03/dsh-vorssaint/actions/workflows/ci.yml)
+
+Report [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)
+usage to [Vorssaint](https://vorssaint.com): token spend, live runs, models and
+projects, and — with your model prices — the API value that feeds the daily
+budget.
+
+Vorssaint already follows Claude, Codex, OpenCode and GitHub Copilot by reading
+their local session logs. DSH keeps its logs compressed and rotates them, so
+this plugin writes the small, stable JSONL feed that Vorssaint's DSH reader
+tails instead:
+
+```
+~/.vorssaint/agents/dsh/<session-id>.jsonl
+```
+
+The plugin starts reporting from the moment it loads; usage from recent
+sessions is imported from DSH's own logs on first run, so the current day and
+month are not empty after installing it.
+
+## Requirements
+
+- DeepSeek Harness `0.2.2-rc.1` or newer in the `0.2.x` line.
+- A Vorssaint build with DeepSeek Harness support (the `dsh` provider).
+- Node.js `22.15` or newer for backfill; without it the live feed still works.
+
+## Install
+
+```bash
+dsh plugin --profile web add dsh-vorssaint
+```
+
+Use `--profile desktop` when your app runs the desktop profile. From a local
+checkout, before the npm release:
+
+```bash
+dsh plugin --profile web add link:$PWD
+```
+
+Enable the bundle if the Plugin Manager did not (add `"dsh-vorssaint"` to
+`dsh.profile.bundles` in `~/.dsh/profiles/<profile>/package.json`), then
+**restart DSH**. The installer marks a new bundle as requiring a restart because
+the running host cannot pick up a plugin that is not in its live list.
+
+Finally, open Vorssaint → Settings → the AI page and switch **DeepSeek Harness**
+on. It is enabled by default like the other agents once the feature is
+installed.
+
+## Prices and the daily budget
+
+DSH reports tokens per response, not a price, and a gateway can report any
+model id it likes. The plugin therefore ships no prices: configure the rates
+you are actually billed, in USD per million tokens, keyed by the exact model id
+Vorssaint will show (the id DSH reports in `assistant/message`). Add a `*`
+entry as the fallback for ids you did not list.
+
+Add this to `~/.dsh/profiles/<profile>/cordis.patch.yml` (the file's existing
+entries stay):
+
+```yaml
+- id: vorssaint
+  config:
+    pricing:
+      "deepseek/deepseek-v4.1-flash":
+        input: 0.28
+        output: 0.42
+        cacheRead: 0.028
+        cacheWrite: 0.28
+      "*":
+        input: 1
+        output: 2
+```
+
+`cacheRead` and `cacheWrite` default to the input rate. Reasoning tokens are
+already part of output and are not billed twice. Without a price the feed still
+carries tokens, model, project and runs; only API value and the daily budget
+stay empty for those responses.
+
+Change the values to the rates on your provider's pricing page — the numbers
+above are a shape example, not a quote.
+
+## How it works
+
+1. The plugin listens to DSH's committed `session/event` stream.
+2. Every response that reports usage becomes one `usage` line with input,
+   cache-write, cache-read, output and reasoning tokens, the model id and the
+   provider route, plus `cost` when the model has a rate.
+3. Turn boundaries become `turn` lines, which Vorssaint shows as a live run.
+4. One file per session, append-only and serialized; the writer skips sequences
+   already on disk, so restarts and re-reads never double count. Vorssaint also
+   dedupes by the response id.
+5. On start, before buffered live events are written, the plugin imports the
+   usage already in DSH's session logs from the last `backfillDays` days. A
+   session whose feed is at least as new as its log is skipped, so a normal
+   restart costs nothing. A fork's inherited prefix is not billed again.
+
+The exact line schema, tolerances and golden lines are in
+[`docs/FEED.md`](docs/FEED.md).
+
+## Configuration
+
+| field | default | meaning |
+| --- | --- | --- |
+| `feedDir` | `~/.vorssaint/agents/dsh` | Where the feed is written. Vorssaint only reads the default path; change it only together with the app side. |
+| `pricing` | `{}` | USD per million tokens by exact model id; `*` is the fallback. |
+| `backfill` | `true` | Import usage already in recent DSH session logs on start. |
+| `backfillDays` | `30` | How far back to import. `0` disables the scan. |
+| `sessionsDir` | `$DSH_HOME/sessions`, else `~/.dsh/sessions` | DSH's session-log directory, for backfill. |
+
+Configuration is validated by the loader; invalid rates are dropped rather than
+guessed. The feed directory and files are created with `0700`/`0600`.
+
+## Privacy
+
+Only the fields in [`docs/FEED.md`](docs/FEED.md) are written: session id,
+working directory, timestamps, turn numbers, model/provider ids, token counts
+and the optional cost. No prompt text, tool arguments, model output, file
+contents or credentials ever enter the feed. Writes are fire-and-forget: a full
+disk or a closed permissions dialog is logged once and never blocks or fails an
+agent turn.
+
+## Troubleshooting
+
+- **No DeepSeek Harness entry in Vorssaint.** Update Vorssaint to a build with
+  the DSH provider, then enable it on the AI settings page.
+- **Plugin not loaded.** `dsh --profile web --dump-config | grep vorssaint`
+  should show the `vorssaint` row. If it does not, enable the bundle and restart
+  DSH.
+- **No data.** Check that `~/.vorssaint/agents/dsh` exists after a DSH turn. A
+  turn with no model response (for example, cancelled before the first step)
+  writes no usage line.
+- **Tokens but no budget.** Configure `pricing` (above).
+
+## Development
+
+```bash
+pnpm install
+pnpm check        # typecheck, build, unit tests
+```
+
+The tests cover the line mapping, cost rules, backfill parsing (including fork
+cuts and subagents), the append-only writer's restart behavior, and the package
+metadata the loader reads.
+
+## License
+
+MIT © Rúben Garrido

package/cordis.patch.yml

@@ -0,0 +1,17 @@
+# dsh-vorssaint bundle layer.
+# One plugin row: turns the DSH session event stream into the JSONL usage feed
+# Vorssaint reads at ~/.vorssaint/agents/dsh.
+- insert:
+    - id: vorssaint
+      name: "dsh-vorssaint"
+      config:
+        # Vorssaint only reads the default feed directory; override it only
+        # together with the app side. Prices are USD per million tokens, keyed
+        # by exact DSH model id (`*` is the fallback):
+        #
+        # pricing:
+        #   "deepseek/deepseek-v4.1-flash": { input: 0.28, output: 0.42 }
+        #
+        # Without a price the feed still reports tokens, model and runs; only
+        # the API-value and daily-budget figures stay empty.
+        backfill: true

package/docs/FEED.md

@@ -0,0 +1,148 @@
+# DSH usage feed — contract v1
+
+The `dsh-vorssaint` DSH plugin writes one JSONL file per DeepSeek Harness
+session. Vorssaint's `DSHReader` tails those files to report usage, API value
+and live runs for the DeepSeek Harness provider.
+
+The plugin is the only writer; Vorssaint is the only reader. The contract is
+versioned with the `v` field on every line and only changes with a new major
+version of the plugin.
+
+## Location
+
+```
+~/.vorssaint/agents/dsh/<session-id>.jsonl
+```
+
+* The directory is created on demand, mode `0700`; files are mode `0600`.
+  Existing paths are tightened to the same modes on first use.
+* `<session-id>` is the DSH session id, with every character outside
+  `[A-Za-z0-9._-]` replaced by `_`.
+* Files are UTF-8, one JSON object per line, `\n` terminated. A torn final
+  line (no trailing newline) is ignored by the reader and removed by the
+  writer the next time it opens the file.
+* The directory can be overridden in the plugin config (`feedDir`), but
+  Vorssaint only reads this default path.
+
+## Lines
+
+Every line is an object with `v` (always `1`) and `type`. Times are epoch
+**milliseconds**. Unknown fields and unknown line types are ignored by the
+reader. The writer adds `seq` (the DSH event sequence) to every line it can;
+it uses it to skip replayed events and Vorssaint ignores it.
+
+### `session`
+
+Written first in a file. A restart appends to the existing file instead of
+rewriting it, so the header normally appears once.
+
+```json
+{"v":1,"type":"session","session":"session-7fe88e4c-4773-4582-ab38-d5b56f942811","ts":1793850692328,"cwd":"/Users/ruben/dsh-plugins","preset":"standard"}
+```
+
+| field | type | meaning |
+|---|---|---|
+| `session` | string | DSH session id |
+| `ts` | number | `SessionHeader.createdAt` |
+| `cwd` | string, optional | session working directory; the reader derives the project name from its last path component |
+| `parent` | string, optional | the session this one was created from, informational. DSH also records it for ordinary forks, so it does **not** mean "subagent". |
+| `subagent` | `true`, optional | present only when DSH's `SessionHeader.origin` is `subagent`; the reader then counts usage but shows no live run |
+| `preset` | string, optional | DSH agent preset at creation |
+
+### `turn`
+
+```json
+{"v":1,"type":"turn","ts":1793850830395,"turn":1,"phase":"start","seq":5}
+{"v":1,"type":"turn","ts":1793850866520,"turn":1,"phase":"end","completed":true,"seq":12}
+```
+
+| field | type | meaning |
+|---|---|---|
+| `ts` | number | DSH event time |
+| `turn` | integer | DSH turn number |
+| `phase` | `"start"` or `"end"` | |
+| `completed` | boolean, on `end` | `true` when the turn ended normally: reason `completed` or `max-tokens`; `false` for `aborted`, `interrupted`, `blocked`, `error`, `forked` |
+| `seq` | integer, optional | the DSH event sequence, present on every turn line the writer emits |
+
+Turn lines in a subagent session (`subagent: true`) are ignored by the reader:
+the subagent's work is part of the run it serves. Its usage is still counted,
+but as its own session — it is not folded into the parent's live run, so a
+subagent working while the parent waits does not grow the parent's run. A
+session that merely has a `parent` (an ordinary fork) keeps its turn lines.
+
+### `usage`
+
+One line per assembled model response that reported usage. This is the billing
+record.
+
+```json
+{"v":1,"type":"usage","ts":1793850842900,"turn":1,"step":2,"seq":20,"request":"eb7abe7f-9bfe-4df1-b072-4c365a8112a5","model":"deepseek/deepseek-v4.1-flash","provider":"commandcode","tokens":{"input":4819,"cacheWrite":0,"cacheRead":77568,"output":339,"reasoning":78},"cost":0.0004}
+```
+
+| field | type | meaning |
+|---|---|---|
+| `ts` | number | DSH event time |
+| `turn`, `step` | integer | position in the session (informational) |
+| `seq` | integer, optional | DSH event sequence; used by the writer, ignored by the reader |
+| `request` | string, optional | assistant message id; it forms the reader's dedupe key (`dsh:` + id) |
+| `model` | string | model id exactly as the provider route reported it |
+| `provider` | string, optional | DSH provider route (informational) |
+| `tokens.input` | integer | prompt tokens that missed the cache |
+| `tokens.cacheWrite` | integer | prompt tokens written to the cache |
+| `tokens.cacheRead` | integer | prompt tokens served from the cache |
+| `tokens.output` | integer | completion tokens; includes reasoning tokens |
+| `tokens.reasoning` | integer | reasoning tokens included in `output` |
+| `cost` | number, optional | API list value of this response in US dollars, when the plugin has a price for the model; omitted when unknown |
+
+## Reader semantics (Vorssaint `DSHReader`)
+
+* `session` → adopt `session`, compute `project` with the existing
+  `AgentLogParser.projectName(cwd)`, remember `subagent: true` (never infer it
+  from `parent`).
+* `turn` `start` (root session) → `.turnBegan(ts)`.
+* `turn` `end` (root session) → `.turnEnded(ts, completed: completed, duration: nil)`.
+* `usage` → `.usage(key: "dsh:" + (request, or "<session>:<turn>:<step>:<unix-seconds>"
+  when the line has no request id),
+  record: AgentUsageRecord(provider: .dsh, date: ts, model: model,
+  project: state.project, session: state.session, tokens: tokens,
+  cost: cost, savings: 0, reportedCost: cost != nil), billable: AgentBillable(tokens: tokens))`.
+* Missing `tokens` fields default to 0; negative or non-finite values are
+  clamped to 0. A usage line with an empty `model` is ignored.
+* The reader tolerates a file that starts mid-session: absent metadata leaves
+  the session/project empty and only usage is counted.
+* Vorssaint's store dedupes `usage` records by `key`, so the same response
+  written twice never double counts. `turn` lines have no key: a re-read can
+  replay a turn boundary, which the store's idempotence rules absorb.
+* `DSHReader.readsFullHistoryFirst` is `false`.
+
+## Golden lines
+
+```json
+{"v":1,"type":"session","session":"s-dsh","ts":1790088000000,"cwd":"/Users/me/code/app","preset":"standard"}
+{"v":1,"type":"turn","ts":1790088000000,"turn":1,"phase":"start","seq":0}
+{"v":1,"type":"usage","ts":1790088010000,"turn":1,"step":1,"request":"m1","model":"deepseek/deepseek-v4.1-flash","provider":"commandcode","tokens":{"input":100,"cacheWrite":20,"cacheRead":300,"output":40,"reasoning":10},"cost":0.001}
+{"v":1,"type":"turn","ts":1790088020000,"turn":1,"phase":"end","completed":true,"seq":3}
+```
+
+```json
+{"v":1,"type":"session","session":"s-sub","ts":1790088000000,"cwd":"/Users/me/code/app","parent":"s-dsh","subagent":true}
+{"v":1,"type":"turn","ts":1790088000000,"turn":1,"phase":"start","seq":0}
+{"v":1,"type":"usage","ts":1790088010000,"turn":1,"step":1,"request":"m2","model":"deepseek/deepseek-v4.1-flash","tokens":{"input":10,"output":5}}
+```
+
+The subagent file's usage is counted; its turn lines produce no live runs.
+
+## Writer-side behavior worth knowing
+
+* **Backfill.** On start the plugin reads `session*.jsonl.zstd` under the DSH
+  sessions directory for the last `backfillDays` days (default 30) and writes
+  the usage/turn lines already present. For a seeded (forked) session it skips
+  every event up to and including the `session/end-seed` marker whose
+  `inherited` is `true`; pre-v1 logs, which have no such marker, fall back to
+  the header's `seedLength`. Forked history is therefore not billed twice.
+* **Live.** Lines are appended as the session commits them. Writes are queued
+  per file, so order inside a file is preserved.
+* **Restarts.** Existing files are appended to, not rewritten; a missing file
+  for a recent session is rebuilt from that session's log.
+* **Privacy.** Only the fields above are written. No prompt text, tool
+  arguments, model output or file paths beyond `cwd` ever enter the feed.

package/icon.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+  <rect x="2" y="2" width="60" height="60" rx="14" fill="#F4F7FF"/>
+  <g transform="translate(8 8) scale(2)" fill="#4D6BFE" fill-rule="evenodd"><path d="M23.748 4.482c-.254-.124-.364.113-.512.234-.051.039-.094.09-.137.136-.372.397-.806.657-1.373.626-.829-.046-1.537.214-2.163.848-.133-.782-.575-1.248-1.247-1.548-.352-.156-.708-.311-.955-.65-.172-.241-.219-.51-.305-.774-.055-.16-.11-.323-.293-.35-.2-.031-.278.136-.356.276-.313.572-.434 1.202-.422 1.84.027 1.436.633 2.58 1.838 3.393.137.093.172.187.129.323-.082.28-.18.552-.266.833-.055.179-.137.217-.329.14a5.526 5.526 0 01-1.736-1.18c-.857-.828-1.631-1.742-2.597-2.458a11.365 11.365 0 00-.689-.471c-.985-.957.13-1.743.388-1.836.27-.098.093-.432-.779-.428-.872.004-1.67.295-2.687.684a3.055 3.055 0 01-.465.137 9.597 9.597 0 00-2.883-.102c-1.885.21-3.39 1.102-4.497 2.623C.082 8.606-.231 10.684.152 12.85c.403 2.284 1.569 4.175 3.36 5.653 1.858 1.533 3.997 2.284 6.438 2.14 1.482-.085 3.133-.284 4.994-1.86.47.234.962.327 1.78.397.63.059 1.236-.03 1.705-.128.735-.156.684-.837.419-.961-2.155-1.004-1.682-.595-2.113-.926 1.096-1.296 2.746-2.642 3.392-7.003.05-.347.007-.565 0-.845-.004-.17.035-.237.23-.256a4.173 4.173 0 001.545-.475c1.396-.763 1.96-2.015 2.093-3.517.02-.23-.004-.467-.247-.588zM11.581 18c-2.089-1.642-3.102-2.183-3.52-2.16-.392.024-.321.471-.235.763.09.288.207.486.371.739.114.167.192.416-.113.603-.673.416-1.842-.14-1.897-.167-1.361-.802-2.5-1.86-3.301-3.307-.774-1.393-1.224-2.887-1.298-4.482-.02-.386.093-.522.477-.592a4.696 4.696 0 011.529-.039c2.132.312 3.946 1.265 5.468 2.774.868.86 1.525 1.887 2.202 2.891.72 1.066 1.494 2.082 2.48 2.914.348.292.625.514.891.677-.802.09-2.14.11-3.054-.614zm1-6.44a.306.306 0 01.415-.287.302.302 0 01.2.288.306.306 0 01-.31.307.303.303 0 01-.304-.308zm3.11 1.596c-.2.081-.399.151-.59.16a1.245 1.245 0 01-.798-.254c-.274-.23-.47-.358-.552-.758a1.73 1.73 0 01.016-.588c.07-.327-.008-.537-.239-.727-.187-.156-.426-.199-.688-.199a.559.559 0 01-.254-.078c-.11-.054-.2-.19-.114-.358.028-.054.16-.186.192-.21.356-.202.767-.136 1.146.016.352.144.618.408 1.001.782.391.451.462.576.685.914.176.265.336.537.445.848.067.195-.019.354-.25.452z"></path></g>
+</svg>

package/lib/backfill.js

@@ -0,0 +1,222 @@
+/**
+ * Import the usage already in DSH's own session logs, so a fresh install
+ * reports the current day (or month) instead of starting from zero.
+ *
+ * DSH stores one zstd-compressed JSONL file per session below `sessions/`.
+ * The plugin reads the recent ones once at start, maps the same events the
+ * live listener sees, and hands them to the feed writer. A log's inherited
+ * fork prefix ends at its `session/end-seed` marker with `inherited: true`;
+ * counting those events again would bill the parent's work twice, so they
+ * are skipped.
+ *
+ * Decompression is optional: Node gained `zstdDecompressSync` in 22.15, and
+ * a host that predates it simply gets no backfill.
+ *
+ * @module dsh-vorssaint/backfill
+ */
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
+import * as zlib from 'node:zlib';
+import { feedEntriesForEvent, feedFileName } from './feed.js';
+/** DSH session logs, whatever the format generation in their name. */
+const SESSION_LOG = /^session.*\.jsonl\.zstd$/;
+/** A session log larger than this is skipped rather than held in memory. */
+const MAX_LOG_BYTES = 64 * 1024 * 1024;
+const INTERESTING = ['"turn/start"', '"turn/end"', '"assistant/message"'];
+const END_SEED = '"session/end-seed"';
+const zstdDecompressSync = zlib.zstdDecompressSync;
+/**
+ * Session logs under `sessionsDir` touched since `sinceMs`, newest first.
+ * @param sessionsDir - DSH's sessions directory.
+ * @param sinceMs - only files modified at or after now minus this.
+ * @returns absolute log paths; empty when the directory is missing.
+ */
+export async function discoverSessionLogs(sessionsDir, sinceMs) {
+    let entries;
+    try {
+        entries = await readdir(sessionsDir, { recursive: true, withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const cutoff = Date.now() - sinceMs;
+    const files = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !SESSION_LOG.test(entry.name))
+            continue;
+        const path = join(entry.parentPath, entry.name);
+        try {
+            const info = await stat(path);
+            if (info.size === 0 || info.size > MAX_LOG_BYTES || info.mtimeMs < cutoff)
+                continue;
+            files.push({ path, modified: info.mtimeMs });
+        }
+        catch {
+            // A log removed between the listing and the stat is simply gone.
+        }
+    }
+    files.sort((left, right) => right.modified - left.modified);
+    return files.map((file) => file.path);
+}
+/**
+ * Every recent session's feed entries, one session at a time.
+ * @param sessionsDir - DSH's sessions directory.
+ * @param options - window, rates, and the feed directory used to skip
+ *   sessions already captured live.
+ */
+export async function* backfillSessions(sessionsDir, options) {
+    const decompress = options.decompress ?? zstdDecompressSync;
+    if (decompress === undefined)
+        return;
+    for (const path of await discoverSessionLogs(sessionsDir, options.sinceMs)) {
+        try {
+            if (options.feedDir !== undefined && (await feedCoversLog(path, options.feedDir)))
+                continue;
+            const text = decompress(await readFile(path)).toString('utf8');
+            const parsed = parseSessionLog(text, options.pricing);
+            if (parsed !== undefined && parsed.entries.length > 0)
+                yield parsed;
+        }
+        catch {
+            // A log being written, or one in a format this reader does not know,
+            // is not worth failing the plugin over: live usage still gets through.
+        }
+    }
+}
+/**
+ * Map one session log's text to its identity and feed entries.
+ * @param text - decompressed JSONL.
+ * @param pricing - configured model rates.
+ * @returns the session, or undefined when the log does not start with a
+ *   session header this reader understands.
+ */
+export function parseSessionLog(text, pricing) {
+    const rows = text.split('\n');
+    const header = firstHeader(rows);
+    if (header === undefined)
+        return undefined;
+    const identity = {
+        session: header.id,
+        ts: header.createdAt,
+        ...(header.cwd === undefined ? {} : { cwd: header.cwd }),
+        ...(header.parentSession === undefined ? {} : { parent: header.parentSession }),
+        ...(header.origin === 'subagent' ? { subagent: true } : {}),
+        ...(header.agentPreset === undefined ? {} : { preset: header.agentPreset }),
+    };
+    // Older formats (v0) predate the tagged fork marker and only carry the
+    // inherited prefix length in the header. Without this cut, a fork written
+    // by an old DSH would bill its parent's history again.
+    const inherited = Math.max(inheritedCut(rows), seedCut(header));
+    const entries = [];
+    let lastSeq = inherited;
+    for (const row of rows) {
+        if (!INTERESTING.some((needle) => row.includes(needle)))
+            continue;
+        const event = eventOf(row);
+        if (event === undefined || event.seq <= lastSeq)
+            continue;
+        lastSeq = event.seq;
+        entries.push(...feedEntriesForEvent(event, pricing));
+    }
+    return { identity, entries };
+}
+/**
+ * Whether a session's feed was written at or after its log's last change.
+ * When it was, live capture already holds the latest event and decompressing
+ * the whole log again would only replay it.
+ */
+async function feedCoversLog(logPath, feedDir) {
+    try {
+        const [feed, log] = await Promise.all([
+            stat(join(feedDir, feedFileName(basename(dirname(logPath))))),
+            stat(logPath),
+        ]);
+        // A log flushed after its feed append is re-read rather than skipped;
+        // the writer's sequence filter makes that cheap for the events it holds.
+        return feed.mtimeMs >= log.mtimeMs;
+    }
+    catch {
+        return false;
+    }
+}
+function firstHeader(rows) {
+    const first = rows.find((row) => row.trim() !== '');
+    if (first === undefined)
+        return undefined;
+    const parsed = json(first);
+    if (parsed === undefined || parsed.type !== 'session')
+        return undefined;
+    const id = parsed.id;
+    const createdAt = parsed.createdAt;
+    if (typeof id !== 'string' || id === '' || typeof createdAt !== 'number' || !Number.isFinite(createdAt)) {
+        return undefined;
+    }
+    return {
+        id,
+        createdAt,
+        ...(typeof parsed.cwd === 'string' && parsed.cwd !== '' ? { cwd: parsed.cwd } : {}),
+        ...(typeof parsed.parentSession === 'string' && parsed.parentSession !== ''
+            ? { parentSession: parsed.parentSession }
+            : {}),
+        ...(typeof parsed.origin === 'string' && parsed.origin !== '' ? { origin: parsed.origin } : {}),
+        ...(typeof parsed.agentPreset === 'string' && parsed.agentPreset !== ''
+            ? { agentPreset: parsed.agentPreset }
+            : {}),
+        ...(typeof parsed.seedLength === 'number' && Number.isSafeInteger(parsed.seedLength) && parsed.seedLength > 0
+            ? { seedLength: parsed.seedLength }
+            : {}),
+    };
+}
+/**
+ * The last inherited sequence of a pre-v1 seeded log, which wrote the prefix
+ * length (`seedLength`) instead of an end-seed marker. The prefix occupies
+ * sequences 0..seedLength-1.
+ */
+function seedCut(header) {
+    return header.seedLength === undefined ? -1 : header.seedLength - 1;
+}
+/** The sequence through which a log is a copy of another session's history. */
+function inheritedCut(rows) {
+    let cut = -1;
+    for (const row of rows) {
+        if (!row.includes(END_SEED))
+            continue;
+        const parsed = json(row);
+        if (parsed === undefined || parsed.type !== 'session/end-seed')
+            continue;
+        const data = record(parsed.data);
+        if (data?.inherited !== true)
+            continue;
+        const seq = parsed.seq;
+        if (typeof seq === 'number' && Number.isSafeInteger(seq) && seq > cut)
+            cut = seq;
+    }
+    return cut;
+}
+function eventOf(row) {
+    const parsed = json(row);
+    if (parsed === undefined)
+        return undefined;
+    const type = parsed.type;
+    const seq = parsed.seq;
+    const time = parsed.time;
+    if (typeof type !== 'string' || typeof seq !== 'number' || typeof time !== 'number')
+        return undefined;
+    if (!Number.isSafeInteger(seq) || seq < 0 || !Number.isFinite(time))
+        return undefined;
+    return { type, seq, time, data: parsed.data };
+}
+function json(row) {
+    try {
+        const parsed = JSON.parse(row);
+        return record(parsed);
+    }
+    catch {
+        return undefined;
+    }
+}
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}

package/lib/feed.js

@@ -0,0 +1,329 @@
+/**
+ * The Vorssaint usage feed: line builders and an append-only writer.
+ *
+ * One file per DSH session under the feed directory. The contract lives in
+ * `docs/FEED.md`; this module is the only writer of it.
+ *
+ * @module dsh-vorssaint/feed
+ */
+import { appendFile, chmod, mkdir, open, stat, truncate, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { costOf, resolveRate } from './pricing.js';
+/** Contract version written on every line. */
+export const FEED_VERSION = 1;
+/**
+ * The feed identity of a live session.
+ * @param session - the DSH session.
+ * @returns its id and creation metadata.
+ */
+export function identityOf(session) {
+    const header = session.header;
+    return {
+        session: String(header.id),
+        ts: header.createdAt,
+        ...(header.cwd === undefined ? {} : { cwd: header.cwd }),
+        ...(header.parentSession === undefined ? {} : { parent: header.parentSession }),
+        ...(header.origin === 'subagent' ? { subagent: true } : {}),
+        ...(header.agentPreset === undefined ? {} : { preset: header.agentPreset }),
+    };
+}
+/**
+ * The `session` line that opens a feed file.
+ * @param identity - the session it describes.
+ * @returns serialized line.
+ */
+export function sessionLine(identity) {
+    const line = {
+        v: FEED_VERSION,
+        type: 'session',
+        session: identity.session,
+        ts: identity.ts,
+    };
+    if (identity.cwd !== undefined && identity.cwd !== '')
+        line.cwd = identity.cwd;
+    if (typeof identity.parent === 'string' && identity.parent !== '')
+        line.parent = identity.parent;
+    if (identity.subagent === true)
+        line.subagent = true;
+    if (identity.preset !== undefined && identity.preset !== '')
+        line.preset = identity.preset;
+    return JSON.stringify(line);
+}
+/**
+ * The feed lines one committed session event produces.
+ * @param event - a committed DSH session event.
+ * @param pricing - configured model rates.
+ * @returns zero or more entries; empty for events Vorssaint does not read.
+ */
+export function feedEntriesForEvent(event, pricing) {
+    if (!Number.isSafeInteger(event.seq) || event.seq < 0 || !Number.isFinite(event.time))
+        return [];
+    switch (event.type) {
+        case 'turn/start': {
+            const turn = integer(record(event.data)?.turn);
+            if (turn === undefined)
+                return [];
+            return [{ seq: event.seq, line: turnLine(event.time, turn, 'start', event.seq) }];
+        }
+        case 'turn/end': {
+            const turn = integer(record(event.data)?.turn);
+            if (turn === undefined)
+                return [];
+            const reason = record(record(event.data)?.reason);
+            const kind = typeof reason?.kind === 'string' ? reason.kind : '';
+            // A max-tokens stop is how the model ends a turn normally when it runs
+            // out of room; only aborts, errors and interruptions are unfinished.
+            const completed = kind === 'completed' || kind === 'max-tokens';
+            return [{ seq: event.seq, line: turnLine(event.time, turn, 'end', event.seq, completed) }];
+        }
+        case 'assistant/message': {
+            const data = record(event.data);
+            if (data === undefined)
+                return [];
+            const usage = record(data.usage);
+            const message = record(data.message);
+            const source = record(message?.source);
+            const model = typeof source?.model === 'string' ? source.model : '';
+            // With no usage the provider billed nothing reportable; with no model
+            // the record cannot be attributed, and Vorssaint skips those as well.
+            if (usage === undefined || model === '')
+                return [];
+            const tokens = {
+                input: count(usage.inputTokens),
+                cacheWrite: count(usage.cacheWriteTokens),
+                cacheRead: count(usage.cacheReadTokens),
+                output: count(usage.outputTokens),
+                reasoning: count(usage.reasoningTokens),
+            };
+            const row = {
+                v: FEED_VERSION,
+                type: 'usage',
+                ts: event.time,
+                seq: event.seq,
+            };
+            const turn = integer(data.turn);
+            const step = integer(data.step);
+            if (turn !== undefined)
+                row.turn = turn;
+            if (step !== undefined)
+                row.step = step;
+            if (typeof message?.id === 'string' && message.id !== '')
+                row.request = message.id;
+            row.model = model;
+            if (typeof source?.provider === 'string' && source.provider !== '')
+                row.provider = source.provider;
+            row.tokens = tokens;
+            const rate = resolveRate(pricing, model);
+            const cost = costOf(rate, tokens);
+            if (cost !== undefined)
+                row.cost = cost;
+            return [{ seq: event.seq, line: JSON.stringify(row) }];
+        }
+        default:
+            return [];
+    }
+}
+/**
+ * An append-only feed writer, one chain per session file.
+ *
+ * Appends are serialized so lines keep DSH's event order, and the writer skips
+ * sequences already on disk, which keeps a restart or a re-read from writing
+ * the same response twice. Vorssaint also dedupes usage by the response id, so
+ * a torn last line is at worst replayed, never double counted.
+ *
+ * Failures are swallowed after one warning: a read-only home directory or a
+ * full disk must never fail, block or delay an agent turn.
+ */
+export class FeedWriter {
+    dir;
+    pricing;
+    log;
+    files = new Map();
+    opening = new Map();
+    directory;
+    warned = false;
+    constructor(dir, pricing, log) {
+        this.dir = dir;
+        this.pricing = pricing;
+        this.log = log;
+    }
+    /**
+     * Append the entries not already written for their session.
+     * @param identity - the session the entries belong to.
+     * @param entries - ordered entries; filtered by their sequence.
+     * @returns a promise that never rejects.
+     */
+    ingest(identity, entries) {
+        if (entries.length === 0)
+            return Promise.resolve();
+        return this.ensure(identity)
+            .then((state) => {
+            const fresh = entries.filter((entry) => entry.seq > state.lastSeq);
+            if (fresh.length === 0)
+                return;
+            // Advancing before the append resolves keeps a burst of events from
+            // queueing the same sequence twice; a failed append loses that line
+            // rather than replaying older ones on every later event.
+            state.lastSeq = fresh[fresh.length - 1].seq;
+            const text = fresh.map((entry) => entry.line).join('\n') + '\n';
+            state.chain = state.chain
+                .then(() => appendFile(state.path, text, { mode: 0o600 }))
+                .catch((error) => {
+                this.warn(`could not append usage to ${state.path}: ${describe(error)}`);
+            });
+            return state.chain;
+        })
+            .catch((error) => {
+            // The directory promise is cached; clear it so a fixed home directory
+            // is retried by the next event instead of replaying this failure.
+            this.directory = undefined;
+            this.warn(`could not open the usage feed at ${this.dir}: ${describe(error)}`);
+        });
+    }
+    /** Wait for every in-flight open and queued append; called on unload. */
+    async close() {
+        await Promise.allSettled([...this.opening.values()]);
+        await Promise.allSettled([...this.files.values()].map((state) => state.chain));
+    }
+    ensure(identity) {
+        const existing = this.files.get(identity.session);
+        if (existing !== undefined)
+            return Promise.resolve(existing);
+        const opening = this.opening.get(identity.session);
+        if (opening !== undefined)
+            return opening;
+        const created = this.open(identity).finally(() => this.opening.delete(identity.session));
+        this.opening.set(identity.session, created);
+        return created;
+    }
+    async open(identity) {
+        await this.ensureDirectory();
+        const path = join(this.dir, feedFileName(identity.session));
+        let size = 0;
+        try {
+            size = (await stat(path)).size;
+        }
+        catch {
+            size = 0;
+        }
+        // A torn last line from an earlier crash would otherwise merge with the
+        // next record and make both unreadable. Cut it back to the last newline.
+        if (size > 0) {
+            const complete = await completeLength(path, size);
+            if (complete < size) {
+                try {
+                    await truncate(path, complete);
+                    size = complete;
+                }
+                catch {
+                    // Left in place: the next append starts a new line anyway.
+                }
+            }
+        }
+        const lastSeq = size > 0 ? await lastWrittenSeq(path) : -1;
+        const state = { path, lastSeq, chain: Promise.resolve() };
+        if (size === 0) {
+            state.chain = writeFile(path, sessionLine(identity) + '\n', { mode: 0o600 }).catch((error) => {
+                this.warn(`could not open the usage feed at ${path}: ${describe(error)}`);
+            });
+        }
+        state.chain = state.chain.then(() => chmod(path, 0o600).catch(() => undefined));
+        this.files.set(identity.session, state);
+        return state;
+    }
+    ensureDirectory() {
+        this.directory ??= mkdir(this.dir, { recursive: true, mode: 0o700 })
+            .then(() => chmod(this.dir, 0o700))
+            .catch((error) => {
+            // The caller clears this cached failure; report it once here.
+            this.warn(`could not create the usage feed directory ${this.dir}: ${describe(error)}`);
+            throw error;
+        });
+        return this.directory;
+    }
+    warn(message) {
+        if (this.warned)
+            return;
+        this.warned = true;
+        this.log?.warn(`vorssaint: ${message}`);
+    }
+}
+/**
+ * One file name for a session id. DSH ids are already safe; sanitizing keeps
+ * a hand-made or future id from escaping the feed directory.
+ */
+export function feedFileName(session) {
+    const safe = session.replace(/[^A-Za-z0-9._-]/g, '_').replace(/^\.+/, '_');
+    return `${safe === '' ? 'session' : safe}.jsonl`;
+}
+/** The length of a file up to and including its last newline. */
+async function completeLength(path, size) {
+    const handle = await open(path, 'r');
+    try {
+        let start = Math.max(0, size - 64 * 1024);
+        for (;;) {
+            const length = size - start;
+            const buffer = Buffer.alloc(length);
+            await handle.read(buffer, 0, length, start);
+            const newline = buffer.lastIndexOf(0x0a);
+            if (newline !== -1)
+                return start + newline + 1;
+            if (start === 0)
+                return 0;
+            start = Math.max(0, start - 64 * 1024);
+        }
+    }
+    finally {
+        await handle.close();
+    }
+}
+/**
+ * The highest sequence already in a feed file, read from its last complete
+ * line. -1 when the file has none (new file, or only the session header).
+ */
+async function lastWrittenSeq(path) {
+    let handle;
+    try {
+        handle = await open(path, 'r');
+        const size = (await handle.stat()).size;
+        const length = Math.min(size, 64 * 1024);
+        const buffer = Buffer.alloc(length);
+        await handle.read(buffer, 0, length, size - length);
+        let body = buffer.toString('utf8');
+        // A torn final line is not trusted: read the line before it.
+        body = body.endsWith('\n') ? body.slice(0, -1) : body.slice(0, body.lastIndexOf('\n'));
+        if (body === '')
+            return -1;
+        const start = body.lastIndexOf('\n');
+        const line = start === -1 ? body : body.slice(start + 1);
+        const parsed = record(JSON.parse(line));
+        const seq = integer(parsed?.seq);
+        return seq ?? -1;
+    }
+    catch {
+        return -1;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+function turnLine(ts, turn, phase, seq, completed) {
+    const line = { v: FEED_VERSION, type: 'turn', ts, turn, phase, seq };
+    if (phase === 'end')
+        line.completed = completed === true;
+    return JSON.stringify(line);
+}
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function integer(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+function count(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? Math.trunc(value) : 0;
+}
+function describe(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/lib/index.js

@@ -0,0 +1,205 @@
+/**
+ * dsh-vorssaint — report DeepSeek Harness usage, API value and live runs to
+ * Vorssaint.
+ *
+ * Vorssaint follows coding agents by reading their local session logs. DSH
+ * compresses and rotates its own logs, so this plugin writes a small,
+ * stable JSONL feed that Vorssaint's DSH reader tails instead:
+ *
+ *   ~/.vorssaint/agents/dsh/<session-id>.jsonl
+ *
+ * The feed carries token counts per model response, the turn boundaries the
+ * island shows as a live run, and — when the user configured model rates —
+ * the response's API list value. It never carries prompt text, tool
+ * arguments or model output.
+ *
+ * Usage produced while the plugin was not loaded is recovered once at start
+ * from DSH's recent session logs (`backfill`), so budgets do not reset on a
+ * plugin install or a DSH upgrade.
+ *
+ * @module dsh-vorssaint
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import z from '@deepseek-ai/schemastery';
+import { backfillSessions } from './backfill.js';
+import { FeedWriter, feedEntriesForEvent, identityOf } from './feed.js';
+/** Plugin name; also the loader row id and logger name. */
+export const name = 'vorssaint';
+const DEFAULT_FEED_DIR = '~/.vorssaint/agents/dsh';
+const DEFAULT_BACKFILL_DAYS = 30;
+const MAX_BACKFILL_DAYS = 3650;
+const DAY_MS = 24 * 60 * 60 * 1000;
+/** One model's rates, in USD per million tokens. */
+const Rate = z.object({
+    input: z.number().min(0),
+    output: z.number().min(0),
+    cacheRead: z.number().min(0),
+    cacheWrite: z.number().min(0),
+});
+export const Config = z.object({
+    feedDir: z
+        .string()
+        .default(DEFAULT_FEED_DIR)
+        .description('Directory Vorssaint reads the usage feed from. Change only together with the app side.'),
+    pricing: z
+        .dict(Rate)
+        .default({})
+        .description('USD per million tokens, keyed by exact DSH model id; "*" is the fallback. ' +
+        'Without a price the feed reports tokens and runs but no API value.'),
+    backfill: z
+        .boolean()
+        .default(true)
+        .description('Import usage already in recent DSH session logs when the plugin starts.'),
+    backfillDays: z
+        .number()
+        .min(0)
+        .max(MAX_BACKFILL_DAYS)
+        .default(DEFAULT_BACKFILL_DAYS)
+        .description('How far back to import DSH session logs. 0 disables the scan.'),
+    sessionsDir: z
+        .string()
+        .default('')
+        .description('DSH sessions directory. Empty uses $DSH_HOME/sessions, or ~/.dsh/sessions.'),
+});
+/**
+ * Normalize the config the loader (or a direct mount in a test) supplies.
+ * @param raw - user configuration, possibly empty or partial.
+ * @returns usable settings with every default applied.
+ */
+export function resolveConfig(raw) {
+    const values = record(raw);
+    const feedDir = text(values?.feedDir) ?? DEFAULT_FEED_DIR;
+    const sessionsDir = text(values?.sessionsDir);
+    const days = values?.backfillDays;
+    return {
+        feedDir: expandHome(feedDir),
+        pricing: pricingOf(values?.pricing),
+        backfill: values?.backfill === undefined ? true : values.backfill === true,
+        backfillDays: typeof days === 'number' && Number.isFinite(days) && days >= 0
+            ? Math.min(Math.trunc(days), MAX_BACKFILL_DAYS)
+            : DEFAULT_BACKFILL_DAYS,
+        sessionsDir: expandHome(sessionsDir ?? defaultSessionsDir()),
+    };
+}
+/**
+ * Subscribe to committed session events and write the feed. The loader owns
+ * the fiber, so unloading the plugin stops every listener.
+ */
+export function apply(ctx, config) {
+    const settings = resolveConfig(config);
+    const logger = ctx.logger(name);
+    const writer = new FeedWriter(settings.feedDir, settings.pricing, logger);
+    // Backfill runs before any buffered live event is written, so a session's
+    // history lands in the file before its ongoing turns do.
+    let ready = !settings.backfill || settings.backfillDays === 0;
+    let disposed = false;
+    const pending = [];
+    const flush = async () => {
+        const items = pending.splice(0);
+        await Promise.all(items.map((item) => writer.ingest(item.identity, item.entries)));
+    };
+    ctx.on('session/event', (session, event) => {
+        if (disposed)
+            return;
+        try {
+            const entries = feedEntriesForEvent(event, settings.pricing);
+            if (entries.length === 0)
+                return;
+            const identity = identityOf(session);
+            if (ready)
+                void writer.ingest(identity, entries);
+            else
+                pending.push({ identity, entries });
+        }
+        catch (error) {
+            logger.warn(`could not record session usage: ${describe(error)}`);
+        }
+    });
+    if (!ready) {
+        void (async () => {
+            try {
+                for await (const item of backfillSessions(settings.sessionsDir, {
+                    sinceMs: settings.backfillDays * DAY_MS,
+                    pricing: settings.pricing,
+                    feedDir: settings.feedDir,
+                })) {
+                    if (disposed)
+                        return;
+                    await writer.ingest(item.identity, item.entries);
+                }
+            }
+            catch (error) {
+                logger.warn(`could not backfill usage from session logs: ${describe(error)}`);
+            }
+            finally {
+                if (!disposed) {
+                    ready = true;
+                    void flush();
+                }
+            }
+        })();
+    }
+    ctx.effect(() => async () => {
+        disposed = true;
+        ready = true;
+        await flush();
+        await writer.close();
+    });
+}
+function defaultSessionsDir() {
+    const home = process.env.DSH_HOME?.trim();
+    return join(home !== undefined && home !== '' ? expandHome(home) : join(homedir(), '.dsh'), 'sessions');
+}
+function expandHome(path) {
+    if (path === '~')
+        return homedir();
+    if (path.startsWith('~/') || path.startsWith('~\\'))
+        return join(homedir(), path.slice(2));
+    return path;
+}
+function pricingOf(value) {
+    const pricing = {};
+    const entries = record(value);
+    if (entries === undefined)
+        return pricing;
+    for (const [model, raw] of Object.entries(entries)) {
+        if (model === '')
+            continue;
+        const rate = rateOf(raw);
+        if (rate !== undefined)
+            pricing[model] = rate;
+    }
+    return pricing;
+}
+function rateOf(value) {
+    const raw = record(value);
+    if (raw === undefined)
+        return undefined;
+    const input = number(raw.input);
+    const output = number(raw.output);
+    if (input === undefined || output === undefined)
+        return undefined;
+    const rate = { input, output };
+    const cacheRead = number(raw.cacheRead);
+    const cacheWrite = number(raw.cacheWrite);
+    if (cacheRead !== undefined)
+        rate.cacheRead = cacheRead;
+    if (cacheWrite !== undefined)
+        rate.cacheWrite = cacheWrite;
+    return rate;
+}
+function number(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function text(value) {
+    return typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined;
+}
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function describe(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/lib/pricing.js

@@ -0,0 +1,42 @@
+/**
+ * What one response billed, and what the plugin charges for it.
+ *
+ * Vorssaint values a DSH session from the `cost` the plugin writes, because
+ * it has no DeepSeek price list of its own and DSH reports no price per call.
+ * The plugin therefore ships no rates: a user opts in with the `pricing`
+ * config, keyed by the exact model id the provider route reports (with `*`
+ * as a fallback). Without a rate the feed still carries tokens; cost stays
+ * absent rather than guessed.
+ *
+ * @module dsh-vorssaint/pricing
+ */
+const PER_MILLION = 1_000_000;
+/**
+ * The rate that prices one model.
+ * @param pricing - configured rates.
+ * @param model - exact model id from the assistant message.
+ * @returns the model's rate, the wildcard rate, or undefined.
+ */
+export function resolveRate(pricing, model) {
+    if (pricing === undefined || model === '')
+        return undefined;
+    return pricing[model] ?? pricing['*'];
+}
+/**
+ * The API list value of one response.
+ * @param rate - its model's rate, or undefined when unknown.
+ * @param tokens - the response's token counts.
+ * @returns US dollars, or undefined when the model has no rate.
+ */
+export function costOf(rate, tokens) {
+    if (rate === undefined)
+        return undefined;
+    const cacheRead = rate.cacheRead ?? rate.input;
+    const cacheWrite = rate.cacheWrite ?? rate.input;
+    const value = (tokens.input * rate.input +
+        tokens.cacheWrite * cacheWrite +
+        tokens.cacheRead * cacheRead +
+        tokens.output * rate.output) /
+        PER_MILLION;
+    return Number.isFinite(value) && value >= 0 ? value : undefined;
+}

package/package.json

@@ -1,6 +1,79 @@
 {
   "name": "dsh-vorssaint",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Report DeepSeek Harness usage, API value and live runs to Vorssaint.",
+  "icon": "./icon.svg",
+  "type": "module",
+  "main": "./lib/index.js",
+  "exports": {
+    ".": {
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "docs",
+    "cordis.patch.yml",
+    "icon.svg",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "pretest": "pnpm build",
+    "test": "node --test test/*.test.mjs",
+    "check": "pnpm typecheck && pnpm build && pnpm test",
+    "prepare": "tsc -p tsconfig.json",
+    "prepack": "tsc -p tsconfig.json"
+  },
+  "engines": {
+    "node": ">=22.15"
+  },
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "vorssaint",
+    "usage",
+    "tokens",
+    "budget",
+    "menubar"
+  ],
+  "license": "MIT",
+  "author": "Rúben Garrido",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RGarrido03/dsh-vorssaint.git"
+  },
+  "homepage": "https://github.com/RGarrido03/dsh-vorssaint#readme",
+  "bugs": {
+    "url": "https://github.com/RGarrido03/dsh-vorssaint/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "compatibility": {
+      "dshReleases": {
+        "0.2.2-rc.1": "compatible"
+      },
+      "dsh": "^0.2.2-rc.1"
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.0",
+    "@deepseek-ai/schemastery": "^3.18.0"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "4.1.0",
+    "@deepseek-ai/dsh-session": "0.2.2-rc.1",
+    "@deepseek-ai/schemastery": "3.19.0",
+    "@types/node": "^26.6.5",
+    "typescript": "^7.0.2"
+  }
+}