@xbzb404/dsh-context-compression-selector-runtime 0.0.0-stage → 0.2.1-rc.3

package/lib/invariant.d.ts

@@ -0,0 +1,10 @@
+import { Context } from "@deepseek-ai/cordis";
+//#region src/invariant.d.ts
+/** Cordis companion plugin name. */
+declare const name = "context-compression-selector-runtime-invariant";
+/** Services required before the companion can register. */
+declare const inject: string[];
+/** Register this package's invariant companion. */
+declare const apply: (ctx: Context) => Promise<() => void>;
+//#endregion
+export { apply, inject, name };

package/lib/invariant.js

@@ -0,0 +1,70 @@
+import { a as validatePublishedTailTrim, o as sessionEvents } from "./tail-trim.js";
+//#region src/invariant.ts
+const PACKAGE_NAME = "dsh-context-compression-selector-runtime";
+/** Cordis companion plugin name. */
+const name = "context-compression-selector-runtime-invariant";
+/** Services required before the companion can register. */
+const inject = ["invariants"];
+/** Whether the next event claims the unresolved prune's replacement range. */
+function resemblesCompanion(prune, event) {
+	if (event.type !== "tool/result" && event.type !== "user/message" || typeof event.surfaceOp !== "object") return false;
+	const sources = new Set(event.sourceEventSeqs ?? []);
+	return event.surfaceOp.startSeq === prune.data.shadowedRange.start && event.surfaceOp.endSeq === prune.data.shadowedRange.end || prune.data.shadowedSeqs.some((seq) => sources.has(seq));
+}
+/** Validate one standard prune's immediately adjacent surface replacement. */
+function validateCompanion(session, prune, event, fail) {
+	if (event.type !== "tool/result" && event.type !== "user/message" || typeof event.surfaceOp !== "object") fail(`compaction/prune at seq ${prune.seq} must be immediately followed by a replacement surface event`);
+	const { shadowedRange, shadowedSeqs } = prune.data;
+	if (shadowedSeqs.length === 0 || shadowedSeqs[0] !== shadowedRange.start || shadowedSeqs.at(-1) !== shadowedRange.end) fail(`compaction/prune at seq ${prune.seq} has a shadowed range inconsistent with shadowedSeqs`);
+	if (event.surfaceOp.startSeq !== shadowedRange.start || event.surfaceOp.endSeq !== shadowedRange.end) fail(`replacement at seq ${event.seq} does not replace compaction/prune range ${shadowedRange.start}-${shadowedRange.end}`);
+	const sources = new Set(event.sourceEventSeqs ?? []);
+	const missing = shadowedSeqs.filter((seq) => !sources.has(seq));
+	if (missing.length > 0) fail(`replacement at seq ${event.seq} omits shadowed source seqs ${missing.join(", ")}`);
+	if (event.type === "user/message" && validatePublishedTailTrim(session, prune.seq) === null) fail(`TailTrim publication at seq ${prune.seq} is invalid`);
+}
+/** Validate a replayed log and return its only legal unresolved tail. */
+function seedPending(session, fail) {
+	let pending;
+	for (const event of sessionEvents(session)) {
+		if (pending !== void 0) {
+			if (resemblesCompanion(pending, event)) validateCompanion(session, pending, event, fail);
+			pending = void 0;
+		}
+		if (event.type === "compaction/prune") pending = event;
+	}
+	return pending;
+}
+/** Install adjacency checks with pre-commit staging. */
+const install = Object.assign((ctx, fail) => {
+	const pending = /* @__PURE__ */ new WeakMap();
+	const staged = /* @__PURE__ */ new WeakMap();
+	const seed = (session) => {
+		pending.set(session, seedPending(session, fail));
+	};
+	const current = (session) => {
+		if (!pending.has(session)) seed(session);
+		return pending.get(session);
+	};
+	for (const session of ctx.sessions.list()) seed(session);
+	ctx.on("session/created", seed, { global: true });
+	ctx.on("internal/dispatch", (_mode, eventName, args) => {
+		if (eventName !== "session/event") return;
+		const [session, event] = args;
+		const open = current(session);
+		if (open !== void 0 && resemblesCompanion(open, event)) validateCompanion(session, open, event, fail);
+		staged.set(event, {
+			session,
+			next: event.type === "compaction/prune" ? event : void 0
+		});
+	}, { global: true });
+	ctx.on("session/event", (session, event) => {
+		const candidate = staged.get(event);
+		if (candidate === void 0 || candidate.session !== session) return fail("session/event reached publication without matching pre-commit validation");
+		staged.delete(event);
+		pending.set(session, candidate.next);
+	}, { global: true });
+}, { inject: ["sessions"] });
+/** Register this package's invariant companion. */
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/tail-trim.js

@@ -0,0 +1,142 @@
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+//#region src/session-events.ts
+/**
+* Read one immutable Session event snapshot.
+*
+* Harness rc.2 exposed `events`; Alpha 5 replaced it with the public
+* `snapshotEvents()` method. 0.2.0 keeps `snapshotEvents()` (now with default
+* `[0, seq)` range arguments) and removed the `events` accessor. This helper
+* prefers the modern public API but retains the rc.2 `events` accessor as a
+* fallback so sessions produced by older harness builds still resolve.
+*/
+function sessionEvents(session) {
+	const candidate = session;
+	if (typeof candidate.snapshotEvents === "function") return candidate.snapshotEvents();
+	if (candidate.events !== void 0) return candidate.events;
+	throw new TypeError("Session exposes neither snapshotEvents() nor the rc.2 events accessor");
+}
+//#endregion
+//#region src/tail-trim.ts
+/** Plugin-owned TailTrim publication protocol over official Session events. */
+const PRUNE_SOURCE_PLUGIN = "dsh-context-compression-selector-runtime";
+const TAIL_TRIM_REF_PATTERN = /^session:\/\/([^/]+)\/tailtrim\/(\d+)$/;
+const MAX_ROOTS = 64;
+const MAX_STUB_CODE_POINTS = 1024;
+/** Build a same-session reference keyed by the standard prune event. */
+function tailTrimRef(sessionId, manifestSeq) {
+	return `session://${sessionId}/tailtrim/${String(manifestSeq)}`;
+}
+/** Parse one exact TailTrim reference. */
+function parseTailTrimRef(ref) {
+	const match = TAIL_TRIM_REF_PATTERN.exec(ref);
+	if (match === null) return null;
+	const manifestSeq = Number(match[2]);
+	if (!Number.isSafeInteger(manifestSeq) || manifestSeq < 0) return null;
+	return {
+		sessionId: match[1] ?? "",
+		manifestSeq
+	};
+}
+/** Build the fixed bounded model-visible TailTrim stub. */
+function tailTrimStub(ref, toolNames, sourceEventSeqs) {
+	const stub = [
+		"[TailTrim: completed tool-call group]",
+		`ref: ${ref}`,
+		`tools: ${toolNames.join(", ")}`,
+		`source_event_seqs: ${sourceEventSeqs.join(", ")}`,
+		"use context_compression_retrieve with this TailTrim ref if needed"
+	].join("\n");
+	return Array.from(stub).length <= MAX_STUB_CODE_POINTS ? stub : null;
+}
+/** Wrap a TailTrim stub in the one user message used for range replacement. */
+function tailTrimMessage(stub) {
+	return createUserMessage({
+		content: [{
+			type: "text",
+			text: stub
+		}],
+		source: {
+			kind: "context-compression-prune",
+			plugin: PRUNE_SOURCE_PLUGIN
+		}
+	});
+}
+/** Validate the standard prune, adjacent replacement, append roots and stub. */
+function validatePublishedTailTrim(session, manifestSeq) {
+	const events = sessionEvents(session);
+	const manifest = events[manifestSeq];
+	if (manifest?.type !== "compaction/prune" || manifest.data.shadowedSeqs.length < 2 || manifest.data.shadowedSeqs.length > MAX_ROOTS || manifest.data.shadowedSeqs[0] !== manifest.data.shadowedRange.start || manifest.data.shadowedSeqs.at(-1) !== manifest.data.shadowedRange.end || new Set(manifest.data.shadowedSeqs).size !== manifest.data.shadowedSeqs.length) return null;
+	const replacement = events[manifestSeq + 1];
+	if (replacement?.type !== "user/message" || replacement.seq !== manifest.seq + 1 || replacement.data.source.kind !== "context-compression-prune" || replacement.data.source.plugin !== PRUNE_SOURCE_PLUGIN || replacement.surfaceOp === void 0 || replacement.surfaceOp === "append" || replacement.surfaceOp.startSeq !== manifest.data.shadowedRange.start || replacement.surfaceOp.endSeq !== manifest.data.shadowedRange.end || !sameNumbers(replacement.sourceEventSeqs, [manifest.seq, ...manifest.data.shadowedSeqs]) || replacement.data.content.length !== 1 || replacement.data.content[0]?.type !== "text") return null;
+	const tracedRoots = manifest.data.shadowedSeqs.map((seq) => uniqueAppendRoot(session, seq, manifestSeq));
+	if (tracedRoots.some((root) => root === null)) return null;
+	const sourceEventSeqs = tracedRoots;
+	if (new Set(sourceEventSeqs).size !== sourceEventSeqs.length) return null;
+	const roots = sourceEventSeqs.map((seq) => events[seq]);
+	if (roots.some((event) => event === void 0)) return null;
+	const typedRoots = roots;
+	if (!validRootGroup(typedRoots, manifestSeq)) return null;
+	const assistant = typedRoots[0];
+	if (assistant?.type !== "assistant/message") return null;
+	const toolNames = assistant.data.message.content.map((block) => {
+		if (block.type !== "tool-call") throw new Error("unreachable");
+		return block.name;
+	});
+	const ref = tailTrimRef(String(session.id), manifestSeq);
+	const stub = tailTrimStub(ref, toolNames, sourceEventSeqs);
+	if (stub === null || replacement.data.content[0].text !== stub) return null;
+	return {
+		manifest,
+		replacement,
+		roots: typedRoots,
+		toolNames,
+		ref,
+		stub
+	};
+}
+function uniqueAppendRoot(session, seq, beforeSeq) {
+	const events = sessionEvents(session);
+	const pending = [{
+		seq,
+		depth: 0
+	}];
+	const visited = /* @__PURE__ */ new Set();
+	const roots = /* @__PURE__ */ new Set();
+	while (pending.length > 0) {
+		const next = pending.pop();
+		if (next === void 0 || next.depth > MAX_ROOTS || visited.has(next.seq)) continue;
+		if (!Number.isSafeInteger(next.seq) || next.seq < 0 || next.seq >= beforeSeq) return null;
+		visited.add(next.seq);
+		if (visited.size > MAX_ROOTS) return null;
+		const event = events[next.seq];
+		if (event === void 0 || event.type !== "assistant/message" && event.type !== "tool/result") return null;
+		if (event.surfaceOp === "append") roots.add(event.seq);
+		else if (typeof event.surfaceOp === "object") {
+			const sources = event.sourceEventSeqs;
+			if (sources === void 0 || sources.length === 0) return null;
+			for (const source of sources) pending.push({
+				seq: source,
+				depth: next.depth + 1
+			});
+		} else return null;
+		if (roots.size > 1) return null;
+	}
+	return roots.size === 1 ? [...roots][0] ?? null : null;
+}
+function validRootGroup(roots, manifestSeq) {
+	const assistant = roots[0];
+	if (assistant?.type !== "assistant/message" || assistant.seq >= manifestSeq || assistant.surfaceOp !== "append" || assistant.data.interrupted === true || assistant.data.message.content.length === 0 || assistant.data.message.content.some((block) => block.type !== "tool-call")) return false;
+	const callIds = assistant.data.message.content.map((call) => call.id);
+	if (new Set(callIds).size !== callIds.length || roots.length !== callIds.length + 1) return false;
+	for (const [index, root] of roots.slice(1).entries()) {
+		if (root.type !== "tool/result" || root.seq >= manifestSeq || root.surfaceOp !== "append") return false;
+		const message = root.data.message;
+		if (message.isError === true || root.data.error !== void 0 || root.data.turn !== assistant.data.turn || root.data.step !== assistant.data.step || String(message.toolCallId) !== String(callIds[index])) return false;
+	}
+	return true;
+}
+function sameNumbers(left, right) {
+	return left !== void 0 && left.length === right.length && left.every((value, index) => value === right[index]);
+}
+//#endregion
+export { validatePublishedTailTrim as a, tailTrimStub as i, tailTrimMessage as n, sessionEvents as o, tailTrimRef as r, parseTailTrimRef as t };

package/package.json

@@ -1,6 +1,69 @@
 {
   "name": "@xbzb404/dsh-context-compression-selector-runtime",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.1-rc.3",
+  "description": "Auditable context-compression runtime for DeepSeek Harness",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/**/*.js",
+    "lib/**/*.d.ts",
+    "assets/**/*",
+    "README.md",
+    "README.zh.md",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.md"
+  ],
+  "keywords": [
+    "deepseek",
+    "harness",
+    "context",
+    "compression",
+    "plugin"
+  ],
+  "license": "MIT",
+  "author": "ZHB",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xbzb404/dsh-context-compression-selector.git",
+    "directory": "packages/runtime"
+  },
+  "homepage": "https://github.com/xbzb404/dsh-context-compression-selector#readme",
+  "bugs": {
+    "url": "https://github.com/xbzb404/dsh-context-compression-selector/issues"
+  },
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "dependencies": {
+    "@huggingface/tokenizers": "0.1.3"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": ">=4.0.4 <5",
+    "@deepseek-ai/schemastery": ">=3.18.4 <4",
+    "@deepseek-ai/dsh-agent": ">=0.2.0-rc.2 <0.3.0",
+    "@deepseek-ai/dsh-compaction": ">=0.2.0-rc.2 <0.3.0",
+    "@deepseek-ai/dsh-invariants": ">=0.2.0-rc.2 <0.3.0",
+    "@deepseek-ai/dsh-llm": ">=0.2.0-rc.2 <0.3.0",
+    "@deepseek-ai/dsh-session": ">=0.2.0-rc.2 <0.3.0",
+    "@deepseek-ai/dsh-settings": ">=0.2.0-rc.2 <0.3.0",
+    "@deepseek-ai/dsh-system-prompt": ">=0.2.0-rc.2 <0.3.0",
+    "@deepseek-ai/dsh-token-meter": ">=0.2.0-rc.2 <0.3.0",
+    "@deepseek-ai/dsh-tools": ">=0.2.0-rc.2 <0.3.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  }
+}