dsh-engram 0.3.0 → 0.3.3

package/lib/index-block.js

@@ -130,16 +130,36 @@ function enforceCharCap(lines, maxChars) {
 }
 
 /**
- * One-line, data-driven escalation reminder. Surfaces the workspace real
- * recent mem-vs-esr balance (usage rollup, last 14 days) so the model sees
- * its own under-proactivity at the next session and can self-correct NOW.
- * Returns "" when there is nothing to correct (no data, too small a sample,
- * or the balance is healthy) — the reminder disappears once behaviour
- * improves, closing the loop.
+ * One-line escalation reminder from an arbitrary balance view
+ * ({ memCalls, esrCalls, days }). Surfaces the workspace real recent
+ * mem-vs-esr balance so the model sees its own under-proactivity and can
+ * self-correct NOW. Returns "" when there is nothing to correct (no data,
+ * too small a sample, or the balance is healthy) — the reminder disappears
+ * once behaviour improves, closing the loop. Pure, deterministic.
  */
-export function escalationHint(store, workspace) {
+export function esrBalanceHint(balance) {
+  if (balance === void 0 || balance === null) return "";
+  const memCalls = balance.memCalls ?? 0;
+  const esrCalls = balance.esrCalls ?? 0;
+  const days = balance.days ?? 0;
+  // No data or too little signal — lecturing on <3 memory ops is noise.
+  if (memCalls < 3 || days < 1) return "";
+  const ratio = esrCalls / (memCalls + esrCalls);
+  // Healthy once esr exceeds ~a third of memory-ops volume; otherwise nudge.
+  if (ratio >= 0.34) return "";
+  return `escalate: last ${days}d ${memCalls} mem ops vs ${esrCalls} esr calls (${Math.round(ratio * 100)}%) — multi-step work → esr_task now, recurring objects → esr_node, related things → esr_link, and close with evidence (esr_close) #suggest-escalate`;
+}
+
+/**
+ * Balance view derived from the per-(workspace,day) `usage` table (legacy).
+ * The table is no longer written in production (assessment P3 moved
+ * observability to on-demand session-log scans); this path exists for
+ * backward compatibility and store-driven tests. Production prefers the
+ * live in-memory recorder view (lib/trigger.js) so the nudge is not starved.
+ */
+export function usageBalanceView(store, workspace) {
   const rows = store.usageRows(workspace);
-  if (rows.length === 0) return "";
+  if (rows.length === 0) return null;
   const recent = rows.slice(-14);
   const MEM = ["engram_store", "engram_recall", "engram_detail", "loom_store", "loom_recall", "loom_detail"];
   const ESR = ["esr_task", "esr_node", "esr_close", "esr_link", "esr_gc"];
@@ -150,44 +170,276 @@ export function escalationHint(store, workspace) {
     for (const k of MEM) memCalls += c[k] ?? 0;
     for (const k of ESR) esrCalls += c[k] ?? 0;
   }
-  // No data or too little signal — lecturing on <3 memory ops is noise.
-  if (memCalls < 3) return "";
-  const ratio = esrCalls / (memCalls + esrCalls);
-  // Healthy once esr exceeds ~half the memory-ops volume; otherwise nudge.
-  if (ratio >= 0.34) return "";
-  return `escalate: last ${recent.length}d ${memCalls} mem ops vs ${esrCalls} esr calls (${Math.round(ratio * 100)}%) — multi-step work → esr_task now, recurring objects → esr_node, related things → esr_link, and close with evidence (esr_close)`;
+  return { memCalls, esrCalls, days: recent.length };
+}
+
+/**
+ * Legacy entry point (store-driven escalation nudge). Kept for callers/tests
+ * that predate the decision-point recorder; prefer `esrBalanceHint` with a
+ * live balance view.
+ */
+export function escalationHint(store, workspace) {
+  return esrBalanceHint(usageBalanceView(store, workspace));
+}
+
+/**
+ * The three ESR closure evidence gates for a task. Null/empty counts as a gap.
+ */
+export function evidenceGaps(t) {
+  const gaps = [];
+  if (t.artifact === null || t.artifact === "") gaps.push("artifact");
+  if (t.evaluation === null || t.evaluation === "") gaps.push("evaluation");
+  if (t.memoryRefs.length === 0) gaps.push("memory_ref");
+  return gaps;
 }
 
 /**
- * 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.
+ * "What should I do with this task next" sort rank — READY-to-close first
+ * (evidence complete → esr_close is the highest-value next move), then claimed
+ * in-progress, then other active, then drafts.
  */
-export function renderEsr(store, workspace, config) {
+function taskNextRank(t) {
+  if (t.state === "stable") return 10;
+  if (evidenceGaps(t).length === 0) return 0;
+  if (t.assignee) return 1;
+  if (t.state === "active") return 2;
+  if (t.state === "draft") return 3;
+  return 4;
+}
+
+/**
+ * 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);
+    const rb = taskNextRank(b);
+    if (ra !== rb) return ra - rb;
+    const ga = evidenceGaps(a).length;
+    const gb = evidenceGaps(b).length;
+    if (ga !== gb) return ga - gb;
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+  });
+}
+
+/**
+ * Recurring-failure candidates (P0-B): error memories that earned
+ * `hits >= minErrorHits` through repeat-failure revival — durable breakage,
+ * the strongest "turn this into a root-cause task" signal. Most-hit first.
+ */
+export function selectRootCauseCandidates(store, workspace, config) {
+  const min = (config?.minErrorHits ?? 2) | 0;
+  if (min < 1) return [];
+  return store
+    .listMemories(workspace, 200)
+    .filter((m) => m.kind === "error" && (m.hits ?? 0) >= min)
+    .sort((a, b) => (b.hits ?? 0) - (a.hits ?? 0) || (b.updatedAt ?? 0) - (a.updatedAt ?? 0))
+    .map((m) => ({ id: m.id, text: String(m.text), hits: m.hits ?? 0 }));
+}
+
+/**
+ * Stale-task candidates (P3): active tasks that have not been touched for
+ * `staleTaskDays` (default 14) — close with evidence or drop the intent.
+ */
+export function selectStaleCandidates(tasks, config) {
+  const days = (config?.staleTaskDays ?? 14) | 0;
+  if (days < 1) return [];
+  const cutoff = Date.now() - days * 86_400_000;
+  return tasks
+    .filter((t) => (t.updatedAt ?? t.createdAt ?? 0) < cutoff)
+    .map((t) => ({ id: t.id, name: t.name, updatedAt: t.updatedAt ?? t.createdAt, createdAt: t.createdAt }));
+}
+
+/**
+ * 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.
+ *
+ * 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 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 hint = escalationHint(store, workspace);
+  const draft = active.filter((t) => t.state === "draft").length;
+  const ordered = sortActiveForNext(active);
+
   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)";
-    return hint === "" ? base : `${base}\n${hint}`;
+    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`);
-  for (const t of active.slice(0, 8)) lines.push(`- ${t.id.slice(0, 6)}: ${escapeLt(truncate(t.name, 60))} — ${t.state.toUpperCase()}${taskGapSuffix(t)}`);
+  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)`);
+  }
+  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 (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");
 }
 
 function taskGapSuffix(t) {
   if (t.state === "stable") return "";
-  const gaps = [];
-  if (t.artifact === null || t.artifact === "") gaps.push("artifact");
-  if (t.evaluation === null || t.evaluation === "") gaps.push("evaluation");
-  if (t.memoryRefs.length === 0) gaps.push("memory_ref");
+  const gaps = evidenceGaps(t);
   return gaps.length === 0 ? " · READY to close" : ` · gap: ${gaps.join(", ")}`;
 }

package/lib/index.js

@@ -20,9 +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";
@@ -56,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: [],
@@ -65,7 +76,18 @@ 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
+  // active ESR tasks × todoPromoteRatio (default: pending > active).
+  minTodosForPromote: 2,
+  todoPromoteRatio: 1,
+  // P0-B: an error memory becomes a root-cause task candidate at this many
+  // repeat-failure hits.
+  minErrorHits: 2,
+  // P3: an active task with no update for this many days is surfaced as stale.
+  staleTaskDays: 14,
 };
 
 function resolveConfig(config) {
@@ -127,10 +149,15 @@ export function apply(ctx, config) {
     return domainPromise;
   };
 
+  // Decision-point triggers (P0-A + P1): live mem-vs-esr balance + the
+  // todo_write promote hook. Process-local; fed by a tools/result listener.
+  const recorder = makeTriggerRecorder(resolved);
+
   const service = {
     config: resolved,
     getDomain,
     openedDomain: () => opened,
+    recorder,
     ensureDomain: () => {
       getDomain().catch(() => {});
     },
@@ -149,7 +176,7 @@ 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 {
@@ -204,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 "";
@@ -230,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 = [];
 
@@ -254,27 +331,34 @@ 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);
-          } catch {
-            return "";
-          }
+          return esrBlockFor(agent);
         },
       });
       disposers.push(() => esrDispose());
     }
 
+    // decision-point triggers: always on (independent of autoCapture) —
+    // feeds the live mem-vs-esr balance and the todo_write promote hint.
+    const disposeTrigger = ctx.on("tools/result", (exec, result) => {
+      recorder.handle(exec, result);
+    });
+    disposers.push(disposeTrigger);
+
     // zero-LLM auto-capture
     if (resolved.autoCapture) {
       // The capture handler needs a storeMemory face, but the domain opens
@@ -322,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");
@@ -776,6 +791,22 @@ export async function openEngramDomain(facility) {
     addLink(link) {
       return links.put(link.id, link);
     },
+    /** Idempotent variant: skip when the same (source, relation, target) edge
+     *  already exists in the workspace — used by auto-wiring paths so repeated
+     *  calls never duplicate a relation. */
+    async addLinkOnce(link) {
+      const dup = [...links.entries()]
+        .map(([, l]) => l)
+        .some(
+          (l) =>
+            l.workspace === link.workspace &&
+            l.source === link.source &&
+            l.target === link.target &&
+            (l.relation ?? "") === (link.relation ?? ""),
+        );
+      if (!dup) await links.put(link.id, link);
+      return !dup;
+    },
     linksFor(workspace, entity) {
       return [...links.entries()]
         .map(([, l]) => l)