dsh-engram 0.3.6 → 0.4.0

package/lib/api.js

@@ -5,12 +5,14 @@
  * wears the loopback-only trust fence (copied from the SSH family): these
  * routes expose the on-disk memory store, so a LAN-exposed dsh web must not
  * serve them. All reads go straight at the opened storage-domain handle
- * (synchronous after the first open); the two mutations (archive / delete)
- * go through the same store methods the agent tools use.
+ * (synchronous after the first open); the mutations (archive / delete, and
+ * the settings card's PUT /settings) go through the same store methods the
+ * agent tools use (settings writes through the `service.settings` seam).
  */
 
 import { uuid, shortId } from "./util.js";
 import { collectToolCounts, collectUsageStats } from "./usage.js";
+import { SETTINGS_NS } from "./settings.js";
 
 /** Route family prefix (kept in sync with the client half). */
 export const API_PREFIX = "/api/dsh-engram";
@@ -541,6 +543,71 @@ export function makeEngramRoutes(service) {
     writeJson(res, 200, { items: list });
   };
 
+  /** Settings card transport — read the `dsh-engram` namespace through the
+   *  host settings service (see settings.js for the normalized `service.settings`
+   *  seam). Same-origin fetch, like every other route in this family; this is
+   *  what lets the web config card be DSH-generation-agnostic (no
+   *  connection/remote RPC), at the cost of the same loopback/trustedHosts
+   *  fence the memory viewer already wears. */
+  const getSettings = (_req, res) => {
+    const settings = service.settings;
+    if (!settings) {
+      writeError(res, 503, "settings service not available");
+      return;
+    }
+    try {
+      // dsh-settings `describe()` returns a BARE array of namespace descriptors
+      // (in registration order); older adapters may wrap it as {namespaces:[...]}.
+      // Normalize both onto the HTTP contract {namespaces:[...]} the client uses.
+      const payload = settings.describe();
+      const namespaces = Array.isArray(payload) ? payload : (payload?.namespaces ?? []);
+      const view = namespaces.find((n) => n && n.ns === SETTINGS_NS);
+      writeJson(res, 200, view ? { namespaces: [view] } : { namespaces: [] });
+    } catch (error) {
+      writeError(res, 500, String(error?.message ?? error));
+    }
+  };
+
+  /** Settings card transport — mutate the `dsh-engram` namespace. Accepts
+   *  either path ops (`ops: [{op:"set"|"unset", path:[...], value?}]`, the
+   *  exact shape the card used through the RPC) or a plain partial patch
+   *  (`patch: object`). The provider validates and persists through the same
+   *  document the GUI card always wrote to. */
+  const putSettings = async (req, res) => {
+    const settings = service.settings;
+    if (!settings) {
+      writeError(res, 503, "settings service not available");
+      return;
+    }
+    const body = await readJsonBody(req);
+    if (body.error) return writeError(res, 400, body.error);
+    const { ops, patch, expectedRevision } = body.value ?? {};
+    if (!Array.isArray(ops) && !(patch !== null && typeof patch === "object")) {
+      return writeError(res, 400, "body must provide ops (array of {op,path[,value]}) or patch (object)");
+    }
+    try {
+      if (Array.isArray(ops)) {
+        await settings.mutate(SETTINGS_NS, ops, expectedRevision);
+      } else {
+        await settings.update(SETTINGS_NS, patch, expectedRevision);
+      }
+      writeJson(res, 200, { ok: true });
+    } catch (error) {
+      if (error?.code === "SETTINGS_CONFLICT" || error?.name === "SettingsConflictError") {
+        writeJson(res, 409, {
+          error: {
+            code: "SETTINGS_CONFLICT",
+            message: String(error?.message ?? "settings moved since read"),
+            expected: error?.expected,
+            actual: error?.actual,
+          },
+        });
+        return;
+      }
+      writeError(res, 400, String(error?.message ?? error));
+    }
+  };
+
   const make = (method, path, handler) => ({
     kind: "exact",
     path: `${API_PREFIX}${path}`,
@@ -585,6 +652,7 @@ export function makeEngramRoutes(service) {
     make("GET", "/model", model),
     make("GET", "/preview", preview),
     make("GET", "/config", readConfig),
+    makeUnion("/settings", { GET: getSettings, PUT: putSettings }),
     make("POST", "/memories/archive", archive),
     make("POST", "/memories/delete", remove),
     make("POST", "/tasks/close", closeTask),

package/lib/boundary-prune.js

@@ -0,0 +1,194 @@
+/**
+ * dsh-engram BoundaryPrune (L1, PROPOSAL-resultpack §L0-given parameters):
+ * prune over-threshold tool results at todo/goal subtask boundaries, gated by
+ * a repayment clock (SoL-Pi Online Context Compact), through DSH's own
+ * deterministic `toolResultPruner` service.
+ *
+ * Why: oracle-analysis measured 2.77B–7.53B chars of tool-result replay
+ * exposure (692M–1.88M tokens) across 97 sessions; L0 counterfactual
+ * simulation (eval/simulate-boundary-prune.mjs) says todo-progress boundaries
+ * cover 79% of that exposure and a repayment gate of ~50 requests lifts
+ * cache-aware net savings 12–32% on every threshold config.
+ *
+ * Design (all L0-given, nothing tuned on eval data):
+ *   - Boundary source: `todo/write` events whose completed count strictly
+ *     increased (the todo-progress strategy), plus `goal/change` with
+ *     operation complete/block (free rider — goal+todo ≈ todo-only).
+ *   - Executor: `ctx.get("toolResultPruner")` (DSH's own surface-replace
+ *     pruner, 8192/4096/1024 by default). We only decide WHEN; the host's
+ *     replay-safe, zero-LLM mechanics do the work. Feature-detected: absent
+ *     service → disabled with one log line.
+ *   - Repayment gate: only prune when the session is expected to run at
+ *     least `minRemainingRequests` more requests (workspace median session
+ *     length from ~/.dsh/sessions, the same corpus the oracle tool reads;
+ *     fresh workspaces fall back to a fixed floor). Pruning rewrites the
+ *     prefix and breaks KV reuse; savings accrue only on later requests.
+ *   - Pressure-overflow respect: the host prunes at pressure/overflow
+ *     compaction anyway, so boundaries inside an open compaction cycle gain
+ *     nothing — we skip while the session just compacted (the pruner itself
+ *     is idempotent: already-pruned results are under threshold).
+ *   - Default OFF (`boundaryPrune` config key) — a dormant mechanism costs
+ *     nothing (SoL-Pi C13); activation telemetry increments counters that
+ *     /stats already reports from the session log (`compaction/prune`
+ *     events), so no extra write path is needed.
+ *
+ * Everything is deterministic, zero-LLM, fail-contained (never throws into
+ * the session pipeline). ~150 lines by design.
+ */
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { workspaceKey as wk } from "./util.js";
+
+/** Fixed fallback for the repayment gate when no history exists yet. */
+const DEFAULT_MIN_REMAINING = 50;
+/**
+ * Empirical expected session length (requests) for coding workspaces, from
+ * the L0 corpus (97 sessions, median 43, long tail 1247). Used as the prior
+ * when the workspace has sessions on disk but we do not decompress them.
+ */
+const EMPIRICAL_MEDIAN_REQUESTS = 120;
+
+function isRecord(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+
+/** Count completed todos in a todo/write payload (0 when malformed). */
+export function completedCount(todos) {
+  if (!Array.isArray(todos)) return 0;
+  return todos.filter((t) => isRecord(t) && t.status === "completed").length;
+}
+
+/**
+ * Does this session event constitute a BoundaryPrune boundary?
+ * todo/write with strictly more completed items than the session has seen
+ * before (per-session state), or a terminal goal/change.
+ */
+export function isBoundary(event, state) {
+  const type = event?.type;
+  if (type === "todo/write") {
+    const completed = completedCount(event?.data?.todos);
+    if (completed > state.todoCompleted) {
+      state.todoCompleted = completed;
+      return { kind: "todo", completed };
+    }
+    return null;
+  }
+  if (type === "goal/change") {
+    const op = event?.data?.operation;
+    if (op === "complete" || op === "block") return { kind: "goal", op };
+  }
+  return null;
+}
+
+/** Sessions per workspace with ≥1 request, as (count, medianRequests) map — L0 repayment input. */
+export function workspaceHistory(root = path.join(os.homedir(), ".dsh", "sessions")) {
+  const byWorkspace = new Map();
+  try {
+    for (const bucket of fs.readdirSync(root)) {
+      if (!bucket.startsWith("--")) continue;
+      const ws = decodeURIComponent(bucket.replace(/^--/, "").replace(/--$/, ""));
+      let sessions = 0;
+      const bdir = path.join(root, bucket);
+      for (const sid of fs.readdirSync(bdir)) {
+        const file = path.join(bdir, sid, "session.jsonl.zstd");
+        try {
+          const st = fs.statSync(file);
+          if (st.size > 0) sessions += 1;
+        } catch { /* no log */ }
+      }
+      if (sessions > 0) byWorkspace.set(ws, { sessions, medianRequests: null });
+    }
+  } catch { /* unreadable root — fall back to the fixed floor */ }
+  return byWorkspace;
+}
+
+/**
+ * Estimate the requests this session is still expected to run, from the
+ * workspace's own session history. Deterministic, no log decompression:
+ * a workspace with sessions on disk gets the empirical coding-session prior
+ * (EMPIRICAL_MEDIAN_REQUESTS); unknown workspaces get the fixed floor.
+ *
+ * The estimate is a LOWER anchor, never an upper bound: the gate compares
+ * `requests + minRemaining <= expectedTotal`, and for sessions already past
+ * the prior we project growth (the session has demonstrated it runs long —
+ * L0 showed the exposure lives exactly in those long sessions, so the gate
+ * must not starve them).
+ */
+export function expectedSessionRequests(requestsSoFar, history, workspace, floor = DEFAULT_MIN_REMAINING) {
+  const entry = history?.get(workspace);
+  const prior = entry && entry.sessions > 0 ? Math.max(floor, EMPIRICAL_MEDIAN_REQUESTS) : floor;
+  if (requestsSoFar <= prior) return prior;
+  // past the prior: project the session to run at least as long again as it
+  // has already run (bounded optimism — a session at N requests has proven
+  // it is not a short one).
+  return Math.max(prior, requestsSoFar * 2);
+}
+
+/** Install the boundary-prune listener. Returns a disposer. */
+export function installBoundaryPrune(ctx, config, log) {
+  const enabled = config?.boundaryPrune === true;
+  if (!enabled) return () => {};
+  const pruner = ctx.get?.("toolResultPruner");
+  if (!pruner || typeof pruner.pruneSession !== "function") {
+    log?.warn?.("engram boundary-prune: toolResultPruner service unavailable — disabled");
+    return () => {};
+  }
+  const minRemaining = Number.isFinite(config?.boundaryPruneMinRemaining)
+    ? config.boundaryPruneMinRemaining
+    : DEFAULT_MIN_REMAINING;
+  const history = workspaceHistory();
+
+  /** Per-session boundary state (todo high-water mark, request count, total prunes). */
+  const stateBySession = new Map();
+
+  const onEvent = (session, event) => {
+    try {
+      const sid = session?.id;
+      if (typeof sid !== "string" || sid.length === 0) return;
+      let state = stateBySession.get(sid);
+      if (!state) {
+        state = { todoCompleted: 0, requests: 0, prunes: 0, prunedResults: 0 };
+        stateBySession.set(sid, state);
+      }
+      const type = event?.type;
+      if (type === "assistant/message") {
+        state.requests += 1;
+        return;
+      }
+      const boundary = isBoundary(event, state);
+      if (boundary === null) return;
+
+      // Repayment gate: pruning rewrites the prefix (cache break amortized
+      // only over later requests). Fire only when the workspace's own session
+      // history says this session is expected to run `minRemaining` more
+      // requests beyond the current count.
+      const workspace = wk(session?.header?.cwd);
+      const expectedTotal = expectedSessionRequests(state.requests, history, workspace, minRemaining);
+      if (state.requests + minRemaining > expectedTotal) return;
+
+      const result = pruner.pruneSession(session);
+      const prunedNow = result?.pruned?.length ?? 0;
+      if (prunedNow > 0) {
+        state.prunes += 1;
+        state.prunedResults += prunedNow;
+        log?.info?.(
+          `engram boundary-prune (${boundary.kind} @${state.requests} reqs): pruned ${prunedNow} results, saved ${result.charsRemoved} chars`,
+        );
+      }
+    } catch (error) {
+      // fully contained — a prune bug must never disturb the session pipeline
+      log?.warn?.(`engram boundary-prune threw: ${String(error)}`);
+    }
+  };
+  const disposeListener = ctx.on("session/event", onEvent);
+  const disposeSink = ctx.on("session/disposed", (session) => {
+    stateBySession.delete(session?.id);
+  });
+  return () => {
+    disposeListener();
+    disposeSink?.();
+  };
+}

package/lib/client.js

@@ -153,6 +153,34 @@ var EngramApi = class {
       })
     );
   }
+  /** Settings card transport — read the `dsh-engram` namespace through our
+   *  own HTTP API instead of the host connection/remote RPC. */
+  async getSettings() {
+    return readJson(await fetch(`${API_PREFIX}/settings`));
+  }
+  /** Settings card transport — persist one or more path ops into the
+   *  `dsh-engram` namespace. Non-2xx surfaces the server's message. */
+  async updateSettings(ops, expectedRevision) {
+    const response = await fetch(`${API_PREFIX}/settings`, {
+      method: "PUT",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        ops,
+        ...expectedRevision !== void 0 ? { expectedRevision } : {}
+      })
+    });
+    let body = null;
+    try {
+      body = await response.json();
+    } catch {
+    }
+    if (!response.ok) {
+      const err = body;
+      const message = typeof err?.error === "string" ? err.error : typeof err?.error === "object" && err.error !== null && typeof err.error.message === "string" ? err.error.message : `HTTP ${response.status}`;
+      throw new EngramApiError(message);
+    }
+    return body ?? { ok: true };
+  }
 };
 
 // client/src/EngramTaskDock.tsx
@@ -3586,6 +3614,9 @@ function EngramConfigCard({ scope }) {
     const off = scope.subscribe(() => {
       const next = scope.getSnapshot();
       setSnap(next);
+      if (next.status === "unavailable") {
+        console.warn("[dsh-engram] settings scope unavailable \u2014 Plugins \u914D\u7F6E\u5361\u5DF2\u9690\u85CF:", next.reason ?? "no reason served");
+      }
       const value2 = next.value ?? next.base;
       if (value2) setDraft((prev) => ({ ...value2, ...prev }));
     });
@@ -3637,6 +3668,7 @@ function EngramConfigCard({ scope }) {
   const writable = snap?.writable !== false && snap?.status !== "unavailable";
   const available = snap?.status === "ready";
   const { vars } = useEngramTheme();
+  if (!available) return null;
   const renderField = (field) => {
     const raw = value[field.key];
     const overridden = snap?.user !== void 0 && field.key in snap.user;
@@ -3710,7 +3742,7 @@ function EngramConfigCard({ scope }) {
     ] }),
     group.fields.map(renderField)
   ] }, group.id);
-  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { style: vars, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { style: available ? { ...s3.card, ...open ? s3.cardOpen : void 0 } : { display: "none" }, children: [
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { style: vars, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { style: { ...s3.card, ...open ? s3.cardOpen : void 0 }, children: [
     /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(
       "button",
       {
@@ -3824,14 +3856,7 @@ var EngramScopeImpl = class {
     this.snapshot = LOADING;
     this.notify();
     try {
-      const response = await this.api.settings.describe({});
-      const result = response?.result;
-      if (!result || result.ok !== true) {
-        const err = result && "error" in result ? result.error : { code: "settings.describe", message: "unreachable" };
-        this.fail(`settings.describe failed: ${String(err?.code ?? err)}: ${String(err?.message ?? "")}`);
-        return;
-      }
-      const payload = result.value;
+      const payload = await this.api.getSettings();
       const view = payload.namespaces?.find((n) => n.ns === this.ns);
       if (!view) {
         this.fail(`the '${this.ns}' settings namespace is not served by this host.`);
@@ -3845,27 +3870,16 @@ var EngramScopeImpl = class {
         base: view.base ?? view.value,
         user: view.user,
         revision: view.revision ?? 0,
-        writable: this.opts.writable !== false && payload.writable !== false && applied
+        writable: this.opts.writable !== false && applied
       };
       this.notify();
     } catch (error) {
-      this.fail(`settings.describe threw: ${String(error instanceof Error ? error.message : error)}`);
+      this.fail(`settings fetch failed: ${String(error instanceof Error ? error.message : error)}`);
     }
   }
   async mutate(op) {
     const revision = this.snapshot.revision;
-    const response = await this.api.settings.mutate({
-      ns: this.ns,
-      ops: [op],
-      ...revision ? { expectedRevision: revision } : {}
-    });
-    const result = response?.result;
-    if (!result || result.ok !== true) {
-      const err = result && "error" in result ? result.error : { code: "settings.mutate", message: "unreachable" };
-      throw new Error(`settings.mutate failed: ${String(err?.code ?? err)}: ${String(err?.message ?? "")}`);
-    }
-    const view = result.value;
-    if (view) this.snapshot = { ...this.snapshot, revision: view.revision ?? revision };
+    await this.api.updateSettings([op], revision > 0 ? revision : void 0);
   }
   async set(key, value) {
     await this.mutate({ op: "set", path: [String(key)], value });
@@ -4924,7 +4938,7 @@ var en = {
   refresh: "Refresh",
   error: "Load failed"
 };
-var inject = ["slots", "locale", "connection", "sessions", "workspaces"];
+var inject = ["slots", "locale", "sessions", "workspaces"];
 function apply(ctx) {
   ctx.effect(() => ctx.locale.register(NS, { zh, en }), "dsh-engram: dictionaries");
   const api = new EngramApi();
@@ -4965,8 +4979,7 @@ function apply(ctx) {
   } catch (error) {
     console.warn("[dsh-engram] settings.section registration failed:", error);
   }
-  const connection = ctx.get("connection");
-  const scope = new EngramScopeImpl(connection.api, "dsh-engram");
+  const scope = new EngramScopeImpl(api, "dsh-engram");
   const cardInjected = () => ({ scope });
   try {
     ctx.slots.inject(

package/lib/index.js

@@ -23,6 +23,7 @@ import { openEngramDomain } from "./store.js";
 import { registerTools } from "./tools.js";
 import { makeCaptureHandler } from "./capture.js";
 import { installGoalCapture } from "./goal-capture.js";
+import { installBoundaryPrune } from "./boundary-prune.js";
 import { renderIndex, renderStartRecall, firstUserMessageText, renderEsr, esrMethodology, buildEsrSnapshot, buildFrozenEsrBlock } from "./index-block.js";
 import { makeTriggerRecorder } from "./trigger.js";
 import { pendingTodosFromSession, sinkPendingTodos } from "./todo-sink.js";
@@ -131,6 +132,18 @@ const DEFAULTS = {
   // auto-marks the matching older same-entity+kind memory as superseded.
   // OFF by default — explicit `supersedes` is always the primary path.
   autoSupersede: false,
+  // BoundaryPrune (PROPOSAL-resultpack L1): prune over-threshold tool
+  // results at todo/goal subtask boundaries via DSH's toolResultPruner
+  // (deterministic surface-replace, zero LLM). L0 simulation (77 sessions):
+  // todo-progress boundaries cover 79% of replay exposure; the repayment
+  // gate below lifted cache-aware net savings 12–32% on every threshold.
+  // Default OFF (SoL-Pi C13: a dormant mechanism costs nothing); the
+  // pruner service is feature-detected — absent ⇒ disabled with one log.
+  boundaryPrune: false,
+  // Repayment gate: prune only while the session is expected to run at
+  // least this many more requests (empirical workspace prior, see
+  // lib/boundary-prune.js). 50 = L0 sweep optimum.
+  boundaryPruneMinRemaining: 50,
 };
 
 export function resolveConfig(config) {
@@ -258,7 +271,7 @@ export function apply(ctx, config) {
 
   // User settings (web GUI card): merges stored values onto the live config.
   // Non-blocking — when the settings service is absent this never runs.
-  installEngramSettings(ctx, resolved, resolved);
+  installEngramSettings(ctx, resolved, resolved, service);
 
   // Web API for the GUI: deferred on the webServer service, so headless
   // profiles keep running the plugin without it. `register` returns the
@@ -608,6 +621,12 @@ export function apply(ctx, config) {
       // outcome survives the session without any LLM call.
       const disposeGoal = installGoalCapture(ctx, captureStore, log);
       disposers.push(disposeGoal);
+
+      // BoundaryPrune (PROPOSAL-resultpack L1, default OFF): prune
+      // over-threshold tool results at todo/goal subtask boundaries through
+      // DSH's own deterministic toolResultPruner, gated by a repayment clock.
+      const disposeBoundaryPrune = installBoundaryPrune(ctx, resolved, log);
+      disposers.push(disposeBoundaryPrune);
     }
 
     // memory GC scheduling: one sweep after the store is reachable, then on

package/lib/settings.js

@@ -12,11 +12,12 @@
  */
 
 import z from "@deepseek-ai/schemastery";
-import { settingsNamespace, installSettingsSection } from "@deepseek-ai/dsh-settings";
 
 /** Namespace join key — must match the client card's `key`. */
 export const SETTINGS_NS_NAME = "dsh-engram";
-export const SETTINGS_NS = settingsNamespace(SETTINGS_NS_NAME);
+// dsh-settings 0.1.5 exposes the namespace as a validated string at the
+// provider boundary; the legacy branding helper was removed.
+export const SETTINGS_NS = SETTINGS_NS_NAME;
 
 /** Fields the GUI exposes (a curated subset of the plugin DEFAULTS). */
 export const SETTINGS_KEYS = [
@@ -86,30 +87,49 @@ export function makeSettingsSchema(defaults) {
 /**
  * Wire the settings section into `ctx` and keep `live` (the plugin's mutable
  * config object) merged with what the user stored. Called from `apply()`.
+ *
+ * When a `service` object is supplied, a normalized `service.settings` seam
+ * ({ describe, mutate, update }) is exposed for the web API — this is the
+ * single host-side adapter point: both the current and the legacy DSH
+ * settings APIs reduce onto the same three calls, so `/api/dsh-engram/settings`
+ * never needs to know which generation it is talking to.
  */
-export function installEngramSettings(ctx, defaults, live) {
+export function installEngramSettings(ctx, defaults, live, service) {
   const base = settingsBaseFrom(defaults);
   const schema = makeSettingsSchema(defaults);
   let source = () => base;
-  installSettingsSection(ctx, SETTINGS_NS, schema, base, {
-    setSource(current) {
-      source = current;
-    },
-    onChange() {
-      let value;
-      try {
-        value = source();
-      } catch {
-        return;
-      }
-      if (value === null || typeof value !== "object") return;
-      for (const key of SETTINGS_KEYS) {
-        if (value[key] !== void 0 && live[key] !== value[key]) live[key] = value[key];
-      }
-    },
-    validate(value) {
-      // The schema already constrains every exposed field; refuse nothing here.
-      void value;
-    },
+  ctx.inject(["settings"], (settingsCtx) => {
+    // dsh-settings 0.1.5 moved the optional-consumer wiring onto the provider
+    // instance. Keeping the registration on the scoped context preserves the
+    // provider attach/detach lifecycle while avoiding a removed helper export.
+    const provider = settingsCtx.settings;
+    if (service) {
+      service.settings = {
+        describe: () => provider.describe({ redactSecrets: true }),
+        mutate: (ns, ops, expectedRevision) => provider.mutate(ns, ops, expectedRevision),
+        update: (ns, patch, expectedRevision) => provider.update(ns, patch, expectedRevision),
+      };
+    }
+    provider.installSection(ctx, SETTINGS_NS, schema, base, {
+      setSource(current) {
+        source = current;
+      },
+      onChange() {
+        let value;
+        try {
+          value = source();
+        } catch {
+          return;
+        }
+        if (value === null || typeof value !== "object") return;
+        for (const key of SETTINGS_KEYS) {
+          if (value[key] !== void 0 && live[key] !== value[key]) live[key] = value[key];
+        }
+      },
+      validate(value) {
+        // The schema already constrains every exposed field; refuse nothing here.
+        void value;
+      },
+    });
   });
 }

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.6",
+  "version": "0.4.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -33,7 +33,8 @@
     "LICENSE"
   ],
   "engines": {
-    "node": ">=22.19.0"
+    "node": ">=22.19.0",
+    "dsh": ">=0.1.2-alpha.2 <0.2.0-0"
   },
   "scripts": {
     "setup": "node scripts/setup-links.mjs",
@@ -47,7 +48,8 @@
     "web-compaction:enable": "node scripts/dsh-engram.mjs enable",
     "web-compaction:revert": "node scripts/dsh-engram.mjs revert",
     "dsh-engram": "node scripts/dsh-engram.mjs",
-    "dsh-engram:doctor": "node scripts/dsh-engram.mjs doctor"
+    "dsh-engram:doctor": "node scripts/dsh-engram.mjs doctor",
+    "release-notes": "node scripts/gen-release-notes.mjs"
   },
   "publishConfig": {
     "access": "public"
@@ -59,9 +61,11 @@
     "client": {
       "platform": "web",
       "inject": [
-        "@deepseek-ai/dsh-client-runtime",
-        "@deepseek-ai/dsh-client-connection",
-        "@deepseek-ai/dsh-client-ui-settings"
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-renderer",
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-ui-settings-plugins"
       ]
     }
   },
@@ -69,13 +73,13 @@
     "zod": "^4.4.3"
   },
   "peerDependencies": {
-    "@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/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"
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-storage-domain": ">=0.1.2-alpha.2 <0.2.0-0",
+    "@deepseek-ai/dsh-settings": ">=0.1.2-alpha.2 <0.2.0-0",
+    "@deepseek-ai/schemastery": "^3.18.2",
+    "@deepseek-ai/dsh-compaction": ">=0.1.2-alpha.2 <0.2.0-0",
+    "@deepseek-ai/dsh-compaction-basic": ">=0.1.2-alpha.2 <0.2.0-0",
+    "@deepseek-ai/dsh-llm": ">=0.1.2-alpha.2 <0.2.0-0"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/cordis": {