dsh-engram 0.4.0 → 0.5.0

package/lib/boundary-prune.js

@@ -128,7 +128,7 @@ export function expectedSessionRequests(requestsSoFar, history, workspace, floor
 }
 
 /** Install the boundary-prune listener. Returns a disposer. */
-export function installBoundaryPrune(ctx, config, log) {
+export function installBoundaryPrune(ctx, config, log, hooks = {}, opts = {}) {
   const enabled = config?.boundaryPrune === true;
   if (!enabled) return () => {};
   const pruner = ctx.get?.("toolResultPruner");
@@ -139,7 +139,44 @@ export function installBoundaryPrune(ctx, config, log) {
   const minRemaining = Number.isFinite(config?.boundaryPruneMinRemaining)
     ? config.boundaryPruneMinRemaining
     : DEFAULT_MIN_REMAINING;
-  const history = workspaceHistory();
+  // History is injectable for tests; production reads the real session corpus.
+  const history = opts?.history ?? workspaceHistory();
+
+  // Optional threshold override (ResultPack L0, T2048 landing): the host pruner
+  // ships a fixed threshold (8192) that the plugin cannot change in place. When
+  // `boundaryPruneThresholdChars` is set, we instantiate our own pruner at that
+  // threshold — same deterministic head/middle/tail engine, lower budget — via
+  // the exported `ToolResultPruner` prototype (bypassing the cordis Service
+  // constructor, which needs a full context; the instance only uses its own
+  // `config` + `ctx.tokenMeter`). Falls back to the host pruner when the package
+  // or the token meter is unavailable. `boundaryPruneHeadChars` /
+  // `boundaryPruneTailChars` tune the retained edges (defaults stay at the
+  // host's 4096/1024).
+  let activePruner = pruner;
+  const thresholdOverride = Number.isFinite(config?.boundaryPruneThresholdChars)
+    ? Math.trunc(config.boundaryPruneThresholdChars)
+    : null;
+  if (thresholdOverride !== null && thresholdOverride > 0) {
+    activePruner = makeThresholdPruner(pruner, {
+      thresholdChars: thresholdOverride,
+      headChars: Number.isFinite(config?.boundaryPruneHeadChars) && config.boundaryPruneHeadChars > 0
+        ? Math.trunc(config.boundaryPruneHeadChars)
+        : 4096,
+      tailChars: Number.isFinite(config?.boundaryPruneTailChars) && config.boundaryPruneTailChars > 0
+        ? Math.trunc(config.boundaryPruneTailChars)
+        : 1024,
+    });
+    if (activePruner === null) {
+      log?.warn?.(
+        `engram boundary-prune: threshold override ${thresholdOverride} unavailable (pruner package/tokenMeter) — using host pruner ${pruner.config?.thresholdChars ?? "default"}`,
+      );
+      activePruner = pruner;
+    } else {
+      log?.info?.(
+        `engram boundary-prune: using threshold ${activePruner.config?.thresholdChars} (head ${activePruner.config?.headChars} / tail ${activePruner.config?.tailChars})`,
+      );
+    }
+  }
 
   /** Per-session boundary state (todo high-water mark, request count, total prunes). */
   const stateBySession = new Map();
@@ -150,12 +187,32 @@ export function installBoundaryPrune(ctx, config, log) {
       if (typeof sid !== "string" || sid.length === 0) return;
       let state = stateBySession.get(sid);
       if (!state) {
-        state = { todoCompleted: 0, requests: 0, prunes: 0, prunedResults: 0 };
+        state = { todoCompleted: 0, requests: 0, prunes: 0, prunedResults: 0, lastFireRequest: void 0 };
         stateBySession.set(sid, state);
       }
       const type = event?.type;
       if (type === "assistant/message") {
         state.requests += 1;
+        // Request-count boundary (SoL-Pi "step idle", default OFF): sessions
+        // with no todo progress / no goal never fire the event boundaries (L0
+        // corpus: ~62% of sessions), leaving their over-threshold replay
+        // exposure permanently untouched. When `boundaryPruneIdleCadence` is
+        // set, the counter itself is a boundary source: fire at most once per
+        // cadence requests, still under the repayment gate (so cadence ≠
+        // aggressive — the gate keeps per-session reuse healthy). The implied
+        // boundary kind is `step` so telemetry can attribute it.
+        const cadence = config?.boundaryPruneIdleCadence;
+        if (Number.isFinite(cadence) && cadence > 0 && state.requests % Math.trunc(cadence) === 0) {
+          const sinceLastPrune = state.lastFireRequest === void 0 ? state.requests : state.requests - state.lastFireRequest;
+          if (sinceLastPrune >= Math.trunc(cadence)) {
+            const workspace = wk(session?.header?.cwd);
+            const expectedTotal = expectedSessionRequests(state.requests, history, workspace, minRemaining);
+            if (state.requests + minRemaining <= expectedTotal) {
+              // reuse the same fire path via a synthetic boundary
+              return fireBoundary(session, { kind: "step" }, state, expectedTotal);
+            }
+          }
+        }
         return;
       }
       const boundary = isBoundary(event, state);
@@ -168,21 +225,43 @@ export function installBoundaryPrune(ctx, config, log) {
       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`,
-        );
-      }
+      return fireBoundary(session, boundary, state, expectedTotal);
     } catch (error) {
       // fully contained — a prune bug must never disturb the session pipeline
       log?.warn?.(`engram boundary-prune threw: ${String(error)}`);
     }
   };
+
+  /** Shared fire path for every boundary source (event + step-cadence). */
+  const fireBoundary = (session, boundary, state, expectedTotal) => {
+    const result = activePruner.pruneSession(session);
+    const prunedNow = result?.pruned?.length ?? 0;
+    if (prunedNow > 0) {
+      state.prunes += 1;
+      state.prunedResults += prunedNow;
+      state.lastFireRequest = state.requests;
+      log?.info?.(
+        `engram boundary-prune (${boundary.kind} @${state.requests} reqs): pruned ${prunedNow} results, saved ${result.charsRemoved} chars`,
+      );
+      // L2 hook (ResultPack): archiving + handle tail is wired by index.js
+      // when `resultPack` is enabled. Contained there — never throws here.
+      // Attach the live pruner budgets so the archiver extracts the exact
+      // removed span (archives must match what the surface now displays).
+      try {
+        const budgets = {
+          headChars: activePruner.config?.headChars ?? 4096,
+          tailChars: activePruner.config?.tailChars ?? 1024,
+        };
+        for (const item of result?.pruned ?? []) {
+          if (item && typeof item === "object") Object.assign(item, budgets);
+        }
+        hooks?.onPruned?.(session, result, boundary);
+      } catch (error) {
+        log?.warn?.(`engram boundary-prune: L2 hook threw: ${String(error)}`);
+      }
+    }
+    void expectedTotal;
+  };
   const disposeListener = ctx.on("session/event", onEvent);
   const disposeSink = ctx.on("session/disposed", (session) => {
     stateBySession.delete(session?.id);
@@ -192,3 +271,24 @@ export function installBoundaryPrune(ctx, config, log) {
     disposeSink?.();
   };
 }
+
+/**
+ * Build a pruner at an override threshold by prototyping off the injected
+ * host service instance.
+ *
+ * The host `toolResultPruner` ships a fixed budget (8192/4096/1024) that
+ * cannot be mutated in place. DSH's pruner is a plain prototype-owning class
+ * whose methods only read `this.config` and `this.ctx.tokenMeter`, so we
+ * create a child object inheriting the host instance (methods + ctx shared,
+ * config overridden on the child). Zero LLM, deterministic, contained — the
+ * host instance and its config stay untouched.
+ */
+function makeThresholdPruner(pruner, cfg) {
+  try {
+    const clone = Object.create(pruner);
+    clone.config = cfg;
+    return clone;
+  } catch {
+    return null;
+  }
+}

package/lib/client.js

@@ -2209,6 +2209,7 @@ function EngramTelemetry({ api, workspace }) {
 var import_react6 = require("react");
 var import_jsx_runtime6 = require("react/jsx-runtime");
 var KIND_COLORS = {
+  preference: "#b45309",
   decision: "#2563eb",
   error: "#dc2626",
   procedure: "#7c3aed",
@@ -2218,6 +2219,7 @@ var KIND_COLORS = {
   task: "#4f46e5"
 };
 var KIND_LABEL = {
+  preference: "\u504F\u597D",
   decision: "\u51B3\u5B9A",
   error: "\u9519\u8BEF",
   procedure: "\u6D41\u7A0B",
@@ -2567,6 +2569,7 @@ function EngramDetail({ target, api, tasks, nodes, links, onClose, onNavigateMem
 // client/src/EngramSection.tsx
 var import_jsx_runtime7 = require("react/jsx-runtime");
 var KIND_COLORS2 = {
+  preference: "#b45309",
   decision: "#2563eb",
   error: "#dc2626",
   procedure: "#7c3aed",
@@ -2576,6 +2579,7 @@ var KIND_COLORS2 = {
   task: "#4f46e5"
 };
 var KIND_LABEL2 = {
+  preference: "\u504F\u597D",
   decision: "\u51B3\u5B9A",
   error: "\u9519\u8BEF",
   procedure: "\u6D41\u7A0B",
@@ -2995,6 +2999,7 @@ function EngramSection({ api, t }) {
               /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(StatCard, { num: String(wsCounts ? wsCounts.nodes ?? 0 : overview.totals.nodes ?? 0), label: wsCounts ? "\u8282\u70B9" : "\u8282\u70B9 (\u5168\u5C40)" }),
               /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(StatCard, { num: String(workspaces.length), label: "\u5DE5\u4F5C\u533A" }),
               /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(StatCard, { num: String(overview.captures.total), label: "\u81EA\u52A8\u6355\u83B7" }),
+              /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(StatCard, { num: String(overview.captures.preference ?? 0), label: "\u504F\u597D\u6355\u83B7" }),
               /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
                 StatCard,
                 {
@@ -3369,6 +3374,10 @@ var import_react8 = require("react");
 var import_jsx_runtime8 = require("react/jsx-runtime");
 var COMMON_FIELDS = [
   { key: "autoCapture", label: "\u81EA\u52A8\u6355\u83B7", hint: "\u96F6 LLM \u4ECE\u5DE5\u5177\u7ED3\u679C\u63D0\u53D6\u8BB0\u5FC6\uFF08git/\u5173\u952E\u6587\u4EF6/\u9519\u8BEF\uFF09", kind: "bool" },
+  { key: "autoCapturePreferences", label: "\u504F\u597D\u6355\u83B7", hint: "\u7528\u6237\u7EA0\u6B63/\u504F\u597D\u5B66\u4E60\uFF1A\u68C0\u6D4B\u6D88\u606F\u91CC\u7684\u300C\u4E0D\u8981\u7528X/\u6539\u7528Y/prefer/never use\u300D\u53E5\u5F0F\uFF0C\u81EA\u52A8\u6C89\u6DC0\u4E3A preference \u8BB0\u5FC6\u5E76\u7F6E\u9876 [ENGRAM]\uFF08correx/PAHF \u5F0F\uFF0C\u96F6 LLM\uFF09", kind: "bool" },
+  { key: "boundaryPrune", label: "\u8FB9\u754C\u526A\u679D", hint: "ResultPack L1\uFF1Atodo \u5B8C\u6210/goal \u7EC8\u6001\u8FB9\u754C\u4E3B\u52A8\u526A\u6389\u8D85\u9608\u503C\u65E7\u5DE5\u5177\u7ED3\u679C\uFF08DSH \u786E\u5B9A\u6027 surface-replace\u3001\u507F\u8FD8\u95E8\u3001\u96F6 LLM\uFF1B\u9ED8\u8BA4\u5173\uFF09", kind: "bool" },
+  { key: "boundaryPruneThresholdChars", label: "\u526A\u679D\u9608\u503C(\u5B57\u7B26)", hint: "\u8986\u76D6\u5BBF\u4E3B 8192\uFF1A\u8BBE 2048 \u53EF\u66F4\u65E9\u5F00\u526A\uFF0C\u5E76\u914D L2 \u5F52\u6863\u627E\u56DE\u88AB\u526A\u4E2D\u6BB5\uFF1B\u7559\u7A7A=\u5BBF\u4E3B\u9ED8\u8BA4\u3002\u5EFA\u8BAE\u540C\u65F6\u628A\u4FDD\u7559\u8FB9\u7F18\u8C03\u5C0F\uFF08\u5982 1024/256\uFF09\u4EE5\u83B7\u5F97\u6700\u5927\u8282\u7701", kind: "num", min: 256, max: 16384, step: 256 },
+  { key: "resultPack", label: "\u7ED3\u679C\u5F52\u6863\u53EC\u56DE", hint: "ResultPack L2\uFF1A\u526A\u6389\u7684\u4E2D\u6BB5\u8131\u654F\u5F52\u6863\uFF0C\u8282\u70B9\u5C3E\u90E8\u9644 handle\uFF0C\u6A21\u578B\u53EF\u7528 result_recall(callId) \u6309\u9875\u53EC\u56DE\uFF08\u5B8C\u6574 ObservationPack\uFF1B\u9700\u4E0E\u8FB9\u754C\u526A\u679D\u4E00\u8D77\u5F00\uFF09", kind: "bool" },
   { key: "autoRecallOnStart", label: "\u4F1A\u8BDD\u542F\u52A8\u81EA\u52A8\u53EC\u56DE", hint: "\u65B0\u4F1A\u8BDD\u6309\u9996\u6761\u6D88\u606F\u81EA\u52A8\u628A\u6700\u76F8\u5173\u8BB0\u5FC6\u6CE8\u5165 [RECALL] \u5757\uFF08\u65E0\u9700\u6A21\u578B\u60F3\u8D77\u8C03 engram_recall\uFF09\uFF1B\u5173\u6389=\u56DE\u5230\u7EAF\u62C9\u53D6", kind: "bool" },
   { key: "maxRecallPerSession", label: "\u6BCF\u4F1A\u8BDD\u53BB\u91CD\u4E0A\u9650", hint: "recall \u6BCF\u4F1A\u8BDD\u6700\u591A\u4FDD\u7559 N \u6761\uFF08\u8DE8\u4F1A\u8BDD\u53BB\u91CD\uFF09", kind: "num", min: 1, max: 10 },
   { key: "expireDays", label: "TTL\uFF08\u5929\uFF09", hint: "0 = \u4E0D\u8FC7\u671F", kind: "num", min: 0, max: 3650 },
@@ -3381,6 +3390,9 @@ var ADVANCED_GROUPS = [
     description: "\u5176\u4F59\u6355\u83B7/\u641C\u7D22\u65CB\u94AE",
     fields: [
       { key: "autoCapturePerSession", label: "\u6BCF\u4F1A\u8BDD\u6355\u83B7\u4E0A\u9650", hint: "\u5355\u4F1A\u8BDD\u81EA\u52A8\u6355\u83B7\u6761\u6570\u4E0A\u9650", kind: "num", min: 0, max: 1e3 },
+      { key: "boundaryPruneHeadChars", label: "\u526A\u679D\u4FDD\u7559\u5934\u90E8(\u5B57\u7B26)", hint: "\u9608\u503C\u8986\u76D6\u751F\u6548\u65F6\u7ED3\u679C\u5F00\u5934\u4FDD\u7559\u957F\u5EA6\uFF08\u9ED8\u8BA4 4096\uFF09\uFF1B\u8C03\u5C0F\uFF08\u5982 1024\uFF09\u914D\u5408 T2048 \u66F4\u7701", kind: "num", min: 0, max: 16384, step: 128 },
+      { key: "boundaryPruneTailChars", label: "\u526A\u679D\u4FDD\u7559\u5C3E\u90E8(\u5B57\u7B26)", hint: "\u9608\u503C\u8986\u76D6\u751F\u6548\u65F6\u7ED3\u679C\u7ED3\u5C3E\u4FDD\u7559\u957F\u5EA6\uFF08\u9ED8\u8BA4 1024\uFF09\uFF1B\u8C03\u5C0F\uFF08\u5982 256\uFF09\u914D\u5408 T2048 \u66F4\u7701", kind: "num", min: 0, max: 16384, step: 128 },
+      { key: "boundaryPruneIdleCadence", label: "\u7A7A\u95F2\u6B65\u6570\u8FB9\u754C", hint: "\u6700\u591A\u6BCF N \u8BF7\u6C42\u89E6\u53D1\u4E00\u6B21\u526A\u679D\uFF0C\u8986\u76D6\u65E0 todo/goal \u7684\u4F1A\u8BDD\uFF08\u7EA6 62% \u4F1A\u8BDD\uFF09\uFF1B\u4ECD\u53D7\u507F\u8FD8\u95E8\u7EA6\u675F\uFF1B\u7559\u7A7A=\u4EC5\u4E8B\u4EF6\u8FB9\u754C", kind: "num", min: 10, max: 1e3, step: 10 },
       { key: "autoRecallLimit", label: "\u81EA\u52A8\u53EC\u56DE\u6761\u6570", hint: "[RECALL] \u5757\u6700\u591A\u6CE8\u5165\u7684\u8BB0\u5FC6\u6761\u6570\uFF08\u5C11\u800C\u51C6\uFF09", kind: "num", min: 1, max: 8 },
       { key: "sessionSearch", label: "\u4F1A\u8BDD\u5386\u53F2\u641C\u7D22", hint: "engram_recall \u652F\u6301\u8DE8\u4F1A\u8BDD FTS \u515C\u5E95", kind: "bool" },
       { key: "recallScope", label: "\u53EC\u56DE\u8303\u56F4", hint: "workspace=\u4E25\u683C\u5F53\u524D\u5DE5\u4F5C\u533A\u9694\u79BB\uFF08\u9ED8\u8BA4\uFF0Ctoken \u7EAA\u5F8B\uFF09\uFF1Bglobal=\u672C\u5DE5\u4F5C\u533A\u547D\u4E2D\u5F31/\u7A7A\u65F6\u4ECE\u5176\u5B83\u5DE5\u4F5C\u533A\u6C60\u53EC\u56DE\u5E76\u6807 [W:<workspace>] \u6765\u6E90\uFF08\u4F1A\u6253\u7834\u9694\u79BB\uFF09", kind: "select", options: ["workspace", "global"] }

package/lib/index-block.js

@@ -20,6 +20,7 @@ export function prefixFor(kind) {
     case "insight": return "I";
     case "handoff": return "H";
     case "task": return "T";
+    case "preference": return "R";
     default: return "F";
   }
 }
@@ -65,14 +66,24 @@ export function selectIndexMemories(store, workspace, config) {
             m.kind === "task"),
     )
     .sort((a, b) => {
-      const ap = isProvenProcedure(a, config) ? 0 : 1;
-      const bp = isProvenProcedure(b, config) ? 0 : 1;
+      // User preferences are standing rules — rank them above everything
+      // (still newest-first within the group). Proven procedures follow.
+      const ap = kindRank(a, config) ? 0 : 1;
+      const bp = kindRank(b, config) ? 0 : 1;
       if (ap !== bp) return ap - bp;
+      const ap2 = isProvenProcedure(a, config) ? 0 : 1;
+      const bp2 = isProvenProcedure(b, config) ? 0 : 1;
+      if (ap2 !== bp2) return ap2 - bp2;
       return byRecency(a, b);
     })
     .slice(0, config.indexMaxLines);
 }
 
+/** Preference memories outrank everything in the [ENGRAM] index block. */
+function kindRank(m, config) {
+  return (m?.kind ?? "") === "preference" && (m.signal ?? 0.5) >= (config?.minIndexSignal ?? 0.4);
+}
+
 function memoryLine(m, config) {
   const px = prefixFor(m.kind);
   const mark = isProvenProcedure(m, config) ? `${px}✓` : px;
@@ -199,14 +210,25 @@ export function renderStartRecall(store, workspace, config = {}, opts = {}) {
   const lines = [];
   const source = query === null ? "newest memory" : "recall";
   lines.push(`[RECALL] ${source} · ${fresh.length} hit(s)${query ? ` · first msg: ${escapeLt(truncate(query, 40))}` : " · no user text yet"}`);
+  // UAP (read-path activation): when a hit's oneline is truncated, say so —
+  // the model should know the full record is one `engram_detail` call away
+  // instead of assuming the 140-char preview is the whole memory. The trailing
+  // guidance then points at a concrete truncated id (or the top hit).
+  let truncatedId = null;
   for (const m of fresh) {
     const px = prefixFor(m.kind);
     const mark = isProvenProcedure(m, config) ? `${px}✓` : px;
     const date = fmtDate(m.createdAt ?? m.updatedAt);
-    const text = truncate(String(m.text).replace(/\s*\n+\s*/g, " ").trim(), 140);
-    lines.push(`- [${mark}] ${date} ${escapeLt(text)} #${shortId(m.id)}${(m.hits ?? 0) > 0 ? ` ×${m.hits}` : ""}`);
+    const full = String(m.text).replace(/\s*\n+\s*/g, " ").trim();
+    const truncated = [...full].length > 140;
+    const text = truncate(full, 140);
+    if (truncated && truncatedId === null) truncatedId = shortId(m.id);
+    lines.push(`- [${mark}] ${date} ${escapeLt(text)} #${shortId(m.id)}${truncated ? " …" : ""}${(m.hits ?? 0) > 0 ? ` ×${m.hits}` : ""}`);
   }
-  lines.push("context: use above · engram_detail <id> · engram_recall <query>");
+  const drill = truncatedId !== null
+    ? `context: use above · #${truncatedId} truncated — engram_detail ${truncatedId} (full) · engram_recall <query>`
+    : `context: use above · engram_detail <id> · engram_recall <query>`;
+  lines.push(drill);
   return enforceStartRecallCap(lines, maxChars);
 }
 

package/lib/index.js

@@ -23,11 +23,14 @@ import { openEngramDomain } from "./store.js";
 import { registerTools } from "./tools.js";
 import { makeCaptureHandler } from "./capture.js";
 import { installGoalCapture } from "./goal-capture.js";
+import { installPreferenceCapture } from "./preference.js";
 import { installBoundaryPrune } from "./boundary-prune.js";
+import { resultPackDir, archivePrunedResults, resultRecallTool, sweepExpired } from "./result-pack.js";
+import { recordBoundaryPruneFire, recordRecallInjection, readPackTelemetry, engramHome } from "./pack-telemetry.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";
-import { installEngramSettings } from "./settings.js";
+import { installEngramSettings, makeEngineConfigSchema, SETTINGS_KEYS } from "./settings.js";
 import { makeEngramRoutes } from "./api.js";
 import { collectPointerContext, mountCompactionEngine } from "./context-gc.js";
 import { provisionWebCompaction } from "./web-provision.js";
@@ -68,6 +71,11 @@ const DEFAULTS = {
   autoRecallOnStart: true,
   autoRecallLimit: 3,
   autoRecallMaxChars: 700,
+  // user-correction / preference learning (zero-LLM, auto-captured from
+  // user/message events; prefer/avoid/switch-to cues). Store as `preference`
+  // memories that outrank the [ENGRAM] index.
+  autoCapturePreferences: true,
+  preferenceCapturePerSession: 8,
   // [ENGRAM] index budget (token discipline)
   indexMaxLines: 12,
   indexMaxChars: 700,
@@ -144,23 +152,110 @@ const DEFAULTS = {
   // least this many more requests (empirical workspace prior, see
   // lib/boundary-prune.js). 50 = L0 sweep optimum.
   boundaryPruneMinRemaining: 50,
+  // Threshold override (ResultPack L0 "T2048 landing"): the host pruner is
+  // fixed at 8192; set this to a lower budget to prune earlier at boundaries
+  // (L0 says T2048 has the highest net savings +61.6Mc, gated only by the
+  // L2 archive requirement — now satisfied). 0/absent → host threshold.
+  boundaryPruneThresholdChars: 0,
+  // Edges retained by the override pruner (unless set, host's 4096/1024).
+  boundaryPruneHeadChars: 0,
+  boundaryPruneTailChars: 0,
+  // Request-count boundary (SoL-Pi "step idle", default OFF): fire at most once
+  // per N requests even in sessions with no todo/goal boundary (~62% of the L0
+  // corpus never fires the event boundaries). Still under the repayment gate.
+  // 0 → event boundaries only.
+  boundaryPruneIdleCadence: 0,
+  // ResultPack L2 (PROPOSAL-resultpack §L2): archive the middles L1 prunes
+  // off the surface (~/.dsh/engram/resultpack/<callId>.json, redacted) and
+  // append a `[middle archived: result_recall(<callId>) 可取]` handle tail to
+  // each pruned node; register `result_recall(callId, offset?)` for paged
+  // recall — the full ObservationPack pattern (SoL-Pi mech ③; paired
+  // EdgeBench −23.58%). Requires `boundaryPrune: true` to have anything to
+  // archive (L2 without L1 is a no-op with a log line). Default OFF (C13).
+  resultPack: false,
+  // result_recall page budget (chars per page). 4000 fits a typical model
+  // context band without re-materializing huge results whole.
+  resultPackPageChars: 4000,
+  // Retain archived middles this many days (mtime sweep, same GC cadence).
+  resultPackRetentionDays: 7,
 };
 
+/**
+ * Cordis reads `plugin.Config` off the module: DSH ≥0.1.7 validates the
+ * `engram` profile row against it AND projects the settings form from it —
+ * the curated SETTINGS_KEYS are `.volatile()`, so the settings service exposes
+ * exactly the GUI card's knobs (entry id `engram`), while every other DEFAULTS
+ * key stays a plain declared field so profile-patch config survives validation.
+ */
+export const Config = makeEngineConfigSchema(DEFAULTS);
+
 export function resolveConfig(config) {
   const src = config && typeof config === "object" ? config : {};
   const out = { ...DEFAULTS };
   for (const key of Object.keys(DEFAULTS)) {
-    if (src[key] !== void 0) out[key] = src[key];
+    if (src[key] !== void 0) {
+      // A volatile reference may hold a nullish value (e.g. a profile patch
+      // listed a knob as null, or schemastery's null-default sentinel); the
+      // `??` keeps the DEFAULTS value in that case instead of nulling out.
+      out[key] = unwrapValue(src[key]) ?? DEFAULTS[key];
+    }
   }
   return out;
 }
 
+/** Unwrap a volatile config reference (DSH ≥0.1.7 settings) to its plain value. */
+function unwrapValue(value) {
+  return value !== null && typeof value === "object" && typeof value.get === "function" ? value.get() : value;
+}
+
+/**
+ * Collect the volatile config references for the given keys from a plugin
+ * config object (DSH ≥0.1.7 validates `Config` into volatile references that
+ * the loader commits into IN PLACE on settings-card edits). Plain values are
+ * skipped, so this is a no-op on legacy DSH.
+ */
+export function collectVolatileRefs(config, keys) {
+  const refs = {};
+  if (config !== null && typeof config === "object") {
+    for (const key of keys) {
+      const ref = config[key];
+      if (ref !== null && typeof ref === "object" && typeof ref.get === "function") refs[key] = ref;
+    }
+  }
+  return refs;
+}
+
+/**
+ * Re-read volatile references into a resolved config (`target`, mutated in
+ * place): the loader has committed a settings-card edit into the same refs and
+ * emitted `loader/volatile-update`. Nullish refs fall back to DEFAULTS (the
+ * schemastery null-default sentinel yields an undefined ref value). Returns
+ * the keys whose value actually changed.
+ */
+export function syncVolatileRefs(refs, target) {
+  const changed = [];
+  for (const key of Object.keys(refs)) {
+    const next = unwrapValue(refs[key]) ?? DEFAULTS[key];
+    if (next !== target[key]) {
+      target[key] = next;
+      changed.push(key);
+    }
+  }
+  return changed;
+}
+
 /**
  * Mount the plugin. `ctx` is the scoped cordis context; `config` the optional
  * resolved plugin config (plain object from the profile patch).
  */
 export function apply(ctx, config) {
   const resolved = resolveConfig(config);
+  // DSH ≥0.1.7 / 0.2.x settings model: the GUI card edits the `engram`
+  // entry's VOLATILE Config fields. The loader commits those into the same
+  // references (in place) and emits `loader/volatile-update` — hold the refs
+  // so a card edit re-syncs `resolved` live for new sessions (blocks already
+  // frozen for a session stay frozen — the plugin's documented contract).
+  const volatileRefs = collectVolatileRefs(config, SETTINGS_KEYS);
   if (!resolved.enabled) return;
 
   const log = ctx.logger ? ctx.logger("engram") : undefined;
@@ -220,7 +315,10 @@ export function apply(ctx, config) {
     sessionQuery,
     log,
     /** Cumulative auto-capture totals (GUI overview observability). */
-    captureStats: { total: 0, git: 0, file: 0, error: 0 },
+    captureStats: { total: 0, git: 0, file: 0, error: 0, preference: 0 },
+    /** SoL-Pi activation telemetry (M15/C13): durable boundary-prune fires +
+     *  [RECALL] injection funnel, read at request time (readPackTelemetry). */
+    packTelemetry: () => readPackTelemetry({ home: engramHome() }),
     /** Last GC sweep totals (GUI overview observability). */
     gcStats: { lastRun: 0, archivedMemories: 0, archivedTasks: 0, removedLinks: 0 },
     /** Live Context GC status (API overview + durable status file). */
@@ -264,6 +362,11 @@ export function apply(ctx, config) {
       if (report.archivedMemories.length + report.archivedTasks.length + report.removedLinks.length > 0) {
         log?.info?.(`engram gc: ${report.archivedMemories.length} memories archived, ${report.archivedTasks.length} tasks, ${report.removedLinks.length} links removed`);
       }
+      // ResultPack L2 archive sweep rides the same GC cadence (mtime-based).
+      if (resolved.resultPack === true) {
+        const removed = sweepExpired(resultPackDir(), resolved.resultPackRetentionDays ?? 7);
+        if (removed > 0) log?.info?.(`engram gc: ${removed} expired result-pack archives removed`);
+      }
     } catch (error) {
       log?.warn?.(`engram gc sweep failed: ${String(error)}`);
     }
@@ -327,7 +430,18 @@ export function apply(ctx, config) {
           pendingRecall = true;
         } else {
           const recall = renderStartRecall(opened, workspace, resolved, { query, allowRecencyFallback: false });
-          block = recall.length > 0 ? `${block}\n${recall}`.trim() : block;
+          if (recall.length > 0) {
+            // Activation funnel, injection leg: a [RECALL] block actually made
+            // it into a session. Counted here (the block only materializes when
+            // the render produced hits), so /stats can close the loop with
+            // engram_recall/engram_detail tool calls from the session logs.
+            recordRecallInjection({
+              home: engramHome(),
+              workspace,
+              hits: (recall.match(/- \[/g) ?? []).length,
+            });
+            block = `${block}\n${recall}`.trim();
+          }
         }
       }
     } catch (error) {
@@ -392,6 +506,17 @@ export function apply(ctx, config) {
   ctx.effect(() => {
     const disposers = [];
 
+    // Settings card edits (volatile Config fields) hot-commit into the refs
+    // in place; re-read them so `resolved` reflects new values for new
+    // sessions without a profile restart. Legacy DSH never emits this event
+    // and leaves `volatileRefs` empty, so the listener is inert there.
+    if (Object.keys(volatileRefs).length > 0) {
+      const disposeVolatile = ctx.on?.("loader/volatile-update", () => {
+        syncVolatileRefs(volatileRefs, resolved);
+      });
+      if (disposeVolatile !== void 0) disposers.push(disposeVolatile);
+    }
+
     // tools
     disposers.push(registerTools(ctx, service));
 
@@ -622,11 +747,62 @@ export function apply(ctx, config) {
       const disposeGoal = installGoalCapture(ctx, captureStore, log);
       disposers.push(disposeGoal);
 
+      // User-correction / preference learning (zero-LLM): `user/message`
+      // events carrying explicit prefer/avoid/switch-to cues auto-sediment as
+      // `preference` memories (correx / PAHF / Mem0 preference-extraction
+      // pattern, distilled to pure rules). No model call.
+      const disposePreference = installPreferenceCapture(ctx, captureStore, resolved, log, service.captureStats);
+      disposers.push(disposePreference);
+
       // 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);
+      const l2Dir = resultPackDir();
+      const disposeBoundaryPrune = installBoundaryPrune(ctx, resolved, log, {
+        // ResultPack L2 hook: archive the pruned middles (redacted) + append
+        // a handle tail on each pruned node. Fail-contained in result-pack.js.
+        // Also records durable activation telemetry (SoL-Pi M15/C13) —
+        // independent of `resultPack`: /stats must be able to prove the L1
+        // mechanism actually fires on the live profile.
+        onPruned: (session, report, boundary) => {
+          recordBoundaryPruneFire({
+            home: engramHome(),
+            boundary,
+            report,
+            workspace: wk(session?.header?.cwd),
+          });
+          if (resolved.resultPack !== true) return;
+          const workspace = wk(session?.header?.cwd);
+          archivePrunedResults({
+            dir: l2Dir,
+            session,
+            report,
+            workspace,
+            log,
+          });
+        },
+      });
       disposers.push(disposeBoundaryPrune);
+
+      // ResultPack L2 tool (default OFF with L1): `result_recall(callId, offset?)`
+      // pages back an archived middle. Independent of the memory domain — the
+      // archive lives on the filesystem. Registers only when enabled; without
+      // boundayPrune there is nothing to archive, so it self-disables.
+      if (resolved.resultPack === true) {
+        if (resolved.boundaryPrune !== true) {
+          log?.warn?.("engram result-pack: requires boundaryPrune: true to prune middles — result_recall not registered");
+        } else {
+          const pageChars = Number.isFinite(resolved.resultPackPageChars)
+            ? resolved.resultPackPageChars
+            : 4000;
+          disposers.push(
+            ctx.effect(() => {
+              ctx.tools.register(resultRecallTool(l2Dir, pageChars));
+              log?.info?.(`engram result-pack enabled: result_recall(callId, offset) registered; archive dir ${l2Dir}`);
+            }),
+          );
+        }
+      }
     }
 
     // memory GC scheduling: one sweep after the store is reachable, then on