dsh-context-mode 0.3.1 → 0.3.3

package/README.md

@@ -92,6 +92,80 @@ only accepts its own platform ids, and `pi` is its neutral MCP-only id — every
 store stays DSH-owned: `CONTEXT_MODE_DIR` isolates DSH data and
 `CONTEXT_MODE_PROJECT_DIR` pins project hashing to the configured workspace.
 
+## Compaction archiving
+
+Compaction replaces the live conversation with a generated summary and prunes
+the events behind it, so anything the summary omits leaves the model's reach.
+The plugin listens for `compaction/start` and files the transcript into the
+knowledge base first, where `ctx_search` can still reach it afterwards.
+
+Storage is layered rather than filtered — every transcript event is archived,
+and the layers differ only in the `source` label they carry, so precision is
+chosen at query time instead of at write time:
+
+| Source | Contents |
+| --- | --- |
+| `session/<id>/constraint` | user messages — requirements, decisions, limits |
+| `session/<id>/finding` | tool results and assistant prose stating a concrete value |
+| `session/<id>/narrative` | remaining assistant prose — reasoning, plans |
+
+Nothing is dropped at write, so a misclassification costs a query's precision
+rather than the content itself. Harness-injected blocks (`<active_memory>`,
+`<current_runtime_context>`, `<system-reminder>`, `<resume_snapshot>`) are the
+one exception: they ride on `user/message`, are per-turn runtime noise rather
+than transcript, and are discarded before layering. Set `precompact: false` to
+turn archiving off entirely.
+
+Archives written before 0.3.2 may contain those injected blocks. A one-shot
+cleanup script removes them and leaves everything else alone:
+
+```sh
+node node_modules/dsh-context-mode/scripts/cleanup-injected.mjs --db <path>            # report only
+node node_modules/dsh-context-mode/scripts/cleanup-injected.mjs --db <path> --apply    # delete
+```
+
+## Checkpoint archive index
+
+A checkpoint keeps only a summary of the span it replaces, and the shipped
+checkpoint format has no section for tool output — a long tool result survives
+only as whatever the summarizing model chose to keep. `precompact` files that
+same span into the knowledge base beforehand, but nothing told the model so,
+and a summary that omits a detail reads as if the detail never existed.
+
+This package also exports a compaction engine that closes that gap. It extends
+the shipped `BasicCompactionEngine` and overrides only `summarize()`, appending
+an `## Archive Index` that names the archived sources:
+
+```ts
+import DshContextModeCompaction from 'dsh-context-mode/compaction'
+```
+
+Mount it in place of the shipped backend, inside the isolate group the shipped
+one requires:
+
+```yaml
+- id: compaction
+  name: cordis:group
+  group: true
+  isolate:
+    compaction: true
+    toolResultPruner: true
+  config:
+    - id: compaction-basic
+      name: 'dsh-context-mode/compaction'   # was @deepseek-ai/dsh-compaction-basic
+
+    - id: command-compact
+      name: '@deepseek-ai/dsh-command-compact'
+```
+
+Trigger policy, retention, the transaction bracket, token metering, and
+prefix-cache-aligned replay all stay on the shipped engine — only the returned
+summary text differs. The index is appended to the summary rather than injected
+into the summarization instruction, so the shipped output contract is untouched
+and no model has to follow an amended format. Failing to build the index
+returns the superseded summary unchanged, and restoring the shipped `name` row
+disables the index entirely.
+
 ## Development
 
 ```sh

package/lib/types/cjk.d.ts

@@ -14,13 +14,17 @@
  *
  *   - writes segment CJK runs into single characters separated by spaces,
  *     which makes `unicode61` emit one token per character;
- *   - queries segment identically and are joined as a phrase, so an adjacent
- *     query like "缓存方案" becomes the phrase `"缓 存 方 案"` and only
- *     matches documents where those characters appear adjacently.
- *
- * Phrase semantics matter: without the phrase the query would degrade to an
- * AND of single characters, matching any document that merely contains all of
- * them. See {@link buildCjkQuery}.
+ *   - queries segment identically, so "缓存方案" becomes the tokens
+ *     `缓 存 方 案` and the searcher can match them.
+ *
+ * The query side deliberately does NOT wrap the segmented run in a phrase.
+ * Phrase semantics were tried first and made retrieval worse: a document
+ * saying "缓存走本地文件" and a query saying "缓存方案用什么" share the
+ * prefix but diverge immediately, so an adjacency requirement rejects the
+ * result a caller actually wanted. Emitting single tokens instead lets
+ * upstream's `sanitizeQuery` build an AND expression, and BM25 ranks the
+ * document that shares more characters first, which is the ranking a
+ * character-based index can honestly provide. See {@link buildCjkQuery}.
  */
 /** Return whether a string contains any character that needs segmentation. */
 export declare function hasCjk(value: string): boolean;

package/lib/types/cjk.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cjk.d.ts","sourceRoot":"","sources":["../../src/cjk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAOH,8EAA8E;AAC9E,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE7C;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGhD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEnD"}
+{"version":3,"file":"cjk.d.ts","sourceRoot":"","sources":["../../src/cjk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAOH,8EAA8E;AAC9E,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE7C;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGhD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEnD"}

package/lib/types/cjk.js

@@ -14,13 +14,17 @@
  *
  *   - writes segment CJK runs into single characters separated by spaces,
  *     which makes `unicode61` emit one token per character;
- *   - queries segment identically and are joined as a phrase, so an adjacent
- *     query like "缓存方案" becomes the phrase `"缓 存 方 案"` and only
- *     matches documents where those characters appear adjacently.
+ *   - queries segment identically, so "缓存方案" becomes the tokens
+ *     `缓 存 方 案` and the searcher can match them.
  *
- * Phrase semantics matter: without the phrase the query would degrade to an
- * AND of single characters, matching any document that merely contains all of
- * them. See {@link buildCjkQuery}.
+ * The query side deliberately does NOT wrap the segmented run in a phrase.
+ * Phrase semantics were tried first and made retrieval worse: a document
+ * saying "缓存走本地文件" and a query saying "缓存方案用什么" share the
+ * prefix but diverge immediately, so an adjacency requirement rejects the
+ * result a caller actually wanted. Emitting single tokens instead lets
+ * upstream's `sanitizeQuery` build an AND expression, and BM25 ranks the
+ * document that shares more characters first, which is the ranking a
+ * character-based index can honestly provide. See {@link buildCjkQuery}.
  */
 /** Han, Hiragana, Katakana, and Hangul ranges that need segmentation. */
 const CJK_PATTERN = /[\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\uac00-\ud7af]/;

package/lib/types/compaction.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Compaction backend that appends an archive index to every checkpoint.
+ *
+ * DSH's shipped backend condenses an older span of the conversation into a
+ * summary and lets the raw events fall out of the derived history. The summary
+ * is lossy by design: its instruction fixes the sections a checkpoint may
+ * carry, and tool output has no section of its own, so a long tool result
+ * survives only as whatever the summarizing model chose to keep.
+ *
+ * This plugin's `precompact` listener files the same span into the
+ * context-mode knowledge base first, so the detail still exists and
+ * `ctx_search` can reach it. What it cannot do from outside is tell the model
+ * that — the checkpoint text is written here, inside the engine, and the
+ * shipped engine has no reason to mention a knowledge base it does not know
+ * about. That is the gap this subclass closes.
+ *
+ * Two deliberate choices keep the risk low:
+ *
+ *   - Only `summarize()` is overridden. Trigger policy, retention, the
+ *     bracket-first transaction, token metering, and KV-cache-aligned replay
+ *     all stay on the shipped implementation, so this cannot diverge from the
+ *     behavior the rest of DSH expects.
+ *   - The index is appended to the *returned* summary, never injected into the
+ *     summarization instruction. The summarizing model never sees this text,
+ *     so the shipped output contract ("keep every section, in order") stays
+ *     intact and no model has to be trusted to follow an amended format.
+ *
+ * Nothing here is allowed to fail a compaction: if the index cannot be built,
+ * the superseded summary is returned unchanged.
+ *
+ * @module dsh-context-mode/compaction
+ */
+import type { ContentBlock } from '@deepseek-ai/dsh-llm';
+import { BasicCompactionEngine } from '@deepseek-ai/dsh-compaction-basic';
+/**
+ * The shipped summarization input and result types, derived from the base
+ * class rather than restated.
+ *
+ * The package does not re-export them from its root, and deep-importing its
+ * private `lib/types/summarizer.js` path would break on any internal move.
+ * Deriving from the method signature keeps this module aligned with whatever
+ * the installed version declares, and needs no import of its own.
+ */
+type SummarizeArgs = Parameters<BasicCompactionEngine['summarize']>;
+type SummarizedResult = Awaited<ReturnType<BasicCompactionEngine['summarize']>>;
+/** Session-event shapes this module reads. */
+interface SessionEventLike {
+    readonly type: string;
+    readonly seq?: number;
+    readonly data?: unknown;
+}
+interface SessionLike {
+    readonly id?: string;
+    snapshotEvents(): readonly SessionEventLike[];
+}
+interface AgentLike {
+    readonly session?: SessionLike;
+}
+/**
+ * A compaction engine that names the session archive in each checkpoint.
+ *
+ * Constructed by DSH exactly like the shipped engine it extends, so the row
+ * that mounts it needs no additional wiring.
+ */
+export declare class DshContextModeCompaction extends BasicCompactionEngine {
+    /**
+     * Summarize the replayed region, then append the archive index.
+     *
+     * The index is appended after `super.summarize()` resolves, so the shipped
+     * call — and therefore prefix-cache alignment, token accounting, and the
+     * returned `SummaryResult` envelope — are unchanged.
+     */
+    protected summarize(input: SummarizeArgs[0], agent: SummarizeArgs[1], signal?: SummarizeArgs[2]): Promise<SummarizedResult>;
+}
+/**
+ * Build the archive-index block for one agent's session.
+ *
+ * The source labels are derivable without waiting on the archiver: the
+ * `precompact` listener files each layer under `session/<id>/<layer>`, and the
+ * session id is available here. The index therefore states *where* the detail
+ * lives rather than claiming anything about what it contains.
+ *
+ * @param agent - owner of the session being compacted.
+ * @returns the markdown block, or an empty string when no session is reachable.
+ */
+export declare function buildArchiveIndex(agent: AgentLike): string;
+/**
+ * Append an index block to the text of a summary.
+ *
+ * Only text blocks are touched. A summary may also carry non-text blocks, and
+ * rewriting or dropping those is the shipped engine's business, not this
+ * module's; they are copied through untouched.
+ *
+ * @param summary - the superseded summary blocks.
+ * @param index - the block to append.
+ * @returns new blocks with the index appended to the trailing text.
+ */
+export declare function appendToSummary(summary: readonly ContentBlock[], index: string): ContentBlock[];
+export default DshContextModeCompaction;
+//# sourceMappingURL=compaction.d.ts.map

package/lib/types/compaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compaction.d.ts","sourceRoot":"","sources":["../../src/compaction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AACxD,OAAO,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAA;AAEzE;;;;;;;;GAQG;AACH,KAAK,aAAa,GAAG,UAAU,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC,CAAA;AACnE,KAAK,gBAAgB,GAAG,OAAO,CAAC,UAAU,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC,CAAC,CAAA;AAQ/E,8CAA8C;AAC9C,UAAU,gBAAgB;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CACxB;AAED,UAAU,WAAW;IACnB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAA;IACpB,cAAc,IAAI,SAAS,gBAAgB,EAAE,CAAA;CAC9C;AAED,UAAU,SAAS;IACjB,QAAQ,CAAC,OAAO,CAAC,EAAE,WAAW,CAAA;CAC/B;AAED;;;;;GAKG;AACH,qBAAa,wBAAyB,SAAQ,qBAAqB;IACjE;;;;;;OAMG;cACsB,SAAS,CAChC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,GACxB,OAAO,CAAC,gBAAgB,CAAC;CAY7B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAuB1D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,KAAK,EAAE,MAAM,GACZ,YAAY,EAAE,CAUhB;AAED,eAAe,wBAAwB,CAAA"}

package/lib/types/compaction.js

@@ -0,0 +1,94 @@
+import { BasicCompactionEngine } from '@deepseek-ai/dsh-compaction-basic';
+/** Heading of the appended section. Kept short; it costs context on every later request. */
+const INDEX_HEADING = '## Archive Index';
+/** Upper bound on the appended section, so a checkpoint can never be grown without limit. */
+const MAX_INDEX_CHARS = 1_200;
+/**
+ * A compaction engine that names the session archive in each checkpoint.
+ *
+ * Constructed by DSH exactly like the shipped engine it extends, so the row
+ * that mounts it needs no additional wiring.
+ */
+export class DshContextModeCompaction extends BasicCompactionEngine {
+    /**
+     * Summarize the replayed region, then append the archive index.
+     *
+     * The index is appended after `super.summarize()` resolves, so the shipped
+     * call — and therefore prefix-cache alignment, token accounting, and the
+     * returned `SummaryResult` envelope — are unchanged.
+     */
+    async summarize(input, agent, signal) {
+        const result = await super.summarize(input, agent, signal);
+        try {
+            const index = buildArchiveIndex(agent);
+            if (index.length === 0)
+                return result;
+            return { ...result, summary: appendToSummary(result.summary, index) };
+        }
+        catch {
+            // An index is an improvement, never a requirement: a failure here must
+            // not turn into a failed compaction.
+            return result;
+        }
+    }
+}
+/**
+ * Build the archive-index block for one agent's session.
+ *
+ * The source labels are derivable without waiting on the archiver: the
+ * `precompact` listener files each layer under `session/<id>/<layer>`, and the
+ * session id is available here. The index therefore states *where* the detail
+ * lives rather than claiming anything about what it contains.
+ *
+ * @param agent - owner of the session being compacted.
+ * @returns the markdown block, or an empty string when no session is reachable.
+ */
+export function buildArchiveIndex(agent) {
+    const session = agent.session;
+    if (session === undefined)
+        return '';
+    const id = session.id;
+    if (typeof id !== 'string' || id.length === 0)
+        return '';
+    const base = `session/${id}`;
+    const lines = [
+        INDEX_HEADING,
+        '',
+        'The raw transcript of this span was archived to the context-mode knowledge',
+        'base before it was condensed, so detail the summary above omits is still',
+        'retrievable with `ctx_search`. Scope each query to one layer by `source`:',
+        '',
+        `- \`source: "${base}/constraint"\` — user messages: requirements, decisions, limits`,
+        `- \`source: "${base}/finding"\` — tool results and stated conclusions`,
+        `- \`source: "${base}/narrative"\` — assistant reasoning and plans`,
+        '',
+        'Search for a concrete token you expect in the original (a command, an error',
+        'string, a path, an identifier) rather than a paraphrase of the question.',
+    ];
+    const block = lines.join('\n');
+    return block.length <= MAX_INDEX_CHARS ? block : `${block.slice(0, MAX_INDEX_CHARS - 1)}…`;
+}
+/**
+ * Append an index block to the text of a summary.
+ *
+ * Only text blocks are touched. A summary may also carry non-text blocks, and
+ * rewriting or dropping those is the shipped engine's business, not this
+ * module's; they are copied through untouched.
+ *
+ * @param summary - the superseded summary blocks.
+ * @param index - the block to append.
+ * @returns new blocks with the index appended to the trailing text.
+ */
+export function appendToSummary(summary, index) {
+    const blocks = summary.map(block => ({ ...block }));
+    for (let position = blocks.length - 1; position >= 0; position -= 1) {
+        const block = blocks[position];
+        if (block.type !== 'text' || typeof block.text !== 'string')
+            continue;
+        blocks[position] = { ...block, text: `${block.text}\n\n${index}` };
+        return blocks;
+    }
+    // A summary with no text block at all: add one rather than dropping the index.
+    return [...blocks, { type: 'text', text: index }];
+}
+export default DshContextModeCompaction;

package/lib/types/precompact.d.ts

@@ -75,6 +75,29 @@ export declare function installPrecompactArchive(ctx: Context, getClient: () =>
  * reached are searchable beside the evidence.
  */
 export declare function classify(events: readonly SessionEventLike[]): ArchivedLine[];
+/**
+ * Whether a message body is harness-injected context rather than transcript.
+ *
+ * DSH attaches `<current_runtime_context>`, `<active_memory>`,
+ * `<system-reminder>`, and `<resume_snapshot>` blocks to user messages, so
+ * they arrive with the same `user/message` type as a genuine user turn. They
+ * are per-turn runtime noise, not requirements or decisions: filing them under
+ * `constraint` both dilutes that layer and returns stale policy snapshots for
+ * policy-shaped queries. `<active_memory>` is also a second-hand summary of
+ * events that are archived directly, so keeping it would store the same facts
+ * twice.
+ *
+ * The check has to cover two shapes. The tag form is what the model sees when
+ * a block is inlined whole, but `textOf` reads only the text blocks of a
+ * message, so a block's opening tag can be stripped before this point and the
+ * body then begins with the injected block's own heading — the transcripts
+ * this was written against start with "Current runtime context." rather than
+ * with a tag. Matching the headings as well keeps those from being filed.
+ *
+ * A body qualifies only when an injected marker *starts* the message, so a
+ * user who quotes one of these tags mid-sentence is still archived.
+ */
+export declare function isInjectedContext(text: string): boolean;
 /**
  * Whether assistant prose states a value worth retrieving on its own.
  *

package/lib/types/precompact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"precompact.d.ts","sourceRoot":"","sources":["../../src/precompact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAGrD,+DAA+D;AAC/D,eAAO,MAAM,MAAM;;;;CAIT,CAAA;AAEV,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,MAAM,CAAC,CAAC,MAAM,OAAO,MAAM,CAAC,CAAA;AAE5D,qDAAqD;AACrD,MAAM,WAAW,iBAAiB;IAChC,iCAAiC;IACjC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;IAC1B,iFAAiF;IACjF,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;CACnC;AAED,UAAU,gBAAgB;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CACxB;AAYD,6EAA6E;AAC7E,UAAU,YAAY;IACpB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAcD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,OAAO,EACZ,SAAS,EAAE,MAAM,cAAc,GAAG,SAAS,EAC3C,OAAO,GAAE,iBAAsB,GAC9B,MAAM,IAAI,CAiCZ;AA+CD;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,gBAAgB,EAAE,GAAG,YAAY,EAAE,CAU5E;AAYD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAO1D;AAcD,mFAAmF;AACnF,wBAAgB,MAAM,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAwBtD;AAWD,wEAAwE;AACxE,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE3C;AAaD,6EAA6E;AAC7E,MAAM,MAAM,aAAa,GAAG,YAAY,CAAA"}
+{"version":3,"file":"precompact.d.ts","sourceRoot":"","sources":["../../src/precompact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAGrD,+DAA+D;AAC/D,eAAO,MAAM,MAAM;;;;CAIT,CAAA;AAEV,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,MAAM,CAAC,CAAC,MAAM,OAAO,MAAM,CAAC,CAAA;AAE5D,qDAAqD;AACrD,MAAM,WAAW,iBAAiB;IAChC,iCAAiC;IACjC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;IAC1B,iFAAiF;IACjF,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;CACnC;AAED,UAAU,gBAAgB;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CACxB;AAYD,6EAA6E;AAC7E,UAAU,YAAY;IACpB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAcD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,OAAO,EACZ,SAAS,EAAE,MAAM,cAAc,GAAG,SAAS,EAC3C,OAAO,GAAE,iBAAsB,GAC9B,MAAM,IAAI,CAiCZ;AA+CD;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,gBAAgB,EAAE,GAAG,YAAY,EAAE,CAW5E;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AAoBD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAO1D;AAcD,mFAAmF;AACnF,wBAAgB,MAAM,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAwBtD;AAWD,wEAAwE;AACxE,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE3C;AAaD,6EAA6E;AAC7E,MAAM,MAAM,aAAa,GAAG,YAAY,CAAA"}

package/lib/types/precompact.js

@@ -136,6 +136,8 @@ export function classify(events) {
         const text = textOf(event);
         if (text.length === 0)
             continue;
+        if (isInjectedContext(text))
+            continue;
         const layer = layerOf(event.type, text);
         if (layer === undefined)
             continue;
@@ -143,6 +145,36 @@ export function classify(events) {
     }
     return lines;
 }
+/**
+ * Whether a message body is harness-injected context rather than transcript.
+ *
+ * DSH attaches `<current_runtime_context>`, `<active_memory>`,
+ * `<system-reminder>`, and `<resume_snapshot>` blocks to user messages, so
+ * they arrive with the same `user/message` type as a genuine user turn. They
+ * are per-turn runtime noise, not requirements or decisions: filing them under
+ * `constraint` both dilutes that layer and returns stale policy snapshots for
+ * policy-shaped queries. `<active_memory>` is also a second-hand summary of
+ * events that are archived directly, so keeping it would store the same facts
+ * twice.
+ *
+ * The check has to cover two shapes. The tag form is what the model sees when
+ * a block is inlined whole, but `textOf` reads only the text blocks of a
+ * message, so a block's opening tag can be stripped before this point and the
+ * body then begins with the injected block's own heading — the transcripts
+ * this was written against start with "Current runtime context." rather than
+ * with a tag. Matching the headings as well keeps those from being filed.
+ *
+ * A body qualifies only when an injected marker *starts* the message, so a
+ * user who quotes one of these tags mid-sentence is still archived.
+ */
+export function isInjectedContext(text) {
+    return INJECTED_CONTEXT_PATTERN.test(text);
+}
+const INJECTED_CONTEXT_PATTERN = new RegExp('^\\s*(?:' +
+    '<(?:current_runtime_context|active_memory|system-reminder|resume_snapshot)\\b' +
+    '|Current runtime context\\b' +
+    '|The available skill catalog changed\\b' +
+    ')');
 /** Return the layer for one event, or undefined when it carries no transcript value. */
 function layerOf(type, text) {
     if (type === 'user/message')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-context-mode",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Expose context-mode MCP tools as native DeepSeek Harness tools",
   "keywords": [
     "dsh",
@@ -24,11 +24,16 @@
       "types": "./lib/types/index.d.ts",
       "import": "./lib/types/index.js"
     },
+    "./compaction": {
+      "types": "./lib/types/compaction.d.ts",
+      "import": "./lib/types/compaction.js"
+    },
     "./package.json": "./package.json",
     "./cordis.patch.yml": "./cordis.patch.yml"
   },
   "files": [
     "lib",
+    "scripts/cleanup-injected.mjs",
     "skills",
     "vendor/context-mode/server.bundle.mjs",
     "vendor/context-mode/LICENSE",
@@ -58,16 +63,24 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-compaction-basic": "^0.1.5-rc.2",
     "@deepseek-ai/dsh-llm": "^0.1.5-rc.2",
     "@deepseek-ai/dsh-system-prompt": "^0.1.5-rc.2",
     "@deepseek-ai/dsh-tools": "^0.1.5-rc.2"
   },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-compaction-basic": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-agent": "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-skill": "^0.1.5-rc.2",
     "@deepseek-ai/dsh-system-prompt": "^0.1.5-rc.2",
     "@deepseek-ai/dsh-tools": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-skill": "^0.1.5-rc.2",
     "@types/node": "^22.0.0",
     "typescript": "^6.0.3"
   }

package/scripts/cleanup-injected.mjs

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+/**
+ * Remove harness-injected context blocks that earlier builds filed as
+ * constraints.
+ *
+ * Before `isInjectedContext` existed, `precompact` classified purely on event
+ * type, so the `<current_runtime_context>` / `<active_memory>` blocks DSH
+ * attaches to user messages were archived as `session/<id>/constraint` — the
+ * layer meant to hold requirements and decisions. Those rows are runtime
+ * noise, and they are stale policy snapshots besides.
+ *
+ * Scope is deliberately narrow. A row is only a candidate when it lives in an
+ * archived session layer AND carries an injected marker immediately after the
+ * archive's own `## [layer] party (seq N)` heading. A document or source file
+ * that merely *mentions* `active_memory` (the plugin's own sources do) keeps
+ * its row, because such a match is never preceded by an archive heading.
+ *
+ * Usage:
+ *   node scripts/cleanup-injected.mjs --db <path> [--apply]
+ *
+ * Without `--apply` nothing is written; the script only reports what it would
+ * delete. Both FTS5 tables are cleaned together, since `chunks` and
+ * `chunks_trigram` hold the same logical rows and would otherwise disagree.
+ */
+import { DatabaseSync } from 'node:sqlite'
+import { existsSync } from 'node:fs'
+
+const args = process.argv.slice(2)
+const apply = args.includes('--apply')
+const dbIndex = args.indexOf('--db')
+const dbPath = dbIndex >= 0 ? args[dbIndex + 1] : undefined
+
+if (dbPath === undefined) {
+  console.error('usage: node scripts/cleanup-injected.mjs --db <path> [--apply]')
+  process.exit(2)
+}
+if (!existsSync(dbPath)) {
+  console.error(`database not found: ${dbPath}`)
+  process.exit(2)
+}
+
+/** Markers that identify a harness-injected block, matched after the heading. */
+const MARKERS = [
+  '<current_runtime_context',
+  '<active_memory',
+  '<system-reminder',
+  '<resume_snapshot',
+  'Current runtime context',
+  'The available skill catalog changed',
+]
+
+/** Archive headings look like `## [约束] 用户 (seq 2766)`. */
+const heading = '## [%'
+const patterns = MARKERS.map(marker => `${heading}%${marker}%`)
+
+/** Build the content predicate for one table alias. */
+const clausesFor = alias => MARKERS.map(() => `(${alias}.content LIKE ?)`).join(' OR ')
+
+const selectSql = `
+  SELECT c.rowid AS rowid, s.label AS label, c.content AS content
+  FROM chunks c
+  JOIN sources s ON s.id = c.source_id
+  WHERE s.label LIKE 'session/%'
+    AND (${clausesFor('c')})
+`
+
+const db = new DatabaseSync(dbPath)
+const rows = db.prepare(selectSql).all(...patterns)
+
+// `chunks_trigram` mirrors `chunks`; the same logical row has a different
+// rowid per table, so the trigram side is matched by content within the same
+// session-scoped sources.
+const trigramSql = `
+  SELECT t.rowid AS rowid, s.label AS label, t.content AS content
+  FROM chunks_trigram t
+  JOIN sources s ON s.id = t.source_id
+  WHERE s.label LIKE 'session/%'
+    AND (${clausesFor('t')})
+`
+const trigramRows = db.prepare(trigramSql).all(...patterns)
+
+console.log(`mode: ${apply ? 'APPLY' : 'DRY RUN'}`)
+console.log(`database: ${dbPath}`)
+console.log(`chunks rows matched: ${rows.length}`)
+console.log(`chunks_trigram rows matched: ${trigramRows.length}`)
+
+for (const row of rows) {
+  const preview = row.content.replace(/\s+/g, ' ').slice(0, 96)
+  console.log(`  [${row.rowid}] ${row.label}\n      ${preview}`)
+}
+
+if (rows.length === 0 && trigramRows.length === 0) {
+  console.log('\nnothing to clean')
+  db.close()
+  process.exit(0)
+}
+
+if (!apply) {
+  console.log('\ndry run only — re-run with --apply to delete these rows')
+  db.close()
+  process.exit(0)
+}
+
+db.exec('BEGIN')
+try {
+  const delChunks = db.prepare('DELETE FROM chunks WHERE rowid = ?')
+  for (const row of rows) delChunks.run(row.rowid)
+  const delTrigram = db.prepare('DELETE FROM chunks_trigram WHERE rowid = ?')
+  for (const row of trigramRows) delTrigram.run(row.rowid)
+  db.exec('COMMIT')
+} catch (error) {
+  db.exec('ROLLBACK')
+  console.error('cleanup failed, rolled back:', error)
+  db.close()
+  process.exit(1)
+}
+
+// `sources.chunk_count` is a cached tally; recompute it for the labels touched
+// so the bookkeeping matches the rows that remain.
+const touched = new Set([...rows, ...trigramRows].map(row => row.label))
+const recount = db.prepare(`
+  UPDATE sources
+  SET chunk_count = (
+    SELECT COUNT(*) FROM chunks c WHERE c.source_id = sources.id
+  )
+  WHERE label = ?
+`)
+for (const label of touched) recount.run(label)
+
+// Reclaim the space freed by the deletes.
+db.exec("INSERT INTO chunks(chunks) VALUES('optimize')")
+db.exec("INSERT INTO chunks_trigram(chunks_trigram) VALUES('optimize')")
+
+console.log(`\ndeleted ${rows.length} + ${trigramRows.length} rows, recounted ${touched.size} source(s)`)
+db.close()