dsh-context-mode 0.3.1 → 0.3.2

package/README.md

@@ -92,6 +92,38 @@ 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
+```
+
 ## 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/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.2",
   "description": "Expose context-mode MCP tools as native DeepSeek Harness tools",
   "keywords": [
     "dsh",
@@ -29,6 +29,7 @@
   },
   "files": [
     "lib",
+    "scripts/cleanup-injected.mjs",
     "skills",
     "vendor/context-mode/server.bundle.mjs",
     "vendor/context-mode/LICENSE",

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()