@stackstackstack/dsh-compaction-tool-result-pruner 0.1.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+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.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# side as of the last confirmed-consistent state. Both languages carry equal authority;
+# after editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write packages/compaction/compaction-tool-result-pruner/README.md
+README.md: 8755f04cfe3e948cfeb67cfb31cbe52168251e15
+README.zh.md: 47c6fec3851b21ea2df9f0d79aa81508530f73dd

package/README.md

@@ -0,0 +1,62 @@
+# @stackstackstack/dsh-compaction-tool-result-pruner
+
+English | [中文](README.zh.md)
+
+The replay-safe model-free pruning service (`ctx.toolResultPruner`). It rewrites over-budget `tool/result` surface nodes to a bounded head, a fixed omission marker, and a bounded tail while retaining the full original event in the append-only session log.
+
+This is a concrete companion to [`dsh-compaction-basic`](../compaction-basic/README.md), not a compaction backend or model-facing tool. Compact-basic reads it through optional `ctx.get('toolResultPruner')`, so either package remains independently composable.
+
+## Service API
+
+`pruneSession(session)` scans one stable snapshot of the current surface. Every over-budget tool result is replaced by one newly appended `tool/result` carrying `{ surfaceOp: { op: 'replace', start: originalSeq, end: originalSeq }, sourceEventSeqs: [originalSeq] }`. The replacement spreads the complete original data and changes only `content`, preserving `turn`, `step`, `callId`, error fields, `meta`, and later data additions. The original event remains available for persistence, replay, and exact-log inspection.
+
+The method throws synchronously when the session rejects a replacement. Replacements committed earlier in the pass remain durable.
+
+`measureContent(blocks)` counts Unicode code points in `text` blocks. `pruneContent(blocks)` returns the bounded replacement or `null` when content is already within the threshold. Non-text blocks are retained at their original relative positions; text slicing never splits a UTF-16 surrogate pair, though it can split a multi-code-point grapheme cluster.
+
+Every emitted result has exactly the configured head budget, fixed marker, and tail budget in text code points, is no larger than `thresholdChars`, and is strictly smaller than the triggering input. A second pass therefore emits no replacement.
+
+## Config
+
+Unrecognized keys fail at plugin construction. Resolved config is detached and deeply immutable.
+
+| Key | Required | Meaning |
+|---|---|---|
+| `thresholdChars` | no (default `8192`) | Prune when combined text exceeds this many Unicode code points. |
+| `headChars` | no (default `4096`) | Leading Unicode code points retained. |
+| `tailChars` | no (default `1024`) | Trailing Unicode code points retained. |
+
+All values are integers; the threshold is positive and head/tail are non-negative. `headChars + marker + tailChars` must fit within `thresholdChars`, so a valid configuration can prune every over-budget result without growth or repeated rewriting.
+
+## Usage
+
+```ts
+import type { Context } from '@deepseek-ai/cordis'
+import ToolResultPruner from '@stackstackstack/dsh-compaction-tool-result-pruner'
+
+export function apply(ctx: Context): void {
+  ctx.plugin(ToolResultPruner)
+}
+```
+
+## Model Experience
+
+### Pruned tool result
+
+#### What the model sees
+
+Once a compaction trigger qualifies, future requests see the retained head, `\n\n[... tool result middle pruned ...]\n\n`, and retained tail in place of the removed text. Rich blocks keep their order. The model does not see a second copy of the original.
+
+#### Token effect
+
+Each rewritten tool result has at most `thresholdChars` text code points. Pruning itself makes no model call; compaction-basic skips summarization when the remeasured request falls below pressure, otherwise the summarizer reads the pruned surface.
+
+#### KV Cache effect
+
+Replacing an earlier result invalidates reuse from the first changed token. The pruned prefix is eligible for reuse while its route, envelope, and preceding history remain identical.
+
+## Known Limitations and Deferred Work
+
+- **Character budgets are not token budgets** — provider token density varies, so `ctx.tokenMeter` remains the authority for deciding whether pruning relieved request pressure.
+- **Pruning is syntactic** — it retains the beginning and end without interpreting which middle lines are semantically important.
+- **Grapheme clusters can split** — code-point slicing protects surrogate pairs but does not perform locale-aware grapheme segmentation.

package/README.zh.md

@@ -0,0 +1,62 @@
+# @stackstackstack/dsh-compaction-tool-result-pruner
+
+[English](README.md) | 中文
+
+可安全回放、不依赖模型的剪枝服务（`ctx.toolResultPruner`）。它会将超出预算的 `tool/result` 表层节点改写为长度受限的头部、固定省略标记和长度受限的尾部，同时在仅追加会话日志中保留完整原始事件。
+
+这是 [`dsh-compaction-basic`](../compaction-basic/README.md) 的具体配套服务，不是压缩（compaction）后端或面向模型的工具。Compact-basic 通过可选的 `ctx.get('toolResultPruner')` 读取它，因此这两个包仍可各自独立组合。
+
+## 服务 API
+
+`pruneSession(session)` 会扫描当前表层的一个稳定快照。每个超出预算的工具结果都会被一个新追加的 `tool/result` 替换，其携带 `{ surfaceOp: { op: 'replace', start: originalSeq, end: originalSeq }, sourceEventSeqs: [originalSeq] }`。替换会展开完整原始数据，只更改 `content`，保留 `turn`、`step`、`callId`、错误字段、`meta` 以及以后新增的数据字段。原始事件仍可用于持久化、回放和精确日志检查。
+
+当会话拒绝替换时，该方法会同步抛出异常。本次扫描中先前已提交的替换仍会保留。
+
+`measureContent(blocks)` 会统计 `text` 块中的 Unicode 码点。`pruneContent(blocks)` 会返回长度受限的替换；如果内容已在阈值内，则返回 `null`。非文本块保持原始相对位置；文本切片绝不会拆分 UTF-16 代理项对，但可能拆分由多个码点组成的字素簇。
+
+每个发出的结果在文本码点上都精确包含已配置的头部预算、固定标记和尾部预算，不大于 `thresholdChars`，且严格小于触发输入。因此第二次扫描不会发出替换。
+
+## 配置
+
+无法识别的配置键会使插件在构造时失败。已解析配置与输入脱离，并且深度不可变。
+
+| 配置键 | 必填 | 含义 |
+|---|---|---|
+| `thresholdChars` | 否（默认 `8192`） | 合并文本超过此 Unicode 码点数时剪枝。 |
+| `headChars` | 否（默认 `4096`） | 保留的开头 Unicode 码点数。 |
+| `tailChars` | 否（默认 `1024`） | 保留的末尾 Unicode 码点数。 |
+
+所有值都必须是整数；阈值必须为正数，头部／尾部必须为非负数。`headChars + marker + tailChars` 之和不得超过 `thresholdChars`，因此有效配置可以剪枝每个超出预算的结果，不会增长或重复改写。
+
+## 用法
+
+```ts
+import type { Context } from '@deepseek-ai/cordis'
+import ToolResultPruner from '@stackstackstack/dsh-compaction-tool-result-pruner'
+
+export function apply(ctx: Context): void {
+  ctx.plugin(ToolResultPruner)
+}
+```
+
+## 模型体验
+
+### 已剪枝的工具结果
+
+#### 模型看到的内容
+
+一旦满足压缩触发条件，后续请求看到的将是保留的头部、`\n\n[... tool result middle pruned ...]\n\n` 和保留的尾部，而非被移除的文本。非文本块保持原有顺序。模型不会看到原文的第二份副本。
+
+#### Token 影响
+
+每个已改写工具结果最多包含 `thresholdChars` 个文本码点。剪枝本身不会发起模型调用；重新测量的请求低于压力阈值时，compaction-basic 会跳过摘要，否则摘要器会读取已剪枝的表层。
+
+#### KV Cache 影响
+
+替换较早的结果会使从第一个改变的 token 起的复用失效。当其路由、envelope 与之前的历史保持一致时，已剪枝前缀可以复用。
+
+## 已知限制与暂缓事项
+
+- **字符预算不是 token 预算**：不同提供方的 token 密度各异，因此 `ctx.tokenMeter` 仍负责判定剪枝是否缓解了请求压力。
+- **剪枝只基于语法**：它保留开头与结尾，不解释中间哪些行在语义上重要。
+- **字素簇可能被拆分**：按码点切片可保护代理项对，但不会执行感知区域设置的字素簇分割。

package/lib/index.js

@@ -0,0 +1,196 @@
+import { Service } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+import { deepFreeze, freezeMessage } from "@stackstackstack/dsh-llm";
+//#region lib/types/config.js
+/** Configuration resolution for deterministic tool-result pruning. */
+/** Fixed marker substituted for every removed middle span. */
+const PRUNE_MARKER = "\n\n[... tool result middle pruned ...]\n\n";
+/** Low-friction defaults for coding-agent tool output. */
+const DEFAULTS = deepFreeze({
+	thresholdChars: 8192,
+	headChars: 4096,
+	tailChars: 1024
+});
+const CONFIG_KEYS = new Set([
+	"thresholdChars",
+	"headChars",
+	"tailChars"
+]);
+/**
+* Count Unicode code points without splitting surrogate pairs.
+* @param text - text to measure.
+* @returns the Unicode code-point count.
+*/
+function codePointLength(text) {
+	return Array.from(text).length;
+}
+/**
+* Resolve and validate pruning budgets.
+* @param config - raw plugin configuration.
+* @returns a detached deeply immutable configuration.
+*/
+function resolveConfig(config = {}) {
+	for (const key of Object.keys(config)) if (!CONFIG_KEYS.has(key)) throw new Error(`ToolResultPruneConfig: unknown key "${key}" (allowed: thresholdChars, headChars, tailChars)`);
+	const resolved = {
+		thresholdChars: config.thresholdChars ?? DEFAULTS.thresholdChars,
+		headChars: config.headChars ?? DEFAULTS.headChars,
+		tailChars: config.tailChars ?? DEFAULTS.tailChars
+	};
+	assertPositiveInteger("thresholdChars", resolved.thresholdChars);
+	assertNonNegativeInteger("headChars", resolved.headChars);
+	assertNonNegativeInteger("tailChars", resolved.tailChars);
+	const emittedChars = resolved.headChars + codePointLength(PRUNE_MARKER) + resolved.tailChars;
+	if (emittedChars > resolved.thresholdChars) throw new Error(`ToolResultPruneConfig: headChars + marker + tailChars (${emittedChars}) must be at most thresholdChars (${resolved.thresholdChars})`);
+	return deepFreeze(structuredClone(resolved));
+}
+function assertPositiveInteger(name, value) {
+	if (!Number.isInteger(value) || value <= 0) throw new Error(`ToolResultPruneConfig: ${name} (${value}) must be a positive integer`);
+}
+function assertNonNegativeInteger(name, value) {
+	if (!Number.isInteger(value) || value < 0) throw new Error(`ToolResultPruneConfig: ${name} (${value}) must be a non-negative integer`);
+}
+//#endregion
+//#region lib/types/index.js
+/**
+* Replay-safe, model-free tool-result pruning service.
+*
+* @module @stackstackstack/dsh-compaction-tool-result-pruner
+*/
+/** Deterministic head/middle/tail pruning for current tool-result surface nodes. */
+var ToolResultPruner = class extends Service {
+	static inject = ["tokenMeter"];
+	static Config = z.object({
+		thresholdChars: z.number().step(1).min(1).default(DEFAULTS.thresholdChars),
+		headChars: z.number().step(1).min(0).default(DEFAULTS.headChars),
+		tailChars: z.number().step(1).min(0).default(DEFAULTS.tailChars)
+	});
+	/** Resolved and immutable character budgets. */
+	config;
+	constructor(ctx, config = {}) {
+		super(ctx, "toolResultPruner");
+		this.config = resolveConfig(config);
+	}
+	/**
+	* Measure text content in Unicode code points; non-text blocks cost zero.
+	* @param blocks - tool-result content to measure.
+	* @returns total Unicode code points across text blocks.
+	*/
+	measureContent(blocks) {
+		let chars = 0;
+		for (const block of blocks) if (block.type === "text") chars += codePointLength(block.text);
+		return chars;
+	}
+	/**
+	* Replace an over-budget text middle while retaining rich-block order.
+	* Text slicing is by Unicode code point, not UTF-16 code unit, so a retained
+	* boundary cannot split a surrogate pair. Grapheme clusters may still split.
+	* @param blocks - original tool-result content.
+	* @returns pruned content, or `null` when the text is within budget.
+	*/
+	pruneContent(blocks) {
+		const totalChars = this.measureContent(blocks);
+		if (totalChars <= this.config.thresholdChars) return null;
+		const removedStart = this.config.headChars;
+		const removedEnd = totalChars - this.config.tailChars;
+		const pruned = [];
+		let consumed = 0;
+		let markerInserted = false;
+		for (const block of blocks) {
+			if (block.type !== "text") {
+				pruned.push(block);
+				continue;
+			}
+			const points = Array.from(block.text);
+			const blockStart = consumed;
+			const blockEnd = blockStart + points.length;
+			const headEnd = Math.min(points.length, Math.max(0, removedStart - blockStart));
+			const tailStart = Math.min(points.length, Math.max(0, removedEnd - blockStart));
+			const marker = blockStart < removedEnd && blockEnd > removedStart && !markerInserted ? PRUNE_MARKER : "";
+			if (marker.length > 0) markerInserted = true;
+			const text = points.slice(0, headEnd).join("") + marker + points.slice(tailStart).join("");
+			if (text.length > 0) pruned.push({
+				...block,
+				text
+			});
+			consumed = blockEnd;
+		}
+		/* v8 ignore next -- totalChars > threshold and valid budgets guarantee a removed text span. */
+		if (!markerInserted) throw new Error("tool-result prune: failed to locate the removed text span");
+		const charsAfter = this.measureContent(pruned);
+		/* v8 ignore next -- config validation fixes the emitted head + marker + tail budget. */
+		if (charsAfter > this.config.thresholdChars || charsAfter >= totalChars) throw new Error("tool-result prune: replacement must be smaller and within threshold");
+		return pruned;
+	}
+	/**
+	* Prune every over-budget tool result from one stable current-surface snapshot.
+	* Each replacement preserves the complete event data except for `content`,
+	* cites the shadowed node so replay can recover the replacement input, and is
+	* immediately preceded by a `compaction/prune` shadow-price event pricing the
+	* shadowed node through the injected token meter, so pure consumers can
+	* subtract it without per-node state.
+	* @param session - session whose current surface is rewritten.
+	* @returns landed replacements and aggregate Unicode-code-point savings.
+	* @throws when the session rejects a replacement; replacements committed
+	* earlier in the pass remain durable.
+	*/
+	pruneSession(session) {
+		const candidates = [];
+		for (const seq of [...session.surface.nodes]) {
+			const event = session.events[seq];
+			/* v8 ignore next -- surface seqs are validated contiguous log references. */
+			if (event?.type === "tool/result") candidates.push({
+				seq,
+				event
+			});
+		}
+		const pruned = [];
+		let charsRemoved = 0;
+		for (const { seq, event } of candidates) {
+			const result = event.data.message.content[0];
+			const content = this.pruneContent(result.content);
+			if (content === null) continue;
+			const charsBefore = this.measureContent(result.content);
+			const charsAfter = this.measureContent(content);
+			const message = freezeMessage({
+				...event.data.message,
+				content: [{
+					...result,
+					content
+				}]
+			});
+			session.append("compaction/prune", {
+				shadowedRange: {
+					start: seq,
+					end: seq
+				},
+				shadowedSeqs: [seq],
+				shadowedTokenCount: this.ctx.tokenMeter.estimateMessage(event.data.message)
+			});
+			const replacement = session.append("tool/result", {
+				...event.data,
+				message
+			}, {
+				surfaceOp: {
+					op: "replace",
+					start: seq,
+					end: seq
+				},
+				sourceEventSeqs: [seq]
+			});
+			pruned.push({
+				originalSeq: seq,
+				replacementSeq: replacement.seq,
+				callId: event.data.message.source.callId,
+				charsBefore,
+				charsAfter
+			});
+			charsRemoved += charsBefore - charsAfter;
+		}
+		return {
+			pruned,
+			charsRemoved
+		};
+	}
+};
+//#endregion
+export { DEFAULTS, PRUNE_MARKER, ToolResultPruner, ToolResultPruner as default, codePointLength, resolveConfig };

package/lib/invariant.js

@@ -0,0 +1,20 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@stackstackstack/dsh-compaction-tool-result-pruner`.
+* @module @stackstackstack/dsh-compaction-tool-result-pruner/invariant
+*/
+const PACKAGE_NAME = "@stackstackstack/dsh-compaction-tool-result-pruner";
+/** Cordis companion plugin name. */
+const name = "compaction-tool-result-pruner-invariant";
+/** Services required before the companion can register. */
+const inject = ["invariants"];
+/** No runtime invariant: Session validates each content-only rewrite and its companion owns cross-event enclosure. */
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/config.d.ts

@@ -0,0 +1,19 @@
+/** Configuration resolution for deterministic tool-result pruning. */
+import type { ResolvedConfig, ToolResultPruneConfig } from './types.ts';
+/** Fixed marker substituted for every removed middle span. */
+export declare const PRUNE_MARKER = "\n\n[... tool result middle pruned ...]\n\n";
+/** Low-friction defaults for coding-agent tool output. */
+export declare const DEFAULTS: ResolvedConfig;
+/**
+ * Count Unicode code points without splitting surrogate pairs.
+ * @param text - text to measure.
+ * @returns the Unicode code-point count.
+ */
+export declare function codePointLength(text: string): number;
+/**
+ * Resolve and validate pruning budgets.
+ * @param config - raw plugin configuration.
+ * @returns a detached deeply immutable configuration.
+ */
+export declare function resolveConfig(config?: ToolResultPruneConfig): ResolvedConfig;
+//# sourceMappingURL=config.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Replay-safe, model-free tool-result pruning service.
+ *
+ * @module @stackstackstack/dsh-compaction-tool-result-pruner
+ */
+import { Context, Service } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { ContentBlock } from '@stackstackstack/dsh-llm';
+import type { Session } from '@stackstackstack/dsh-session';
+import type { PruneResult, ResolvedConfig, ToolResultPruneConfig } from './types.ts';
+export { codePointLength, DEFAULTS, PRUNE_MARKER, resolveConfig } from './config.ts';
+export type { PrunedEntry, PruneResult, ResolvedConfig, ToolResultPruneConfig, } from './types.ts';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        toolResultPruner: ToolResultPruner;
+    }
+}
+/** Deterministic head/middle/tail pruning for current tool-result surface nodes. */
+export declare class ToolResultPruner extends Service {
+    static inject: string[];
+    static Config: z<ToolResultPruneConfig>;
+    /** Resolved and immutable character budgets. */
+    readonly config: ResolvedConfig;
+    constructor(ctx: Context, config?: ToolResultPruneConfig);
+    /**
+     * Measure text content in Unicode code points; non-text blocks cost zero.
+     * @param blocks - tool-result content to measure.
+     * @returns total Unicode code points across text blocks.
+     */
+    measureContent(blocks: readonly ContentBlock[]): number;
+    /**
+     * Replace an over-budget text middle while retaining rich-block order.
+     * Text slicing is by Unicode code point, not UTF-16 code unit, so a retained
+     * boundary cannot split a surrogate pair. Grapheme clusters may still split.
+     * @param blocks - original tool-result content.
+     * @returns pruned content, or `null` when the text is within budget.
+     */
+    pruneContent(blocks: readonly ContentBlock[]): ContentBlock[] | null;
+    /**
+     * Prune every over-budget tool result from one stable current-surface snapshot.
+     * Each replacement preserves the complete event data except for `content`,
+     * cites the shadowed node so replay can recover the replacement input, and is
+     * immediately preceded by a `compaction/prune` shadow-price event pricing the
+     * shadowed node through the injected token meter, so pure consumers can
+     * subtract it without per-node state.
+     * @param session - session whose current surface is rewritten.
+     * @returns landed replacements and aggregate Unicode-code-point savings.
+     * @throws when the session rejects a replacement; replacements committed
+     * earlier in the pass remain durable.
+     */
+    pruneSession(session: Session): PruneResult;
+}
+export default ToolResultPruner;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@stackstackstack/dsh-compaction-tool-result-pruner`.
+ * @module @stackstackstack/dsh-compaction-tool-result-pruner/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "compaction-tool-result-pruner-invariant";
+/** Services required before the companion can register. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/types.d.ts

@@ -0,0 +1,37 @@
+import type { CallId } from '@stackstackstack/dsh-llm';
+/** Character-budget policy for deterministic tool-result pruning. */
+export interface ToolResultPruneConfig {
+    /** Prune when total text exceeds this many Unicode code points. Defaults to `8192`. */
+    thresholdChars?: number;
+    /** Maximum leading Unicode code points retained. Defaults to `4096`. */
+    headChars?: number;
+    /** Maximum trailing Unicode code points retained. Defaults to `1024`. */
+    tailChars?: number;
+}
+/** Validated, detached, deeply immutable pruning configuration. */
+export interface ResolvedConfig {
+    readonly thresholdChars: number;
+    readonly headChars: number;
+    readonly tailChars: number;
+}
+/** Cited source event and size accounting for one landed surface replacement. */
+export interface PrunedEntry {
+    /** Full-fidelity tool-result event shadowed by the replacement. */
+    readonly originalSeq: number;
+    /** Newly appended pruned tool-result event. */
+    readonly replacementSeq: number;
+    /** Tool call shared by the original and replacement. */
+    readonly callId: CallId;
+    /** Original text size in Unicode code points. */
+    readonly charsBefore: number;
+    /** Replacement text size in Unicode code points. */
+    readonly charsAfter: number;
+}
+/** Aggregate outcome of one stable-surface pruning pass. */
+export interface PruneResult {
+    /** Replacements in the snapshotted surface order. */
+    readonly pruned: readonly PrunedEntry[];
+    /** Total Unicode code points removed across replacements. */
+    readonly charsRemoved: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@stackstackstack/dsh-compaction-tool-result-pruner",
+  "description": "Replay-safe model-free head/middle/tail pruning for tool-result surface nodes",
+  "version": "0.1.5",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/compaction/compaction-tool-result-pruner"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@stackstackstack/dsh-invariants": "^0.1.5",
+    "@stackstackstack/dsh-compaction": "^0.1.5",
+    "@stackstackstack/dsh-session": "^0.1.5",
+    "@stackstackstack/dsh-llm": "^0.1.5",
+    "@stackstackstack/dsh-token-meter": "^0.1.5",
+    "@deepseek-ai/cordis": "^4.0.1"
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis-plugin-include": "^1.0.6",
+    "@stackstackstack/dsh-compaction": "^0.1.5",
+    "@deepseek-ai/cordis-plugin-loader": "^1.0.2",
+    "@stackstackstack/dsh-invariants": "^0.1.5",
+    "@stackstackstack/dsh-token-meter": "^0.1.5",
+    "@stackstackstack/dsh-session": "^0.1.5",
+    "@stackstackstack/dsh-llm": "^0.1.5",
+    "@deepseek-ai/cordis": "^4.0.1"
+  }
+}