@aiwayds/dsh-dcp 0.5.0 → 0.5.1

package/lib/index.js

@@ -39,6 +39,28 @@ import { registerDcpCommand } from './command.js'
 const require = createRequire(import.meta.url)
 const { version: VERSION } = require('../package.json')
 
+/**
+ * Per-engine state uses module-scoped symbol keys, never `#private` members.
+ * Cordis hands services to consuming fibers through derived receivers —
+ * `ctx.mixin` binds methods to a withProps proxy and `createTraceable` calls
+ * them on Object.create-derived shadows — so `/compact` and `/dcp compact`
+ * (both `ctx.compaction.compactNow(...)`) routinely execute engine methods
+ * with a `this` this class's constructor never initialized. Private members
+ * brand-check against exactly that and throw
+ * "Cannot read private member #triggerLabels from an object whose class did
+ * not declare it", while symbol lookups traverse those receivers to this
+ * instance's own state.
+ */
+const kRounds = Symbol('dsh-dcp.rounds')
+const kTriggerLabels = Symbol('dsh-dcp.triggerLabels')
+const kRoundInFlight = Symbol('dsh-dcp.roundInFlight')
+const kSessionStats = Symbol('dsh-dcp.sessionStats')
+const kRegisterRoundTrigger = Symbol('dsh-dcp.registerRoundTrigger')
+const kMaybeRoundCompact = Symbol('dsh-dcp.maybeRoundCompact')
+const kRecordStats = Symbol('dsh-dcp.recordStats')
+const kRecordSessionStats = Symbol('dsh-dcp.recordSessionStats')
+const kAppendNotice = Symbol('dsh-dcp.appendNotice')
+
 /**
  * Deterministic compaction engine: `summarize()` overridden, everything else
  * inherited. Registers the `/dcp` command beside the inherited `/compact`.
@@ -94,38 +116,20 @@ export class DcpEngine extends BasicCompactionEngine {
   /** Absolute module path, echoed by `/dcp set` for persistence snippets. */
   pluginPath
 
-  /**
-   * Completed-assistant-message counters since the last dsh-dcp compaction,
-   * per session — one "round" is one `assistant/message` (one LLM roundtrip).
-   * Weak keys: disposed sessions (including one-shot subagents) drop out with
-   * the object.
-   */
-  #rounds = new WeakMap()
-
-  /**
-   * Sessions whose next `compactNow` is a round-interval trigger rather than
-   * a manual command. Only {@link DcpEngine.#maybeRoundCompact} writes;
-   * `compactNow` reads and clears its own entry, so a stale marker can only
-   * turn a manual compaction into a labeled `'round'` one — never the reverse.
-   */
-  #triggerLabels = new WeakMap()
-
-  /** Sessions with a round-triggered compaction still in flight. */
-  #roundInFlight = new WeakSet()
-
-  /**
-   * Per-session compaction records: one entry per session that committed at
-   * least one compaction, counting the compactions and the shadowed tokens.
-   * Weak keys (mirroring `#rounds`): disposed sessions — including one-shot
-   * subagents — drop out with the object. Not enumerated directly, because a
-   * WeakMap leaks nothing and lists nothing; `/dcp` walks the sessions
-   * service and looks each live session up here.
-   */
-  #sessionStats = new WeakMap()
-
   constructor(ctx, config = {}) {
     const { basic, dcp } = splitConfig(config)
     super(ctx, basic)
+    // Constructor assignments, not class fields: Node 26's V8 silently drops
+    // every symbol-keyed class field after the first one in a derived class
+    // (plain string-keyed and base-class fields are unaffected).
+    /** Per-session assistant-message counters since the last dsh-dcp compaction. */
+    this[kRounds] = new WeakMap()
+    /** Sessions whose next `compactNow` is a round-interval trigger, not manual. */
+    this[kTriggerLabels] = new WeakMap()
+    /** Sessions with a round-triggered compaction still in flight. */
+    this[kRoundInFlight] = new WeakSet()
+    /** Per-session compaction records for `/dcp` (weak so disposed sessions drop out). */
+    this[kSessionStats] = new WeakMap()
     this.dcp = { ...resolveDcpConfig(dcp) }
     this.dcpStats = { compactions: 0, shadowedTokens: 0, lastAt: null }
     this.pluginPath = fileURLToPath(import.meta.url)
@@ -133,7 +137,7 @@ export class DcpEngine extends BasicCompactionEngine {
     ctx.effect(function* () {
       yield registerDcpCommand(ctx, engine, VERSION)
     }, 'dsh-dcp /dcp command lifecycle')
-    if (this.config.auto) this.#registerRoundTrigger()
+    if (this.config.auto) this[kRegisterRoundTrigger]()
   }
 
   /**
@@ -145,7 +149,7 @@ export class DcpEngine extends BasicCompactionEngine {
    * like the top-level session — and because one-shot subagents emit many
    * assistant messages inside a single turn, they now trigger too.
    */
-  #registerRoundTrigger() {
+  [kRegisterRoundTrigger]() {
     const { ctx } = this
     ctx.on('session/event', (session, event) => {
       // Counting is skipped while disabled, but the listener stays registered
@@ -155,10 +159,10 @@ export class DcpEngine extends BasicCompactionEngine {
       // counting it (instead of completed turns) also covers one-shot
       // subagents, whose whole run is a single turn with many model calls.
       if (event.type !== 'assistant/message') return
-      this.#rounds.set(session, (this.#rounds.get(session) ?? 0) + 1)
+      this[kRounds].set(session, (this[kRounds].get(session) ?? 0) + 1)
     })
     ctx.on('agent/status', ({ agent, status }) => {
-      if (status === 'idle') this.#maybeRoundCompact(agent)
+      if (status === 'idle') this[kMaybeRoundCompact](agent)
     })
   }
 
@@ -170,17 +174,17 @@ export class DcpEngine extends BasicCompactionEngine {
    * must not cancel the N assistant messages behind it. Any other failure warns
    * and releases the boundary: the pressure trigger remains the safety net.
    */
-  #maybeRoundCompact(agent) {
+  [kMaybeRoundCompact](agent) {
     const interval = this.dcp.roundInterval
     if (!interval) return
     const session = agent?.session
-    if (session === undefined || this.#roundInFlight.has(session)) return
-    if ((this.#rounds.get(session) ?? 0) < interval) return
-    this.#triggerLabels.set(session, 'round')
-    this.#roundInFlight.add(session)
-    const settle = () => this.#roundInFlight.delete(session)
+    if (session === undefined || this[kRoundInFlight].has(session)) return
+    if ((this[kRounds].get(session) ?? 0) < interval) return
+    this[kTriggerLabels].set(session, 'round')
+    this[kRoundInFlight].add(session)
+    const settle = () => this[kRoundInFlight].delete(session)
     const consume = () => {
-      this.#rounds.delete(session)
+      this[kRounds].delete(session)
       settle()
     }
     void this.compactNow(agent, new AbortController().signal).then(consume, (error) => {
@@ -217,7 +221,7 @@ export class DcpEngine extends BasicCompactionEngine {
   async compactIfNeeded(agent, trigger, signal) {
     const label = trigger === 'context-overflow' ? 'overflow' : 'auto'
     const result = await super.compactIfNeeded(agent, trigger, signal)
-    if (result !== null) this.#appendNotice(agent.session, result, label)
+    if (result !== null) this[kAppendNotice](agent.session, result, label)
     return result
   }
 
@@ -229,25 +233,25 @@ export class DcpEngine extends BasicCompactionEngine {
    */
   async compactNow(agent, signal, sourceCommandId) {
     const session = agent.session
-    const trigger = this.#triggerLabels.get(session) === 'round' ? 'round' : 'manual'
+    const trigger = this[kTriggerLabels].get(session) === 'round' ? 'round' : 'manual'
     try {
       const result = await super.compactNow(agent, signal, sourceCommandId)
       // `null` means no useful range existed: release the round counter so an
       // early-session interval boundary cannot retry every idle boundary.
       // Manual compactions share the release: a user-driven compact restarts
       // interval counting whether or not it found anything to compact.
-      if (result === null) this.#rounds.delete(session)
+      if (result === null) this[kRounds].delete(session)
       else this.recordCompaction(session, result, trigger)
       return result
     } finally {
-      this.#triggerLabels.delete(session)
+      this[kTriggerLabels].delete(session)
     }
   }
 
   /** Stats and round-counter restart for every committed region. */
   async compactRegion(start, end, agent, signal) {
     const result = await super.compactRegion(start, end, agent, signal)
-    this.#recordStats(agent.session, result)
+    this[kRecordStats](agent.session, result)
     return result
   }
 
@@ -255,12 +259,12 @@ export class DcpEngine extends BasicCompactionEngine {
    * Record one committed compaction: bump the `/dcp` counters and restart the
    * round-interval counting.
    */
-  #recordStats(session, result) {
+  [kRecordStats](session, result) {
     this.dcpStats.compactions += 1
     this.dcpStats.shadowedTokens += result.shadowedTokenCount
     this.dcpStats.lastAt = Date.now()
-    this.#rounds.delete(session)
-    this.#recordSessionStats(session, result.shadowedTokenCount)
+    this[kRounds].delete(session)
+    this[kRecordSessionStats](session, result.shadowedTokenCount)
   }
 
   /**
@@ -268,12 +272,12 @@ export class DcpEngine extends BasicCompactionEngine {
    * must be objects, so a session-less recording (should not happen) is
    * skipped rather than thrown on.
    */
-  #recordSessionStats(session, shadowedTokenCount) {
+  [kRecordSessionStats](session, shadowedTokenCount) {
     if (session === undefined || session === null || typeof session !== 'object') return
-    const entry = this.#sessionStats.get(session) ?? { compactions: 0, shadowedTokens: 0 }
+    const entry = this[kSessionStats].get(session) ?? { compactions: 0, shadowedTokens: 0 }
     entry.compactions += 1
     entry.shadowedTokens += shadowedTokenCount
-    this.#sessionStats.set(session, entry)
+    this[kSessionStats].set(session, entry)
   }
 
   /**
@@ -281,7 +285,7 @@ export class DcpEngine extends BasicCompactionEngine {
    * is a `notice`-form plugin message, so every dsh frontend renders it as a
    * collapsed transcript row, live and on replay.
    */
-  #appendNotice(session, result, trigger) {
+  [kAppendNotice](session, result, trigger) {
     if (!this.dcp.notice) return
     const summary = boundContextSummary(noticeText(this.dcp.language, result.shadowedSeqs.length, result.shadowedTokenCount, trigger))
     try {
@@ -303,10 +307,11 @@ export class DcpEngine extends BasicCompactionEngine {
    *
    * Internal seam: `compactNow` calls it after its durable commit; tests
    * drive it directly instead of mocking the upstream region machinery.
+   * Public-named but not part of the dsh compaction contract.
    */
   recordCompaction(session, result, trigger) {
-    this.#recordStats(session, result)
-    this.#appendNotice(session, result, trigger)
+    this[kRecordStats](session, result)
+    this[kAppendNotice](session, result, trigger)
   }
 
   /**
@@ -323,7 +328,7 @@ export class DcpEngine extends BasicCompactionEngine {
     // Services live on ctx for a cordis plugin instance (`inject` only
     // declares them); this.sessions is undefined in production.
     for (const session of this.ctx.sessions?.list?.() ?? []) {
-      const entry = this.#sessionStats.get(session)
+      const entry = this[kSessionStats].get(session)
       if (entry === undefined) continue
       overview.push({
         id: session.header?.id ?? '<unknown>',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwayds/dsh-dcp",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Deterministic context-pruning compaction backend for dsh (DeepSeek Harness) — zero-LLM summaries, /dcp command, works out of the box. Design references Opencode-DCP/opencode-dynamic-context-pruning.",
   "type": "module",
   "main": "lib/index.js",
@@ -62,18 +62,42 @@
     "@deepseek-ai/schemastery": "^3.18.1"
   },
   "peerDependenciesMeta": {
-    "@deepseek-ai/cordis": { "optional": true },
-    "@deepseek-ai/dsh-agent": { "optional": true },
-    "@deepseek-ai/dsh-brand": { "optional": true },
-    "@deepseek-ai/dsh-commands": { "optional": true },
-    "@deepseek-ai/dsh-compaction": { "optional": true },
-    "@deepseek-ai/dsh-compaction-basic": { "optional": true },
-    "@deepseek-ai/dsh-compaction-tool-result-pruner": { "optional": true },
-    "@deepseek-ai/dsh-invariants": { "optional": true },
-    "@deepseek-ai/dsh-llm": { "optional": true },
-    "@deepseek-ai/dsh-session": { "optional": true },
-    "@deepseek-ai/dsh-token-meter": { "optional": true },
-    "@deepseek-ai/schemastery": { "optional": true }
+    "@deepseek-ai/cordis": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-agent": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-brand": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-commands": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-compaction": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-compaction-basic": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-compaction-tool-result-pruner": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-invariants": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-llm": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-session": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-token-meter": {
+      "optional": true
+    },
+    "@deepseek-ai/schemastery": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",