@sagmans/dsh-auto-compact 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sercan Sagman - ahmetsercansagman@gmail.com
+
+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

@@ -0,0 +1,175 @@
+# dsh-auto-compact
+
+A DeepSeek Harness compaction backend that adds an absolute token budget to the
+shipped window-ratio trigger. It condenses at a fixed price on large-window
+models, while every model whose window is already smaller than that budget keeps
+its proportional trigger.
+
+```
+trigger = min(thresholdTokens, floor(contextWindow x thresholdRatio))
+```
+
+Releases publish to npm as [`@sagmans/dsh-auto-compact`](https://www.npmjs.com/package/@sagmans/dsh-auto-compact); every release carries a provenance attestation built by the tag workflow, and no npm token is stored. The code is [MIT licensed](LICENSE).
+
+## Requirements
+
+- Node.js 24 LTS (verified with 24.20.0).
+- pnpm 11.21.0 for this repository.
+- A DeepSeek Harness install on the supported line: `>=0.1.5-rc.1 <0.1.6` (verified against `0.1.5-rc.2`). The plugin declares that range as a peer dependency, so a profile resolves the harness copy it already has rather than a second framework instance.
+
+## Configuration
+
+Every shipped setting keeps its meaning; this backend adds two fields and one
+per-route override.
+
+| Field | Default | Meaning |
+|---|---|---|
+| `thresholdTokens` | — | Absolute trigger budget in tokens. Omitted means the ratio trigger alone. |
+| `retainShare` | `0.2` | Retained tail as a fraction of the derived trigger, applied only when the budget is what triggers condensation. |
+| `modelPolicies[].thresholdTokens` | — | Budget for one exact `provider`/`model` route. |
+| `thresholdRatio`, `retainRatio`, `retainTokens`, `summarizationProvider`, `summarizationModel`, `maxTokens`, `compactionRetries`, `maxOverflowRetries`, `modelPolicies`, `auto` | shipped | Unchanged; see the shipped backend documentation. |
+
+```yaml
+- id: auto-compact
+  name: '@sagmans/dsh-auto-compact'
+  config:
+    thresholdTokens: 200000
+    modelPolicies:
+      - provider: opencode-go-session
+        model: deepseek-flash
+        thresholdTokens: 120000
+```
+
+## Trigger examples
+
+| Context window | `thresholdRatio` | `thresholdTokens` | Trigger |
+|---|---|---|---|
+| 1,000,000 | 0.8 | 200,000 | **200,000** (budget) |
+| 262,144 | 0.8 | 200,000 | **200,000** (budget) |
+| 131,072 | 0.8 | 200,000 | 104,857 (ratio) |
+| 1,000,000 | 0.8 | — | 800,000 (ratio only) |
+
+## Install
+
+The bundle patch disables the shipped `compaction-basic` row and inserts this
+backend in its place, so the profile keeps exactly one compaction service.
+
+```sh
+dsh plugin --profile tui add link:/path/to/dsh-auto-compact
+dsh --profile tui --dump-config | grep -A3 'id: auto-compact'
+```
+
+Profile-specific tuning belongs in `$DSH_HOME/profiles/<name>/cordis.patch.yml`,
+which the profile watches:
+
+```yaml
+- id: auto-compact
+  config:
+    thresholdTokens: 200000
+```
+
+Restart the profile after a bundle change. Tune the patch file afterwards
+without a restart.
+
+## Where the engine runs
+
+The TUI and Web bundles disable the host-plane compaction rows so that each
+agent preset owns an engine in its own realm. This bundle provides the service
+on the host plane, which serves every agent because an unscoped listener
+receives all agent events. A preset that still mounts the shipped backend keeps
+it as a later listener: that engine can only condense after this one already
+did, or at its own wider ratio trigger, so it stays inert.
+
+Two consequences are worth knowing:
+
+- The host plane mounts no tool-result pruner in those profiles, so
+  condensation here summarizes without the model-free prune pass. Insert a
+  `tool-result-pruner` row at the host plane if you want that pass.
+- A deployment that wants exactly one engine can instead copy the agent preset
+  it uses, point that copy's `compaction-basic` row at this package, and select
+  the copy as the default preset. The copy is a snapshot and drifts from the
+  shipped preset.
+
+## How it works
+
+The absolute budget cannot be expressed as a shipped setting, so the engine
+subclasses the shipped backend and overrides `compactIfNeeded` for the pressure
+trigger only:
+
+1. Read the durable route and the budget for it. Below the budget, delegate
+   unchanged and make no capacity lookup.
+2. Read the routed model's context window from the adapter.
+3. Derive the trigger and the retained tail, then run the shipped transaction
+   under that policy.
+
+The shipped engine resolves its policy from a frozen instance field, so the
+derived policy is placed on a per-call receiver that shares the engine's
+context and state. A field swap would leak between agents condensing
+concurrently on different routes.
+
+Provider-confirmed context overflow, `/compact`, and `auto: false` keep their
+shipped behaviour. Overflow recovery never consults a threshold.
+
+## Verification
+
+Unit tests cover the decision surface, including the boundary where the budget
+stops binding and the point where the derived trigger must carry the decision
+past the shipped ratio check.
+
+A controlled pair of real sessions proves the trigger end to end. Both runs used
+the same task, the same route, and a reported window of 1,000,000 tokens, where
+the shipped ratio trigger is 800,000:
+
+| Run | `thresholdTokens` | Compaction events |
+|---|---|---|
+| A | 8,000 | 4 starts, 3 summaries, 1 prune |
+| B | — | none |
+
+Reproduce it with a scratch profile:
+
+```sh
+dsh --profile autocompact-dogfood --from-default-profile headless --dump-config
+dsh plugin --profile autocompact-dogfood add link:/path/to/dsh-auto-compact
+# patch the profile with the route rows and a small thresholdTokens, then:
+cd /tmp/dsh-auto-compact-dogfood
+dsh --profile autocompact-dogfood "cat big-a.md big-b.md, then report the character count"
+zstd -dc ~/.dsh/sessions/--private-tmp-dsh-auto-compact-dogfood--/*/session.v3.jsonl.zstd \
+  | grep -oE '"type":"compaction/[a-z]+"' | sort | uniq -c
+```
+
+Remove `thresholdTokens` and the same run must report no compaction events.
+
+## Limits
+
+- The adapter must report a context window. A route without one keeps the
+  shipped warn-once failure and no capacity is guessed.
+- Token pressure comes from the shipped meter (four characters per token, with
+  provider usage when available), so a budget is as accurate as that meter.
+- Per-route overrides match exactly; there is no wildcard matcher.
+- A budget below the fixed request envelope (system prompt plus tool schemas)
+  cannot be satisfied. The shipped retry policy then warns and continues the
+  turn.
+
+## Development
+
+```sh
+pnpm install
+pnpm run check   # typecheck, unit tests, build, built-artifact tests, release guards, pack smoke
+```
+
+The profile loads `dist/index.js`, so rebuild and restart the profile after a
+source change.
+
+## Releasing
+
+Published artefacts carry a provenance attestation, which only a CI provider can issue, so releases ship from the tag workflow rather than a laptop.
+
+1. Bump `version` in `package.json`, land it on `main` through a reviewed PR, and wait for CI to pass on the merged SHA.
+2. Tag that SHA with a signed tag and push it. The tag ruleset admits repository admins only.
+3. [`.github/workflows/release.yml`](.github/workflows/release.yml) re-runs the checks and the package smoke; the publish job then waits for a maintainer's approval on the `npm-release` environment before it publishes with OIDC trusted publishing and automatic provenance.
+
+The workflow stores no npm token: the registry trusts `release.yml` on the `npm-release` environment, and [`scripts/npm/release.py`](scripts/npm/release.py) creates both the environment and that trust. The full runbook is [RELEASE.md](RELEASE.md).
+
+## License
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,18 @@
+# dsh-auto-compact — the shipped compaction engine, plus an absolute token cap.
+#
+# The base row is disabled rather than reconfigured: a patch replaces a row's
+# whole config, and the engine swap is what adds the absolute trigger. This
+# profile plane owns no `compaction` provider of its own (the TUI and Web
+# bundles disable the base row so each agent's preset can own one), so this row
+# provides the service without a realm conflict and serves preset-composed
+# agents through the unscoped host listener.
+- id: compaction-basic
+  disabled: true
+
+- insert:
+    - id: auto-compact
+      name: '@sagmans/dsh-auto-compact'
+      config:
+        # Condense at 200K tokens even on a much larger window; the 80% ratio
+        # keeps governing every model whose window falls below 250K.
+        thresholdTokens: 200000

package/dist/config.js

@@ -0,0 +1,91 @@
+/**
+ * Configuration vocabulary and load-time resolution for the absolute compaction
+ * budget.
+ * @module @sagmans/dsh-auto-compact/config
+ */
+import Schema from '@deepseek-ai/schemastery';
+import { BasicCompactionEngine } from '@deepseek-ai/dsh-compaction-basic';
+/** Tail share of the derived threshold used when no explicit share is configured. */
+export const DEFAULT_RETAIN_SHARE = 0.2;
+const thresholdTokensSchema = Schema.number().step(1).min(1);
+// Bounds only; the open lower bound stays with resolvers, which reject a zero
+// or negative share with a message naming the field.
+const retainShareSchema = Schema.number().min(0).max(1);
+/** Shipped schema dicts; composing from them keeps a new shipped field usable here. */
+const stockConfigDict = BasicCompactionEngine.Config.dict ?? {};
+const stockRouteDict = stockConfigDict.modelPolicies?.inner?.dict ?? {};
+/** One exact route override: every shipped field plus the absolute budget. */
+const routePolicySchema = Schema.object({
+    ...stockRouteDict,
+    thresholdTokens: thresholdTokensSchema,
+});
+/** Loader-validated plugin schema. */
+export const Config = Schema.object({
+    ...stockConfigDict,
+    thresholdTokens: thresholdTokensSchema,
+    retainShare: retainShareSchema,
+    modelPolicies: Schema.array(routePolicySchema),
+});
+/** Strip the plugin-only fields from one route override. */
+function stockRoutePolicy(policy) {
+    const { thresholdTokens: _thresholdTokens, ...stock } = policy;
+    return stock;
+}
+/**
+ * Reduce this plugin's configuration to the shipped engine's own vocabulary.
+ *
+ * The shipped resolver rejects unknown keys at the top level and inside every
+ * route override, so an absolute budget left in place would fail the plugin at
+ * load instead of being ignored.
+ *
+ * @param config - validated plugin configuration.
+ * @returns the configuration the shipped engine can resolve.
+ */
+export function toEngineConfig(config = {}) {
+    const { thresholdTokens: _thresholdTokens, retainShare: _retainShare, modelPolicies, ...stock } = config;
+    if (modelPolicies === undefined)
+        return stock;
+    return { ...stock, modelPolicies: modelPolicies.map(stockRoutePolicy) };
+}
+/** Key matching the shipped engine's exact provider/model route identity. */
+export function routeKey(provider, model) {
+    return `${provider}\u0000${model}`;
+}
+function assertCap(name, value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < 1) {
+        throw new Error(`${name} (${String(value)}) must be a positive integer`);
+    }
+    return value;
+}
+function assertRetainShare(value) {
+    if (value === undefined)
+        return DEFAULT_RETAIN_SHARE;
+    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0 || value > 1) {
+        throw new Error(`retainShare (${String(value)}) must be a number in (0, 1]`);
+    }
+    return value;
+}
+/**
+ * Validate the deployment's absolute budgets.
+ *
+ * Duplicate route overrides are rejected by the shipped resolver, which sees
+ * every override through {@link toEngineConfig}.
+ *
+ * @param config - plugin configuration, before or after schema normalization.
+ * @returns detached budget lookups.
+ */
+export function resolveCapPolicy(config = {}) {
+    const routeCaps = new Map();
+    for (const [index, policy] of (config.modelPolicies ?? []).entries()) {
+        const cap = assertCap(`modelPolicies[${index}].thresholdTokens`, policy.thresholdTokens);
+        if (cap !== undefined)
+            routeCaps.set(routeKey(policy.provider, policy.model), cap);
+    }
+    return {
+        defaultCap: assertCap('thresholdTokens', config.thresholdTokens),
+        routeCaps,
+        retainShare: assertRetainShare(config.retainShare),
+    };
+}

package/dist/index.js

@@ -0,0 +1,90 @@
+/**
+ * Absolute-budget compaction engine for the DeepSeek Harness.
+ *
+ * The shipped engine triggers on a fraction of the routed model's window. This
+ * backend keeps that policy and adds an absolute token budget, so a deployment
+ * can condense at a fixed price on large-window models while every smaller
+ * window keeps its ratio trigger.
+ * @module @sagmans/dsh-auto-compact
+ */
+import { BasicCompactionEngine } from '@deepseek-ai/dsh-compaction-basic';
+import { Config, resolveCapPolicy, routeKey, toEngineConfig } from "./config.js";
+import { decidePressurePolicy, routePolicyTerms } from "./policy.js";
+import { derivedConfig, findOverride, resolveContextWindow, routedTarget, withDerivedPolicy, } from "./view.js";
+export { Config, DEFAULT_RETAIN_SHARE, resolveCapPolicy, routeKey, toEngineConfig } from "./config.js";
+export { decidePressurePolicy, routePolicyTerms } from "./policy.js";
+/**
+ * Shipped compaction backend plus an absolute token budget.
+ *
+ * Every shipped setting keeps its meaning; `thresholdTokens` adds a cap on the
+ * trigger, and `retainShare` bounds the retained tail whenever that cap is what
+ * triggers compaction.
+ */
+export class AutoCompactEngine extends BasicCompactionEngine {
+    static Config = Config;
+    static inject = [...BasicCompactionEngine.inject];
+    /** Absolute-budget policy resolved at load. */
+    capPolicy;
+    /**
+     * @param ctx - context owning the LLM, token meter, and session services.
+     * @param config - plugin configuration; the shipped subset is forwarded as-is.
+     */
+    constructor(ctx, config = {}) {
+        super(ctx, toEngineConfig(config));
+        this.capPolicy = resolveCapPolicy(config);
+    }
+    /**
+     * Compact for step-boundary pressure or provider-confirmed overflow.
+     *
+     * Pressure runs under the derived absolute budget when one applies; every
+     * other trigger, and every route the budget does not bind, delegates to the
+     * shipped implementation unchanged.
+     *
+     * @param agent - agent whose latest durable routed request is measured.
+     * @param trigger - pressure or context-overflow.
+     * @param signal - live turn cancellation signal.
+     * @returns the compaction result, or `null` when nothing was needed.
+     */
+    async compactIfNeeded(agent, trigger, signal) {
+        const target = trigger === 'pressure' ? routedTarget(agent.session) : undefined;
+        const cap = target === undefined
+            ? undefined
+            : this.capPolicy.routeCaps.get(routeKey(target.provider, target.model))
+                ?? this.capPolicy.defaultCap;
+        const measured = cap === undefined ? 0 : this.ctx.tokenMeter.measure(agent.session).totalTokens;
+        // The derived trigger never exceeds the budget, so below it there is nothing
+        // to decide and no capacity lookup is worth making on every step.
+        if (target === undefined || cap === undefined || measured < cap) {
+            return super.compactIfNeeded(agent, trigger, signal);
+        }
+        // The shipped transaction resolves the same capacity again when it prices
+        // the span. That second lookup is accepted: it runs only on steps that
+        // already exceeded the budget, and the shipped signature exposes no seam to
+        // hand a resolved window through.
+        const contextWindow = await resolveContextWindow(this.ctx, target, signal);
+        if (contextWindow === undefined)
+            return super.compactIfNeeded(agent, trigger, signal);
+        const override = findOverride(this.config.modelPolicies, target);
+        const terms = routePolicyTerms(this.config, override, contextWindow);
+        const derived = decidePressurePolicy({
+            totalTokens: measured,
+            contextWindow,
+            thresholdTokens: cap,
+            thresholdRatio: terms.thresholdRatio,
+            retainTokens: terms.retainTokens,
+            retainShare: this.capPolicy.retainShare,
+        });
+        if (derived === undefined)
+            return super.compactIfNeeded(agent, trigger, signal);
+        this.ctx.logger.debug(`auto-compact: ${target.provider}/${target.model} pressure ${measured}, `
+            + `ratio trigger ${Math.floor(contextWindow * terms.thresholdRatio)} on window ${contextWindow}, `
+            + `absolute budget ${cap} -> threshold ${derived.thresholdTokens}, tail ${derived.retainTokens}`);
+        const result = await withDerivedPolicy(this, derivedConfig(this.config, override, derived), view => BasicCompactionEngine.prototype.compactIfNeeded.call(view, agent, trigger, signal));
+        if (result !== null) {
+            this.ctx.logger.info(`auto-compact: condensed at the absolute budget of ${derived.thresholdTokens} tokens `
+                + `(window ${contextWindow}, tail ${derived.retainTokens})`);
+        }
+        return result;
+    }
+}
+export default AutoCompactEngine;

package/dist/policy.js

@@ -0,0 +1,78 @@
+/**
+ * Pure decision logic for the absolute compaction budget: no cordis, no I/O.
+ * @module @sagmans/dsh-auto-compact/policy
+ */
+/**
+ * Half-token bias added to the derived budget before it is expressed as a
+ * fraction. The shipped engine re-derives its trigger with
+ * `Math.floor(window * ratio)`, and a budget that binary floating point cannot
+ * represent exactly scales back to one token less, which then rejects the
+ * retained tail as reaching the trigger. Half a token clears that rounding
+ * error while staying below the next whole token.
+ */
+const SCALE_EPSILON = 0.5;
+/**
+ * Resolve the shipped per-route ratio and retained tail in tokens.
+ *
+ * This transcribes the shipped merge — an exact override wins field by field,
+ * retention resolves to exactly one form, and a ratio retention scales with the
+ * routed model's capacity — so pricing stays identical when no absolute budget
+ * applies.
+ *
+ * @param base - the shipped engine's resolved deployment policy.
+ * @param override - the exact route override, when one matches.
+ * @param contextWindow - adapter-owned capacity for the routed model.
+ * @returns the shipped terms for this route.
+ */
+export function routePolicyTerms(base, override, contextWindow) {
+    const thresholdRatio = override?.thresholdRatio ?? base.thresholdRatio;
+    let retainTokens;
+    if (override?.retainTokens !== undefined) {
+        retainTokens = override.retainTokens;
+    }
+    else if (override?.retainRatio !== undefined) {
+        retainTokens = Math.floor(contextWindow * override.retainRatio);
+    }
+    else if (base.retainTokens !== undefined) {
+        retainTokens = base.retainTokens;
+    }
+    else if (base.retainRatio !== undefined) {
+        retainTokens = Math.floor(contextWindow * base.retainRatio);
+    }
+    else {
+        throw new Error('auto-compact: resolved policy carries no retention form');
+    }
+    return { thresholdRatio, retainTokens };
+}
+/**
+ * Decide whether the absolute budget, rather than the shipped ratio, is what
+ * should trigger compaction for this request.
+ *
+ * @param input - measured pressure plus the routed model's resolved budgets.
+ * @returns the derived policy, or `undefined` when the shipped path must decide
+ * alone (no budget configured, no reported capacity, or a ratio trigger that is
+ * already at least as tight).
+ */
+export function decidePressurePolicy(input) {
+    const cap = input.thresholdTokens;
+    // The derived trigger can never exceed the absolute budget, so below the
+    // budget there is nothing to decide and no capacity is needed.
+    if (cap === undefined || input.totalTokens < cap)
+        return undefined;
+    const window = input.contextWindow;
+    if (window === undefined)
+        return undefined;
+    const ratioThreshold = Math.floor(window * input.thresholdRatio);
+    if (cap >= ratioThreshold)
+        return undefined;
+    // A model-free prune can land before summarization; the tail is bounded by
+    // the derived trigger so a later step always has history left to condense.
+    const boundedTail = Math.min(input.retainTokens, Math.floor(cap * input.retainShare), 
+    // The shipped capacity scaling rejects a tail that reaches the trigger.
+    cap - 1);
+    return {
+        thresholdTokens: cap,
+        thresholdRatio: (cap + SCALE_EPSILON) / window,
+        retainTokens: Math.max(0, boundedTail),
+    };
+}

package/dist/view.js

@@ -0,0 +1,82 @@
+/**
+ * Route resolution and the derived-policy receiver used to re-enter the shipped
+ * compaction transaction.
+ * @module @sagmans/dsh-auto-compact/view
+ */
+/**
+ * Read the route the shipped engine itself would price this session against.
+ * @param session - session whose latest durable request header is inspected.
+ * @returns the routed target, or `undefined` when no route is durable yet.
+ */
+export function routedTarget(session) {
+    const config = session.requestHeader()?.config;
+    if (config === undefined || config.provider.length === 0 || config.model.length === 0)
+        return undefined;
+    return { provider: config.provider, model: config.model };
+}
+/**
+ * Find the exact provider/model override the shipped merge would apply.
+ * @param policies - the shipped engine's resolved override table.
+ * @param target - routed target to match exactly.
+ * @returns the matching override, or `undefined`.
+ */
+export function findOverride(policies, target) {
+    return policies.find(policy => policy.provider === target.provider && policy.model === target.model);
+}
+/**
+ * Read the routed model's adapter-owned capacity.
+ * @param ctx - context owning the LLM runtime.
+ * @param target - routed provider/model pair.
+ * @param signal - cancellation signal forwarded to the adapter.
+ * @returns the reported window, or `undefined` when the adapter declares none.
+ */
+export async function resolveContextWindow(ctx, target, signal) {
+    return (await ctx.llm.resolveModelInfo(target.provider, target.model, signal)).context?.contextWindow;
+}
+/**
+ * Build the complete policy the shipped transaction must run under.
+ *
+ * The route override is merged here and then cleared from the table: the
+ * shipped merge would otherwise re-apply the ratio this derivation replaced.
+ *
+ * @param base - the shipped engine's resolved deployment policy.
+ * @param override - the matching exact route override, when any.
+ * @param derived - the derived absolute-budget policy.
+ * @returns a complete, detached policy for one transaction.
+ */
+export function derivedConfig(base, override, derived) {
+    const { provider: _provider, model: _model, ...overrideFields } = override ?? {};
+    return {
+        ...base,
+        ...overrideFields,
+        thresholdRatio: derived.thresholdRatio,
+        retainRatio: undefined,
+        retainTokens: derived.retainTokens,
+        modelPolicies: [],
+    };
+}
+/**
+ * Run one shipped compaction transaction under a derived policy.
+ *
+ * WHY a receiver instead of a field: the shipped engine resolves its policy
+ * from the instance field `config`, which is deep-frozen at load and therefore
+ * cannot be replaced. Swapping the field for the duration of the call would let
+ * two agents compacting concurrently on different routes observe each other's
+ * policy, so the derived value lives on a per-call receiver that shares the
+ * engine's context, overrides, and private state through the prototype chain.
+ *
+ * @param engine - the live engine instance.
+ * @param policy - the derived policy for this one transaction.
+ * @param run - the shipped method to invoke on the receiver.
+ * @returns the shipped method's result.
+ */
+export function withDerivedPolicy(engine, policy, run) {
+    const view = Object.create(engine);
+    Object.defineProperty(view, 'config', {
+        value: policy,
+        enumerable: false,
+        writable: false,
+        configurable: false,
+    });
+    return run(view);
+}

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@sagmans/dsh-auto-compact",
+  "version": "0.1.0",
+  "description": "Absolute token trigger for DeepSeek Harness automatic compaction: condense at a fixed token budget or at the model window ratio, whichever comes first.",
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "plugin",
+    "compaction",
+    "cordis"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "cordis.patch.yml",
+    "README.md"
+  ],
+  "engines": {
+    "node": "^24.0.0"
+  },
+  "packageManager": "pnpm@11.21.0",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sagmans/dsh-auto-compact.git"
+  },
+  "homepage": "https://github.com/sagmans/dsh-auto-compact#readme",
+  "bugs": "https://github.com/sagmans/dsh-auto-compact/issues",
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "compatibility": {
+      "dsh": ">=0.1.5-rc.1 <0.1.6"
+    }
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "node --import tsx/esm --test \"tests/*.spec.ts\"",
+    "build": "tsc -p tsconfig.build.json",
+    "test:build": "node --test \"tests/*.test.mjs\"",
+    "test:release": "python3 -m unittest discover -s tests/release -p 'test_*.py'",
+    "pack-smoke": "node tools/pack-smoke.mjs",
+    "check": "pnpm run typecheck && pnpm test && pnpm run build && pnpm run test:build && pnpm test:release && pnpm run pack-smoke",
+    "prepack": "pnpm run build",
+    "prepublishOnly": "pnpm run typecheck && pnpm test && pnpm test:release"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-agent": ">=0.1.5-rc.1 <0.1.6",
+    "@deepseek-ai/dsh-compaction": ">=0.1.5-rc.1 <0.1.6",
+    "@deepseek-ai/dsh-compaction-basic": ">=0.1.5-rc.1 <0.1.6",
+    "@deepseek-ai/dsh-llm": ">=0.1.5-rc.1 <0.1.6",
+    "@deepseek-ai/dsh-session": ">=0.1.5-rc.1 <0.1.6",
+    "@deepseek-ai/dsh-token-meter": ">=0.1.5-rc.1 <0.1.6",
+    "@deepseek-ai/schemastery": "^3.18.2"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "4.0.2",
+    "@deepseek-ai/dsh": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-agent": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-compaction": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-compaction-basic": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-llm": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-session": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-token-meter": "0.1.5-rc.2",
+    "@deepseek-ai/schemastery": "3.18.2",
+    "@types/node": "22.20.0",
+    "tsx": "4.22.4",
+    "typescript": "6.0.3"
+  }
+}