dsh-context-pruner 0.0.0-stage → 0.1.1

package/cordis.patch.yml

@@ -0,0 +1,19 @@
+# dsh-context-pruner bundle patch.
+#
+# Mounts the plugin into a dsh profile's plugin tree. This build registers the
+# read-only `/prune` command; it does NOT replace `ctx.compaction`, so it
+# composes safely alongside the shipped `compaction-basic` row.
+#
+# Install:
+#   dsh plugin --profile web add G:\Projects\dsh-context-pruner
+#
+# The plugin command pnpm-installs the package into the profile's node_modules
+# and reconciles it into the profile's `dsh.profile.bundles` list, after which
+# this patch's insert row is applied. Nothing outside the profile directory is
+# modified, and removing the row (or the bundle entry) fully reverts it.
+- insert:
+    - id: context-pruner
+      # Node-resolvable package name — must stay in sync with package.json
+      # `name`. Quoted because it is a plain scalar that may be read as a
+      # reserved token.
+      name: 'dsh-context-pruner'

package/lib/backend.js

@@ -0,0 +1,190 @@
+/**
+ * dsh-context-pruner corrective compaction backend.
+ *
+ * The whole point of this plugin lives in one method: `summarize()`. DSH's
+ * `BasicCompactionEngine` documents it as the *sole* subclass customization
+ * hook — pressure policy, retention, range selection, shrink validation and
+ * token accounting all stay on the parent, so every pricing decision keeps
+ * using the singleton token meter.
+ *
+ * We do NOT reimplement the region transaction and we do NOT select a range.
+ * We only change *what the summary says*: instead of a neutral "here is what
+ * happened" checkpoint, we emit a **correction checkpoint** that explicitly
+ * retires the failed exploration and states the conclusion that actually
+ * holds.
+ *
+ * ## Why this reimplements the call instead of swapping the instruction
+ *
+ * `dsh-compaction-basic` builds its summarization directive from a
+ * module-scoped `COMPACTION_INSTRUCTION` constant that it does not export, and
+ * `summarizeWithLlm()` is a plain module function. There is no seam to
+ * substitute the instruction, so the honest options are (a) monkey-patch
+ * module scope or (b) reimplement the call here. We reimplement it, mirroring
+ * the shipped shape exactly so the provider's warm prefix cache is still
+ * reused: the conversation's own system prompt, tools, and leading messages go
+ * first, and our instruction is the single novel trailing user message.
+ *
+ * @module dsh-context-pruner/backend
+ */
+
+import { BasicCompactionEngine } from "@deepseek-ai/dsh-compaction-basic";
+import { BlockAssembler, LlmError, contentHasImage } from "@deepseek-ai/dsh-llm";
+import { deepFreeze } from "@deepseek-ai/dsh-util-values";
+
+/**
+ * Default instruction appended as the final user message of the auxiliary
+ * summarization call.
+ *
+ * It deliberately contradicts the stock compaction instruction. The stock one
+ * says "Do NOT mention this summarization request or that the context was
+ * compacted"; ours must say the opposite, because the entire value of the
+ * feature is that the model *stops* treating the retired exploration as live
+ * reasoning.
+ */
+export const DEFAULT_CORRECTIVE_INSTRUCTION = [
+	"You are now acting as a CORRECTION CHECKPOINT writer for this AI coding assistant.",
+	"",
+	"The conversation ABOVE is being replaced by your checkpoint. It contains an exploration that reached a WRONG conclusion.",
+	"Your checkpoint must let another model resume the work WITHOUT re-trusting that wrong conclusion.",
+	"",
+	"Output EXACTLY the Markdown structure below: keep every section, in order. Use terse bullets, not prose paragraphs. Write \"(none)\" for an empty section — never drop a section.",
+	"",
+	"## Original Request and Intent",
+	"- [the user's original and evolving goals; quote verbatim where the exact wording matters]",
+	"",
+	"## Retired Exploration — DO NOT TRUST",
+	"- [one or two bullets naming what was attempted above and why it was wrong or abandoned]",
+	"",
+	"## Authoritative Conclusion",
+	"- [what is actually true now, or the correct next step]",
+	"",
+	"## Carried-Forward Facts",
+	"- [only facts from above that are STILL TRUE and still needed: file paths, identifiers, hard constraints, user preferences, explicit user instructions]",
+	"",
+	"## Next Step",
+	"- [the single next action in line with the most recent request, or \"(none)\"]",
+	"",
+	"Rules:",
+	"- Name the wrong conclusion ONLY as a rejected direction. Never restate it as a finding, and never re-derive it.",
+	"- Do NOT reproduce long transcripts, code dumps, or command output from the replaced span.",
+	"- Preserve exact file paths, commands, error strings, identifiers, numeric values, function signatures, and syntax fragments verbatim.",
+	"- Capture user feedback and explicit instructions faithfully, especially corrections.",
+	"- Be brief: this checkpoint must be much shorter than the span it replaces.",
+	"- Output only the checkpoint text: do not call any tool and do not take any other action.",
+	"- If the conversation already contains a <compacted-summary> block, it is a PRIOR checkpoint. Do not copy it forward verbatim: preserve still-true facts, drop stale ones, and merge everything into ONE consolidated checkpoint under the same structure."
+].join("\n");
+
+/** Reject visual output and keep only text, mirroring the shipped projection. */
+function summaryText(blocks) {
+	if (contentHasImage(blocks)) {
+		throw new LlmError("compaction summary cannot contain image output", "UNSUPPORTED_CONTENT");
+	}
+	return blocks.filter((block) => block.type === "text");
+}
+
+/**
+ * Map a terminal finish reason to the failure the shipped backend raises,
+ * mirroring `finishError` in `dsh-compaction-basic`.
+ */
+function finishError(finish) {
+	switch (finish.kind) {
+		case "error":
+		case "aborted":
+			return new LlmError(finish.failure.message, finish.failure.code, finish.failure);
+		case "max-tokens": {
+			const error = new Error("summarization truncated at the token cap (incomplete checkpoint)");
+			error.code = "MAX_TOKENS";
+			return error;
+		}
+		default:
+			return undefined;
+	}
+}
+
+/**
+ * Compaction backend that reuses the shipped engine's transaction, policy and
+ * metering, changing only the summarization directive.
+ *
+ * Inherited behavior is deliberate:
+ *   - `compactNow()`    — the idle-safe manual path behind `/compact` and `/prune`.
+ *   - `compactRegion()` — needs an open turn; never used by this plugin.
+ *   - automatic pressure / overflow recovery, token metering, shrink validation.
+ */
+export class CorrectiveCompactionEngine extends BasicCompactionEngine {
+	/**
+	 * Override the sole summarization hook to emit a correction checkpoint.
+	 *
+	 * Mirrors the shipped implementation's call shape so the provider's warm
+	 * prefix cache is still reused, but substitutes the corrective directive.
+	 *
+	 * @param input - replayed conversation prefix (system, tools, leading messages) to condense.
+	 * @param agent - supplies routed-model history and fallback model.
+	 * @param signal - optional cancellation forwarded to the adapter.
+	 * @returns safe text summary blocks plus the exact call envelope.
+	 */
+	async summarize(input, agent, signal) {
+		const config = this.config;
+		const latest = agent.session.requestHeader()?.config;
+		const configured =
+			config.summarizationProvider.length === 0
+				? undefined
+				: { provider: config.summarizationProvider, model: config.summarizationModel };
+		const agentTarget =
+			agent.options.provider !== undefined &&
+			agent.options.provider.length > 0 &&
+			agent.options.model !== undefined &&
+			agent.options.model.length > 0
+				? { provider: agent.options.provider, model: agent.options.model }
+				: undefined;
+		const target = configured ?? latest ?? agentTarget;
+		if (target === undefined) {
+			throw new Error(
+				"no provider/model available for summarization: set both summarization fields, route one request, or set both AgentOptions fields"
+			);
+		}
+
+		const instruction =
+			typeof this.correctiveInstruction === "string" && this.correctiveInstruction.length > 0
+				? this.correctiveInstruction
+				: DEFAULT_CORRECTIVE_INSTRUCTION;
+
+		const assembler = new BlockAssembler();
+		const messages = [
+			...input.messages,
+			deepFreeze({ role: "user", content: [{ type: "text", text: instruction }] })
+		];
+		const options = {
+			provider: target.provider,
+			model: target.model,
+			messages,
+			toolHistory: agent.session.toolHistory(),
+			...(input.tools === undefined ? {} : { tools: [...input.tools] }),
+			maxTokens: config.maxTokens,
+			sessionId: agent.session.id,
+			purpose: "compaction",
+			...(signal === undefined ? {} : { signal })
+		};
+
+		for await (const chunk of this.ctx.llm.stream(options)) assembler.push(chunk);
+		const error = finishError(assembler.finish);
+		if (error !== undefined) throw error;
+
+		const rawOutput = assembler.blocks();
+		const summary = summaryText(rawOutput);
+		if (!summary.some((block) => block.text.trim().length > 0)) {
+			throw new Error("summarization produced no text summary content");
+		}
+
+		return {
+			summary,
+			rawOutput,
+			llmStreamCall: true,
+			provider: options.provider,
+			model: options.model,
+			maxTokens: config.maxTokens,
+			...(assembler.usage === undefined ? {} : { usage: assembler.usage })
+		};
+	}
+}
+
+export default CorrectiveCompactionEngine;