dsh-engram 0.3.2 → 0.3.3

package/lib/index-block.js

@@ -207,7 +207,14 @@ function taskNextRank(t) {
   return 4;
 }
 
-/** Order active tasks so the model can act top-down without re-scanning. */
+/**
+ * Order active tasks so the model can act top-down without re-scanning.
+ *
+ * The final tiebreak is the task id (lexicographic), NEVER updatedAt: a
+ * timestamp in the sort would make the frozen per-session snapshot drift
+ * between turns and shatter the prefix cache. pi-esr's rule 2 — timestamps
+ * excluded from context — applied verbatim.
+ */
 export function sortActiveForNext(tasks) {
   return [...tasks].sort((a, b) => {
     const ra = taskNextRank(a);
@@ -216,7 +223,7 @@ export function sortActiveForNext(tasks) {
     const ga = evidenceGaps(a).length;
     const gb = evidenceGaps(b).length;
     if (ga !== gb) return ga - gb;
-    return (b.updatedAt ?? 0) - (a.updatedAt ?? 0);
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
   });
 }
 
@@ -249,50 +256,50 @@ export function selectStaleCandidates(tasks, config) {
 }
 
 /**
- * Render the [ESR] block — active tasks with closure gaps. Only appears when
- * at least one task exists. "STABLE" tasks are folded to a count line to save
- * tokens.
+ * Static ESR operating methodology (pi-esr rule 1: the system prompt never
+ * changes at runtime — this text is process-static and byte-identical every
+ * turn). Teaches WHEN to create / promote / close so the model no longer
+ * depends on runtime nudges to remember the protocol.
+ */
+export function esrMethodology() {
+  return [
+    "ESR（工程状态）操作协议 —— 多步工作建任务、用证据闭环：",
+    "  1. 动工前：esr_ready 看可认领工作；esr_status 拿实时状态（本块是会话开始快照，不会自动刷新）。",
+    "  2. 多步工作 → esr_task(name=\"…\", entity=…) 建任务（draft 起步）；重复对象 → esr_node；关系 → esr_link。",
+    "  3. 动工 → esr_claim（draft → active）。",
+    "  4. 收工 → esr_close（artifact + evaluation + memory_ref 三证齐才算数；不齐的活继续挂着，别硬关）。",
+    "  state 是唯一真相：拿不准 state 就 call esr_status。",
+  ].join("\n");
+}
+
+/**
+ * Build the DETERMINISTIC per-session [ESR] snapshot for a workspace.
  *
- * @param opts {{
- *   recorder?: import("./trigger.js").TriggerRecorder,  // decision-point recorder (P0-A–P3)
- *   sessionId?: string,                                  // live session for the hints
- * }}
+ * Pure derivation from the store — no recorder, no timestamps, no hint lines.
+ * Same store snapshot → byte-identical output, so the section provider can
+ * render it ONCE per session and freeze it (prefix-cache stable, pi-esr rule
+ * 2: injected once, never auto-refreshed; the model PULLS live state).
+ *
+ * @param opts {{ sessionId?: string }} — reserved for future live-tail
+ *   wording; the block itself is identical either way.
  */
-export function renderEsr(store, workspace, config, opts = {}) {
-  const recorder = opts?.recorder;
-  const sessionId = opts?.sessionId;
-  const live = recorder !== void 0 && sessionId !== void 0;
+export function buildEsrSnapshot(store, workspace, config, opts = {}) {
   const active = store.listTasks(workspace, { includeStable: false });
   const stable = store.listTasks(workspace, { includeStable: true }).filter((t) => t.state === "stable");
+  const draft = active.filter((t) => t.state === "draft").length;
   const ordered = sortActiveForNext(active);
-  // Prefer the live in-memory balance (recorder); fall back to the legacy
-  // usage-table view so store-driven callers/tests keep working unchanged.
-  const balance = recorder !== void 0 ? recorder.recentBalance(workspace) : usageBalanceView(store, workspace);
-  const hint = esrBalanceHint(balance);
-  const promote = live ? recorder.promoteHint(sessionId, workspace, active.length) : "";
-  const rootCause = live ? recorder.errorHint(sessionId, workspace, selectRootCauseCandidates(store, workspace, config)) : "";
-  const closure = live ? recorder.closureHint(sessionId, workspace, ordered.filter((t) => evidenceGaps(t).length === 0)) : "";
-  const stale = live ? recorder.staleHint(sessionId, workspace, selectStaleCandidates(active, config)) : "";
-  // P4: count only what is actually injected for a live session (never the
-  // GUI preview, which renders the same lines without a sessionId).
-  if (live) {
-    if (promote !== "") recorder.emitHint("promote", workspace, sessionId);
-    if (rootCause !== "") recorder.emitHint("rootcause", workspace, sessionId);
-    if (closure !== "") recorder.emitHint("close", workspace, sessionId);
-    if (stale !== "") recorder.emitHint("stale", workspace, sessionId);
-    if (hint !== "") recorder.emitHint("escalate", workspace, sessionId);
-  }
 
   if (active.length === 0 && stable.length === 0) {
     // Keep the mechanism visible even when idle: one compact line teaches the
     // model that multi-step work earns an esr_task closed with real evidence.
-    const base = "[ESR] no open tasks — BE PROACTIVE: multi-step work gets a task now (esr_task); recurring domain objects get a node (esr_node); related things get a link (esr_link). Close tasks with real evidence (esr_close)";
-    const rest = [promote, rootCause, hint].filter((l) => l !== "");
-    return rest.length === 0 ? base : `${base}\n${rest.join("\n")}`;
+    return [
+      "[ESR] no open tasks — BE PROACTIVE: multi-step work gets a task now (esr_task); recurring domain objects get a node (esr_node); related things get a link (esr_link). Close tasks with real evidence (esr_close)",
+      "snapshot from session start — WILL NOT auto-refresh; call esr_status for live state",
+    ].join("\n");
   }
 
   const lines = [];
-  lines.push(`[ESR] tasks: ${active.length} active / ${stable.length} stable`);
+  lines.push(`[ESR] tasks: ${ordered.filter((t) => t.state !== "draft").length} active / ${stable.length} stable${draft > 0 ? ` / ${draft} draft` : ""}`);
   const firstReady = ordered.find((t) => evidenceGaps(t).length === 0);
   if (firstReady !== void 0) {
     lines.push(`next: esr_close ${firstReady.id.slice(0, 6)} — ${escapeLt(truncate(firstReady.name, 40))} (all evidence present)`);
@@ -300,11 +307,134 @@ export function renderEsr(store, workspace, config, opts = {}) {
   for (const t of ordered.slice(0, 8)) lines.push(`- ${t.id.slice(0, 6)}: ${escapeLt(truncate(t.name, 60))} — ${t.state.toUpperCase()}${taskGapSuffix(t)}`);
   if (active.length > 8) lines.push(`- … ${active.length - 8} more`);
   if (stable.length > 0) lines.push(`- closed: ${stable.slice(0, 6).map((t) => `${t.id.slice(0, 6)} (${truncate(t.name, 28)})`).join(" · ")}${stable.length > 6 ? ` +${stable.length - 6}` : ""}`);
-  if (promote !== "") lines.push(promote);
-  if (rootCause !== "") lines.push(rootCause);
-  if (closure !== "") lines.push(closure);
-  if (stale !== "") lines.push(stale);
-  if (hint !== "") lines.push(hint);
+  lines.push("snapshot from session start — WILL NOT auto-refresh; call esr_status for live state");
+  return lines.join("\n");
+}
+
+/**
+ * The derived decision-point hint lines, assembled ONLY on the pull path
+ * (`esr_status`) — never in the frozen [ESR] block. Recorder-fed and
+ * one-shot per session; P4 exposure is counted here (real return path), while
+ * the GUI preview (no recorder/session) yields [] and counts nothing.
+ *
+ * @returns {Array<{ kind: string, line: string }>}
+ */
+export function esrHintLines(store, workspace, config, opts = {}) {
+  const recorder = opts?.recorder;
+  const sessionId = opts?.sessionId;
+  const live = recorder !== void 0 && sessionId !== void 0;
+  if (!live) return [];
+  const active = store.listTasks(workspace, { includeStable: false });
+  const ordered = sortActiveForNext(active);
+  const out = [];
+  const promote = recorder.promoteHint(sessionId, workspace, active.length);
+  if (promote !== "") {
+    out.push({ kind: "promote", line: promote });
+    recorder.emitHint("promote", workspace, sessionId);
+  }
+  const rootCause = recorder.errorHint(sessionId, workspace, selectRootCauseCandidates(store, workspace, config));
+  if (rootCause !== "") {
+    out.push({ kind: "rootcause", line: rootCause });
+    recorder.emitHint("rootcause", workspace, sessionId);
+  }
+  const closure = recorder.closureHint(sessionId, workspace, ordered.filter((t) => evidenceGaps(t).length === 0));
+  if (closure !== "") {
+    out.push({ kind: "close", line: closure });
+    recorder.emitHint("close", workspace, sessionId);
+  }
+  const stale = recorder.staleHint(sessionId, workspace, selectStaleCandidates(active, config));
+  if (stale !== "") {
+    out.push({ kind: "stale", line: stale });
+    recorder.emitHint("stale", workspace, sessionId);
+  }
+  // Live in-memory balance feeds the escalation reminder (falls back to the
+  // legacy usage-table view for store-driven callers without a recorder).
+  const balance = recorder !== void 0 ? recorder.recentBalance(workspace) : usageBalanceView(store, workspace);
+  const escalate = esrBalanceHint(balance);
+  if (escalate !== "") {
+    out.push({ kind: "escalate", line: escalate });
+    recorder.emitHint("escalate", workspace, sessionId);
+  }
+  return out;
+}
+
+/**
+ * Render the frozen [ESR] snapshot (backward-compatible face of
+ * `buildEsrSnapshot`). ALWAYS hint-free: the section provider renders this
+ * once per session and freezes it; decision-point lines live on the
+ * `esr_status` pull path via `esrHintLines`.
+ */
+export function renderEsr(store, workspace, config, opts = {}) {
+  return buildEsrSnapshot(store, workspace, config, opts);
+}
+
+/** Stable display order for accumulated this-session actionables. */
+export const ESR_HINT_ORDER = ["promote", "rootcause", "close", "stale", "escalate"];
+
+/**
+ * Build the per-session [ESR] block the model actually sees: a FROZEN
+ * deterministic snapshot (never changes mid-session, pi-esr rule 2) PLUS the
+ * session's monotonically accumulated decision-point actionables.
+ *
+ * An actionable is APPENDED exactly once, the first time it matures (the
+ * recorder's per-(session,kind) suppression makes esrHintLines return it only
+ * that once); after appending it stays for the whole session (never removed,
+ * even if the underlying condition later clears) — so the prefix changes only
+ * when genuinely new decision-point info appears, never per-turn. Snapshot
+ * stays pure (no timestamps, no recorder) and live state is still pulled via
+ * `esr_status`.
+ *
+ * @param opts {{
+ *   recorder?: import("./trigger.js").TriggerRecorder,
+ *   sessionId?: string,
+ *   holder?: { actionables: Map<string,string> },  // per-session accumulator
+ *   snapshot?: string,                             // pre-frozen snapshot (host passes the session-start one)
+ * }}
+ */
+export function buildFrozenEsrBlock(store, workspace, config, opts = {}) {
+  // Host passes the session-start snapshot (frozen, pi-esr rule 2); callers
+  // without one get a fresh deterministic derivation (pure functions/tests).
+  const snapshot = typeof opts?.snapshot === "string" ? opts.snapshot : buildEsrSnapshot(store, workspace, config, opts);
+  const holder = opts?.holder;
+  const recorder = opts?.recorder;
+  const sessionId = opts?.sessionId;
+  if (holder !== void 0 && recorder !== void 0 && sessionId !== void 0) {
+    const fresh = esrHintLines(store, workspace, config, { recorder, sessionId });
+    for (const h of fresh) holder.actionables.set(h.kind, h.line);
+    if (holder.actionables.size > 0) {
+      const lines = [snapshot, "# this-session actionables (frozen)"];
+      for (const kind of ESR_HINT_ORDER) {
+        const line = holder.actionables.get(kind);
+        if (line !== void 0) lines.push(line);
+      }
+      return lines.join("\n");
+    }
+  }
+  return snapshot;
+}
+
+/**
+ * Compose an `esr_status` response (the PULL surface): the deterministic ESR
+ * snapshot + revision, plus the derived decision-point hints. When the caller
+ * passes the current revision via `sinceRevision`, the state view collapses
+ * to a short "unchanged" line (pi-esr rule 3) while actionables still surface
+ * — they are the volatile part (balance / stale window) that motivates a pull.
+ *
+ * @param opts {{ recorder?, sessionId?, sinceRevision? }}
+ */
+export function buildEsrStatusView(store, workspace, config, opts = {}) {
+  const revision = store.esrFingerprint(workspace);
+  const hints = esrHintLines(store, workspace, config, opts);
+  const hintBlock = hints.length > 0 ? ["── actionables ──", ...hints.map((h) => h.line)].join("\n") : "";
+  const since = opts?.sinceRevision;
+  if (since !== void 0 && since !== null && since !== "" && since === revision) {
+    const lines = ["[ESR_STATUS]", `ESR state unchanged since revision ${since}.`, `ESR revision: ${revision}`];
+    if (hintBlock !== "") lines.push("", hintBlock);
+    return lines.join("\n");
+  }
+  const snapshot = buildEsrSnapshot(store, workspace, config, opts);
+  const lines = [snapshot, `ESR revision: ${revision}`];
+  if (hintBlock !== "") lines.push("", hintBlock);
   return lines.join("\n");
 }
 

package/lib/index.js

@@ -20,10 +20,12 @@ import { resolve as resolvePath } from "node:path";
 import { openEngramDomain } from "./store.js";
 import { registerTools } from "./tools.js";
 import { makeCaptureHandler } from "./capture.js";
-import { renderIndex, renderEsr } from "./index-block.js";
+import { renderIndex, renderEsr, esrMethodology, buildEsrSnapshot, buildFrozenEsrBlock } from "./index-block.js";
 import { makeTriggerRecorder } from "./trigger.js";
 import { installEngramSettings } from "./settings.js";
 import { makeEngramRoutes } from "./api.js";
+import { loadCompactionEngine, collectPointerContext } from "./context-gc.js";
+import { workspaceKey as wk } from "./util.js";
 
 /** Stable cordis plugin name. */
 export const name = "engram";
@@ -57,6 +59,14 @@ const DEFAULTS = {
   gcEnabled: true,
   gcIntervalHours: 24,
   gcStableRetentionDays: 120,
+  // Context GC — the auto-GC that REPLACES DSH's built-in lossy LLM-summary
+  // compaction (pi-esr CONTEXT_GC): mechanical eviction + re-fetch pointers,
+  // NOT the memory-panel GC above. `gcReplacesCompaction` off → the host keeps
+  // its default compaction backend; `gcNarrative` off → fully mechanical.
+  gcReplacesCompaction: true,
+  gcNarrative: true,
+  gcNarrativeMaxTokens: 1024,
+  gcNarrativeMaxChars: 4000,
   // GUI access: hostnames allowed past the loopback fence for /api/dsh-engram
   // (e.g. an operator-authorized cloudflare tunnel). Empty = loopback-only.
   trustedHosts: [],
@@ -66,6 +76,7 @@ const DEFAULTS = {
   verifyArtifact: true,
   // prompt section order (before the persona/tools bands per DSH convention)
   engramIndexOrder: 40,
+  esrMethodOrder: 40.5, // static ESR protocol section (byte-identical every turn)
   esrOrder: 41,
   // decision-point triggers (P0-A): promote a session plan to an ESR task
   // when the pending-todo count is at least minTodosForPromote and exceeds
@@ -165,11 +176,11 @@ export function apply(ctx, config) {
         return "";
       }
     },
-    /** Recompute the exact [ESR] block for a workspace (GUI inject preview). */
+    /** Recompute the exact [ESR] snapshot for a workspace (GUI inject preview). */
     renderEsrBlock(workspace) {
       if (opened === void 0) return "";
       try {
-        return renderEsr(opened, workspace, resolved, { recorder });
+        return renderEsr(opened, workspace, resolved);
       } catch {
         return "";
       }
@@ -220,8 +231,10 @@ export function apply(ctx, config) {
     };
   });
 
-  // Per-session frozen blocks: render once, then reuse — prefix stability is
-  // the point (KV cache). New session (or resumed reload) object → fresh block.
+  // [ENGRAM] block: render once, then reuse — prefix stability is the point
+  // (KV cache). New session (or resumed reload) object → fresh block. The
+  // [ESR] block below follows the same frozen-snapshot rule but additionally
+  // accumulates this-session actionables (see esrBlockFor).
   const sessionCache = new WeakMap();
   const blockFor = (agent) => {
     if (agent === void 0) return "";
@@ -246,6 +259,54 @@ export function apply(ctx, config) {
     return block;
   };
 
+  // [ESR] block = FROZEN snapshot + this-session's monotonically accumulated
+  // actionables (promote/root-cause/close/stale/escalate).
+  //   - The snapshot is rendered ONCE at the first assembly of the session and
+  //     cached per session (pi-esr rule 2: injected once, never
+  //     auto-refreshed) — tasks created/updated mid-session surface via
+  //     `esr_status`, not by re-rendering this block.
+  //   - An actionable is APPENDED exactly once, the moment it first matures
+  //     (recorder-fed, one-shot via esrHintLines), then stays frozen — the
+  //     prefix therefore changes only when genuinely new decision-point info
+  //     exists, never per-turn.
+  const esrSnapshotCache = new WeakMap();  // session -> frozen snapshot text
+  const esrSessionHolders = new WeakMap(); // session -> { actionables: Map<kind,line> }
+  const esrBlockFor = (agent) => {
+    if (agent === void 0) return "";
+    const session = agent.session;
+    if (session === void 0) return "";
+    const cwd = session.header?.cwd;
+    if (cwd === void 0 || cwd.length === 0) return "";
+    if (opened === void 0) return "";
+    let snapshot = esrSnapshotCache.get(session);
+    if (snapshot === void 0) {
+      try {
+        snapshot = buildEsrSnapshot(opened, resolvePath(cwd), resolved, { sessionId: session.id });
+      } catch (error) {
+        log?.warn?.(`engram esr render failed: ${String(error)}`);
+        return "";
+      }
+      esrSnapshotCache.set(session, snapshot);
+    }
+    let holder = esrSessionHolders.get(session);
+    if (holder === void 0) {
+      holder = { actionables: new Map() };
+      esrSessionHolders.set(session, holder);
+    }
+    let block = "";
+    try {
+      block = buildFrozenEsrBlock(opened, resolvePath(cwd), resolved, {
+        recorder,
+        sessionId: session.id,
+        holder,
+        snapshot,
+      });
+    } catch (error) {
+      log?.warn?.(`engram esr render failed: ${String(error)}`);
+    }
+    return block;
+  };
+
   ctx.effect(() => {
     const disposers = [];
 
@@ -270,25 +331,22 @@ export function apply(ctx, config) {
       });
       disposers.push(() => indexDispose());
 
+      // Static ESR protocol (pi-esr rule 1): byte-identical every turn, so
+      // the model never depends on runtime nudges to know WHEN to use ESR.
+      const esrMethodDispose = systemPrompt.section({
+        name: "engram:esr-method",
+        order: resolved.esrMethodOrder,
+        text: () => esrMethodology(),
+      });
+      disposers.push(() => esrMethodDispose());
+
       const esrDispose = systemPrompt.section({
         name: "engram:esr",
         order: resolved.esrOrder,
         text: (assemblyContext) => {
           const agent = assemblyContext?.agent;
           if (agent === void 0) return "";
-          const session = agent.session;
-          if (session === void 0) return "";
-          const cwd = session.header?.cwd;
-          if (cwd === void 0 || cwd.length === 0) return "";
-          if (opened === void 0) return "";
-          try {
-            return renderEsr(opened, resolvePath(cwd), resolved, {
-              recorder,
-              sessionId: session.id,
-            });
-          } catch {
-            return "";
-          }
+          return esrBlockFor(agent);
         },
       });
       disposers.push(() => esrDispose());
@@ -348,6 +406,8 @@ export function apply(ctx, config) {
     }
     disposers.push(gcDispose);
 
+
+
     return async () => {
       for (const dispose of disposers) {
         try {

package/lib/settings.js

@@ -32,6 +32,8 @@ export const SETTINGS_KEYS = [
   "maxMemoriesPerWorkspace",
   "gcEnabled",
   "gcStableRetentionDays",
+  "gcReplacesCompaction",
+  "gcNarrative",
   "trustedHosts",
 ];
 
@@ -59,6 +61,8 @@ export function makeSettingsSchema(defaults) {
     maxMemoriesPerWorkspace: z.natural().max(10000).default(defaults.maxMemoriesPerWorkspace),
     gcEnabled: z.boolean().default(defaults.gcEnabled),
     gcStableRetentionDays: z.natural().max(3650).default(defaults.gcStableRetentionDays),
+    gcReplacesCompaction: z.boolean().default(defaults.gcReplacesCompaction),
+    gcNarrative: z.boolean().default(defaults.gcNarrative),
     verifyArtifact: z.boolean().default(defaults.verifyArtifact).description("ESR 闭环时校验 artifact 路径真实存在"),
     // Security knob, not rendered in the card: hostnames allowed past the
     // loopback fence for /api/dsh-engram (operator-authorized tunnel hosts).

package/lib/store.js

@@ -490,6 +490,21 @@ export async function openEngramDomain(facility) {
         .filter((t) => t.workspace === workspace && notArchivedTask(t) && (includeStable || t.state !== "stable"))
         .sort(byRecency);
     },
+    /**
+     * Deterministic fingerprint of the ESR task surface (what `esr_status` /
+     * the [ESR] snapshot render): id, state, evidence fields, assignee — NOT
+     * timestamps (pi-esr rule 2: timestamps excluded from context). Used as
+     * the `revision` token for incremental pulls: same tasks → same revision
+     * → "unchanged" short response.
+     */
+    esrFingerprint(workspace) {
+      const parts = [...tasks.entries()]
+        .map(([, t]) => t)
+        .filter((t) => t.workspace === workspace && notArchivedTask(t))
+        .map((t) => `${t.id}|${t.state}|${t.artifact ?? ""}|${t.evaluation ?? ""}|${(t.memoryRefs ?? []).join(",")}|${t.assignee ?? ""}`)
+        .sort();
+      return hashText(`esr:${parts.join("\n")}`);
+    },
     async putTask(task) {
       if ([...task.name].length > 200) throw new EngramError("ENGRAM_CAP_EXCEEDED", "task name is over 200 characters");
       if (task.id !== task.id) throw new EngramError("ENGRAM_INVALID_ARGS", "task id mismatch");

package/lib/tools.js

@@ -5,6 +5,7 @@
  * tool schemas cost tokens in every request):
  *   engram_store / engram_recall / engram_detail    — the engram memory surface
  *   esr_task / esr_node / esr_close / esr_link — the ESR-lite evidence surface
+ *   esr_ready / esr_status                    — the pull surface (live state + hints)
  *   esr_gc                                    — pi-esr memory garbage collection
  *
  * Every call is recorded into the per-(workspace, day) usage rollup so the
@@ -16,6 +17,7 @@
 
 import { z } from "zod";
 import { EngramError, hasCode } from "./store.js";
+import { buildEsrStatusView } from "./index-block.js";
 import { truncate, shortId, slugId, fmtDate, escapeLt, workspaceKey as wk, uuid } from "./util.js";
 
 const KINDS = [
@@ -510,6 +512,33 @@ ${hint}` : ""}`;
         },
       }),
 
+      // ── esr_status ──────────────────────────────────────────────────
+      registerTool({
+        name: "esr_status",
+        description:
+          "Pull the live ESR state (deterministic snapshot + revision) plus decision-point hints (promote / root-cause / close / stale / escalate). Pass since_revision to skip unchanged state — returns a short response when nothing changed. The [ESR] block in the prompt is a session-start snapshot that never auto-refreshes; call this for the current truth.",
+        parameters: {
+          type: "object",
+          properties: {
+            workspace: { type: "string", description: "Override the workspace key (default: current session cwd)" },
+            since_revision: { type: "string", description: "Last-seen ESR revision (from a previous esr_status response); unchanged state returns a short response" },
+          },
+        },
+        output: TEXT_OUTPUT,
+        timeoutMs: 20000,
+        execute: async (raw, exec) => {
+          const args = parse(z.object({ workspace: z.string().optional(), since_revision: z.string().optional() }), raw, "esr_status");
+          const caller = callerOf(exec);
+          const domain = await requireDomain(service);
+          const ws = wk(args.workspace ?? caller.cwd);
+          return buildEsrStatusView(domain, ws, service.config, {
+            recorder: service.recorder,
+            sessionId: caller.sessionId,
+            sinceRevision: args.since_revision,
+          });
+        },
+      }),
+
       // ── esr_node ─────────────────────────────────────
       registerTool({
         name: "esr_node",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-engram",
   "description": "Minimalist long-term memory for DeepSeek Harness, distilling symbolic-index + pi-esr ideas: zero-LLM auto-capture, a symbolic [ENGRAM] index with progressive disclosure, and an ESR-lite evidence-closure protocol (esr_task / esr_node / esr_close / esr_link). Real agent-behaviour telemetry (usage rollup + /stats) and a deterministic offline recall benchmark (npm run eval). Hot path is model-free; storage on ctx.storageDomain; web memory viewer, observability panel and config card through DSH's native settings slots.",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -15,6 +15,7 @@
   "main": "lib/index.js",
   "exports": {
     ".": "./lib/index.js",
+    "./compaction": "./lib/compaction.js",
     "./client": "./lib/client.js",
     "./package.json": "./package.json",
     "./cordis.patch.yml": "./cordis.patch.yml"
@@ -60,7 +61,10 @@
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh-storage-domain": "^0.1.0-rc.7",
     "@deepseek-ai/dsh-settings": "^0.1.0-rc.7",
-    "@deepseek-ai/schemastery": "^3.18.1"
+    "@deepseek-ai/schemastery": "^3.18.1",
+    "@deepseek-ai/dsh-compaction": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-compaction-basic": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.7"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/cordis": {
@@ -72,6 +76,15 @@
     "@deepseek-ai/dsh-settings": {
       "optional": true
     },
+    "@deepseek-ai/dsh-compaction": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-compaction-basic": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-llm": {
+      "optional": true
+    },
     "@deepseek-ai/schemastery": {
       "optional": true
     }