dsh-engram 0.3.4 → 0.3.5

package/lib/context-gc.js

@@ -12,12 +12,18 @@
  * with no re-fetchable backing) get a scoped LLM narrative — the safety net,
  * configurable off for a pure-mechanical zero-LLM path.
  *
- * The 6 pi-esr GC constraints:
+ * The 6 pi-esr GC constraints (+ the harness shrink gate that keeps them legal):
  *   - indexed-output-evictable → pointer to `engram_detail(id)` / `engram_recall`
  *   - stable-task-evictable    → pointer to the [ESR] block / `esr_ready`
  *   - working-set-protected    → active tasks restated in the summary
  *   - pointer-salience         → every evicted category has an explicit re-fetch call
  *   - no-provenance-no-evict   → un-provenanced turns via scoped narrative or verbatim
+ *   - shrink-gated             → the framed checkpoint must be STRICTLY SMALLER
+ *     than the evicted span (`fitSummaryToSpan`): the harness refuses and rolls
+ *     back any summary that is not smaller, which otherwise blocks every auto
+ *     compaction and pushes the session into the model-side context overflow.
+ *     The pointer/narrative body is therefore fitted under the span with the
+ *     host token meter, truncating tail detail (still durable in the log).
  *
  * Layout: the pure (zero-LLM, dependency-free) layer lives here; the DSH
  * `CompactionEngine` binding is `loadContextGcEngine`, behind a guarded dynamic
@@ -67,6 +73,152 @@ export function blockText(content) {
   return out.trim();
 }
 
+/**
+ * The durable checkpoint framing the harness applies to a compaction summary
+ * before accepting it (`frameSummary()` in dsh-compaction-basic): the summary
+ * body is wrapped in a preamble + `<compacted-summary>` tags and the WHOLE
+ * framed user message must estimate strictly SMALLER than the evicted span,
+ * or the harness throws `summary is not smaller than the shadowed content`
+ * and rolls the compaction back. These constants mirror that framing so the
+ * Context GC can self-predict acceptance with the host token meter (verified
+ * to reproduce the harness's estimate exactly); a small safety margin absorbs
+ * any harness drift.
+ */
+const FRAME_PREAMBLE =
+  "This is an automatically generated checkpoint condensing an earlier span of the conversation to free up context. Treat the captured context as established background and build on it without restating it. Continue the task directly from the messages that follow, without acknowledging this checkpoint.";
+const FRAME_OPEN_TAG = "<compacted-summary>";
+const FRAME_CLOSE_TAG = "</compacted-summary>";
+
+/** Best-effort token estimate of one derived message through the host meter. */
+function estimateMessageTokens(meter, message) {
+  if (typeof meter?.estimateMessage !== "function") return 0;
+  try {
+    const tokens = meter.estimateMessage(message);
+    return Number.isFinite(tokens) && tokens > 0 ? tokens : 0;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Exact token estimate of the span a compaction is about to shadow: the sum of
+ * the evicted region's derived messages through the SAME token meter the
+ * harness compares against (verified to equal the harness's shadowed count).
+ * Returns 0 when no meter is available — callers then skip the shrink gate
+ * rather than guess.
+ * @param {object|undefined} meter - `ctx.tokenMeter` (host), or undefined.
+ * @param {Array<object>} messages - the region messages passed to `summarize`.
+ * @returns {number}
+ */
+export function estimateShadowedTokens(meter, messages) {
+  const list = Array.isArray(messages) ? messages : [];
+  let total = 0;
+  for (const message of list) total += estimateMessageTokens(meter, message);
+  return total;
+}
+
+/** The harness-framed checkpoint user message for a summary body. */
+function framedCheckpointMessage(bodyText) {
+  return {
+    role: "user",
+    content: [
+      { type: "text", text: `${FRAME_PREAMBLE}\n\n${FRAME_OPEN_TAG}` },
+      { type: "text", text: bodyText },
+      { type: "text", text: FRAME_CLOSE_TAG },
+    ],
+  };
+}
+
+/**
+ * Token estimate of the framed checkpoint the harness will generate for this
+ * body (mirrors `frameSummary` + `createUserMessage` + `estimateMessage`;
+ * verified byte-identical to the live meter). Without a meter, a conservative
+ * chars→tokens heuristic is used — divided by two so both CJK and latin
+ * over-estimate, biasing toward trimming more, never less.
+ * @param {object|undefined} meter - `ctx.tokenMeter`, or undefined.
+ * @param {string} bodyText - the summary body inside the checkpoint.
+ * @returns {number}
+ */
+export function estimateFramedTokens(meter, bodyText) {
+  if (typeof meter?.estimateMessage === "function") {
+    try {
+      const tokens = meter.estimateMessage(framedCheckpointMessage(bodyText));
+      if (Number.isFinite(tokens)) return Math.max(1, tokens);
+    } catch {
+      // fall through to the char heuristic
+    }
+  }
+  const text = typeof bodyText === "string" ? bodyText : "";
+  return (
+    Math.ceil((FRAME_PREAMBLE.length + FRAME_OPEN_TAG.length + FRAME_CLOSE_TAG.length + text.length) / 2) + 8
+  );
+}
+
+/** Truncation note appended when the checkpoint must shrink to fit the span. */
+const FIT_SUFFIX = "\n_…(full detail stays re-fetchable via the engram/ESR tools; see the session log)_";
+
+/**
+ * Shrink a Context GC summary body so the framed checkpoint stays strictly
+ * under the evicted span — the harness's hard shrink gate. Without this, a
+ * large verbatim/pointer body makes every automatic pressure / overflow
+ * compaction roll back (`summary is not smaller than the shadowed content`),
+ * the context never shrinks, and the session eventually hits the model-side
+ * context overflow.
+ *
+ * Truncation keeps the largest PREFIX that still fits — the pointer head and
+ * working set survive, only tail detail is cut — and appends a short note when
+ * the span is large enough to afford one. Exact under the host token meter;
+ * deterministic everywhere; degrades to an empty body for spans so small that
+ * the exact framing overhead does not fit (the stock LLM summarizer would be
+ * refused by the harness for those too).
+ *
+ * @param {string} bodyText - the full Context GC body.
+ * @param {number} shadowedTokens - evicted-span token estimate (0 = unknown).
+ * @param {{meter?: object, margin?: number}} [opts]
+ * @returns {{ text: string, framed: number, shadowed: number, trimmed: boolean }}
+ */
+export function fitSummaryToSpan(bodyText, shadowedTokens, opts = {}) {
+  const meter = opts?.meter;
+  const margin = opts?.margin ?? 4;
+  const budget = shadowedTokens - margin;
+  if (!Number.isFinite(shadowedTokens) || shadowedTokens <= 0 || budget <= 1) {
+    return {
+      text: bodyText,
+      framed: estimateFramedTokens(meter, bodyText),
+      shadowed: shadowedTokens,
+      trimmed: false,
+    };
+  }
+  const source = typeof bodyText === "string" && bodyText.length > 0 ? bodyText : "";
+  if (estimateFramedTokens(meter, source) < budget) {
+    return {
+      text: source,
+      framed: estimateFramedTokens(meter, source),
+      shadowed: shadowedTokens,
+      trimmed: false,
+    };
+  }
+  // Largest prefix of the source that fits WITHOUT the note; the note is only
+  // re-added when the budget still affords it (the note itself is ~25 tokens).
+  let lo = 0;
+  let hi = source.length;
+  let best = 0;
+  while (lo <= hi) {
+    const mid = Math.floor((lo + hi) / 2);
+    if (estimateFramedTokens(meter, source.slice(0, mid)) < budget) {
+      best = mid;
+      lo = mid + 1;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  const prefix = source.slice(0, best);
+  const withNote = `${prefix}${FIT_SUFFIX}`;
+  const text = best > 0 && estimateFramedTokens(meter, withNote) < budget ? withNote : prefix;
+  const trimmed = text !== source;
+  return { text, framed: estimateFramedTokens(meter, text), shadowed: shadowedTokens, trimmed };
+}
+
 function addSet(set, value) {
   const v = String(value ?? "").trim();
   if (v.length > 0) set.add(v);
@@ -466,6 +618,57 @@ export async function loadCompactionEngine(ctx, config = {}, deps = {}, { mode =
   return loadContextGcEngine(ctx, config, deps);
 }
 
+/**
+ * Mount the compaction engine onto `ctx` — THE shared entry both planes use
+ * (host plane: the main engram plugin's `apply`; preset plane: the
+ * `dsh-engram/compaction` row shown in an agent preset's `compaction` group).
+ *
+ * `config.gcReplacesCompaction === false` → mount the bare default LLM
+ * summarizer instead (keeps the `compaction` service alive after the profile
+ * patch disabled the base `compaction-basic` row); otherwise mount the
+ * ContextGcEngine override. `deps.readWorkspace(ws, report)` is how the engine
+ * reaches engram/ESR state for pointer classification — the caller supplies
+ * its own lazy-domain binding.
+ *
+ * Fully contained: an unimportable backend or a duplicate `compaction`
+ * provider (cordis refuses second registration) only warns and returns null —
+ * the host keeps whatever compaction it already has, never a crash.
+ *
+ * @returns {Promise<Function|null>} the mounted engine class, or null.
+ */
+export async function mountCompactionEngine(ctx, config = {}, deps = {}) {
+  const mode = config.gcReplacesCompaction === false ? "default" : "context-gc";
+  const engineDeps =
+    mode === "context-gc"
+      ? {
+          narrativeEnabled: config.gcNarrative !== false,
+          narrativeMaxTokens: config.gcNarrativeMaxTokens ?? 1024,
+          narrativeMaxChars: config.gcNarrativeMaxChars ?? 4000,
+          ...deps,
+        }
+      : {};
+  const Engine = await loadCompactionEngine(ctx, { auto: true }, engineDeps, { mode });
+  if (!Engine) {
+    ctx?.logger?.warn?.("engram context-gc: dsh-compaction-basic unavailable — no compaction engine");
+    return null;
+  }
+  try {
+    new Engine();
+  } catch (error) {
+    // Duplicate `compaction` provider (base row not disabled) or constructor
+    // refusal: keep whatever is already registered, never crash the host.
+    ctx?.logger?.warn?.(
+      `engram context-gc mount skipped (${error instanceof Error ? error.message : String(error)}) — keeping the existing compaction service`,
+    );
+    return null;
+  }
+  ctx?.logger?.info?.(
+    `engram context-gc: compaction = ${mode === "context-gc" ? "Context GC (mechanical eviction + re-fetch pointers)" : "default LLM summarizer (gcReplacesCompaction:false)"}`,
+  );
+  return Engine;
+}
+
+
 /**
  * Load the DSH binding: a `ContextGcEngine extends BasicCompactionEngine`
  * whose sole override is `summarize()`. Returns `null` when
@@ -542,9 +745,38 @@ export async function loadContextGcEngine(ctx, config = {}, deps = {}) {
         callLlm,
       });
 
-      const summaryText = buildContextGcSummary(report, safeContext, { turns, narrative });
+      let summaryText = buildContextGcSummary(report, safeContext, { turns, narrative });
+
+      // The harness refuses any checkpoint whose framed token estimate is >=
+      // the evicted span (see fitSummaryToSpan). Fit the body under that span
+      // so automatic pressure / context-overflow compaction COMMITS instead of
+      // rolling back — otherwise the session only grows until the model-side
+      // context overflow fires.
+      const meter = this.ctx?.tokenMeter;
+      const shadowedTokens = estimateShadowedTokens(meter, messages);
+      const fit = fitSummaryToSpan(summaryText, shadowedTokens, { meter });
+      if (fit.trimmed && typeof this.ctx?.logger?.info === "function") {
+        this.ctx.logger.info(
+          `engram context-gc: checkpoint trimmed to fit the evicted span (${fit.framed} framed vs ${fit.shadowed} shadowed tokens)`,
+        );
+      }
+      summaryText = fit.text;
+
       const result = { summary: [{ type: "text", text: summaryText }] };
       if (narrative.llm && typeof narrative.llm === "object") Object.assign(result, narrative.llm);
+      // The harness's durable `compaction/summary` record ALWAYS carries
+      // `provider`/`model` (spread unconditionally; undefined values reject the
+      // whole event as non-JSON-serializable). The mechanical path makes no LLM
+      // call, so stamp the conversation's routed target — the same model the
+      // default summarizer would have used — as the record's provenance.
+      const target = this._narrativeTarget(agent);
+      if (target && typeof target.provider === "string" && typeof target.model === "string") {
+        result.provider = result.provider ?? target.provider;
+        result.model = result.model ?? target.model;
+      }
+      if (result.maxTokens === undefined && this.config && Number.isFinite(this.config.maxTokens)) {
+        result.maxTokens = this.config.maxTokens;
+      }
       return result;
     }
 

package/lib/goal-capture.js

@@ -0,0 +1,89 @@
+/**
+ * dsh-engram: DSH goal-domain integration.
+ *
+ * The harness's goal service persists a durable `goal/change` session event on
+ * every goal mutation. This module listens for those events and turns the two
+ * terminal states into memories, so a completed / blocked goal survives the
+ * session — deterministic, zero LLM, purely mechanical:
+ *
+ *   - complete → `handoff` memory (high signal, tag `goal`)
+ *   - block    → `error` memory (tag `goal` + `blocked`) — the blocker is a
+ *                real, recall-worthy signal
+ *
+ * The goal snapshot fields are read verbatim; nothing here calls a model and
+ * the listener never throws into the session pipeline (fully contained).
+ */
+
+import { workspaceKey as wk } from "./util.js";
+
+function isRecord(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+
+/**
+ * Pure reducer: map a `goal/change` session-event payload to a memory entry,
+ * or null when the event is not a terminal goal state worth sedimenting.
+ * Deterministic and unit-testable without the harness.
+ */
+export function goalChangeToMemory(change) {
+  if (!isRecord(change) || change.kind !== "goal/change") return null;
+  if (change.operation !== "complete" && change.operation !== "block") return null;
+  const goal = change.goal;
+  if (!isRecord(goal) || typeof goal.objective !== "string") return null;
+  const objective = goal.objective.trim().slice(0, 400);
+  if (objective.length === 0) return null;
+  if (change.operation === "complete") {
+    return {
+      kind: "handoff",
+      text: `goal complete: ${objective}`,
+      tags: ["goal", "auto-captured", "complete"],
+      signal: 0.6,
+    };
+  }
+  const reason = typeof goal.blockedReason === "string" && goal.blockedReason.trim().length > 0
+    ? ` — ${goal.blockedReason.trim().slice(0, 160)}`
+    : "";
+  return {
+    kind: "error",
+    text: `goal blocked: ${objective}${reason}`,
+    tags: ["goal", "auto-captured", "blocked"],
+    signal: 0.4,
+  };
+}
+
+/**
+ * Install the `session/event` listener that auto-sediments terminal goals.
+ * `storeAdapter` is any { storeMemory(entry) -> Promise } face (the same lazy
+ * adapter auto-capture uses); it is resolved per event, so early events that
+ * beat the first domain open are simply dropped. Returns the disposer.
+ */
+export function installGoalCapture(ctx, storeAdapter, log) {
+  const onEvent = (session, event) => {
+    try {
+      if (event?.type !== "goal/change") return;
+      const entry = goalChangeToMemory(event.data);
+      if (entry === null) return;
+      const cwd = session?.header?.cwd;
+      const sessionId = session?.id;
+      if (typeof cwd !== "string" || cwd.length === 0) return;
+      if (typeof sessionId !== "string" || sessionId.length === 0) return;
+      storeAdapter
+        .storeMemory({
+          workspace: wk(cwd),
+          kind: entry.kind,
+          text: entry.text,
+          tags: entry.tags,
+          signal: entry.signal,
+          filePath: null,
+          sessionId,
+          seq: 0,
+        })
+        .then(() => {})
+        .catch((error) => log?.warn?.(`engram goal capture failed: ${String(error)}`));
+    } catch (error) {
+      // fully contained — a capture bug must never disturb the session pipeline
+      log?.warn?.(`engram goal capture threw: ${String(error)}`);
+    }
+  };
+  return ctx.on("session/event", onEvent);
+}

package/lib/index-block.js

@@ -51,7 +51,11 @@ export function isProvenProcedure(m, config) {
  */
 export function selectIndexMemories(store, workspace, config) {
   const all = store.listMemories(workspace, 200);
+  // Stale truth (a newer memory marked itself as replacing that row) never
+  // earns an index line — the current statement is the one worth surfacing.
+  const { supersededBy } = store.memoryRelations?.(workspace) ?? { supersededBy: new Map() };
   return all
+    .filter((m) => !supersededBy.has(m.id))
     .filter(
       (m) =>
         (isGitPlumbingEcho(m) && (m.hits ?? 0) < config.promoteHits

package/lib/index.js

@@ -6,8 +6,10 @@
  *   - a compact, per-session-frozen [ENGRAM] symbolic index injected through a
  *     systemPrompt section (order 40) — prefix-stable for KV cache reuse
  *   - an [ESR] task/closure block (order 41) listing evidence gaps
- *   - six tight tools: engram_store / engram_recall / engram_detail / esr_task /
- *     esr_close / esr_link
+ *   - fourteen tight tools: memory plane (engram_store / engram_recall /
+ *     engram_detail) + ESR protocol (esr_task / esr_close / esr_link / esr_dep /
+ *     esr_claim / esr_unclaim / esr_ready / esr_status / esr_node / esr_gc /
+ *     esr_model)
  *   - storage on ctx.storageDomain (JSON unit dsh_engram), reads synchronous
  *
  * All model-visible writes are immediate (no approval gate — zero friction,
@@ -20,11 +22,15 @@ import { resolve as resolvePath } from "node:path";
 import { openEngramDomain } from "./store.js";
 import { registerTools } from "./tools.js";
 import { makeCaptureHandler } from "./capture.js";
+import { installGoalCapture } from "./goal-capture.js";
 import { renderIndex, 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 { makeEngramRoutes } from "./api.js";
-import { loadCompactionEngine, collectPointerContext } from "./context-gc.js";
+import { collectPointerContext, mountCompactionEngine } from "./context-gc.js";
+import { provisionWebCompaction } from "./web-provision.js";
+import { writeContextGcStatus } from "./status.js";
 import { workspaceKey as wk } from "./util.js";
 
 /** Stable cordis plugin name. */
@@ -88,9 +94,30 @@ const DEFAULTS = {
   minErrorHits: 2,
   // P3: an active task with no update for this many days is surfaced as stale.
   staleTaskDays: 14,
+  // Session-end todo continuity (audit follow-up): when a session is disposed
+  // while its plan still has pending todos, auto-sink them into ESR as DRAFT
+  // tasks (deduped by name, capped by maxTasksPerWorkspace). During the session
+  // nothing is auto-written — todo stays cheap/ephemeral and the [ESR] prefix
+  // stays stable; the sink only lands drafts, which still need the deliberate
+  // esr_claim / esr_task step to become active.
+  autoSinkTodosOnEnd: true,
+  // Web-plane auto-wiring for Context GC: web sessions resolve `compaction`
+  // inside the agent preset's own realm, which a profile patch cannot reach,
+  // so the plugin edits every stock-layout preset's `compaction` group once —
+  // the default preset plus the whole roster (shipped + user roots) — swapping
+  // the `compaction-basic` row for `dsh-engram/compaction` (backup + strict
+  // validation + idempotent; a preset with a custom compaction layout — or
+  // none, like `minimal` — is never touched). Off = every preset keeps DSH's
+  // default LLM summarizer; the host plane (headless/TUI/base) is unaffected.
+  autoWebCompaction: true,
+  // Memory-to-memory semantics (zero LLM): when ON, an entity-anchored write
+  // that carries a replacement/negation cue ("改用 / no longer / switched…")
+  // auto-marks the matching older same-entity+kind memory as superseded.
+  // OFF by default — explicit `supersedes` is always the primary path.
+  autoSupersede: false,
 };
 
-function resolveConfig(config) {
+export function resolveConfig(config) {
   const src = config && typeof config === "object" ? config : {};
   const out = { ...DEFAULTS };
   for (const key of Object.keys(DEFAULTS)) {
@@ -167,6 +194,12 @@ export function apply(ctx, config) {
     captureStats: { total: 0, git: 0, file: 0, error: 0 },
     /** 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). */
+    compactionStatus: {
+      host: "pending",
+      web: { action: "pending", presets: [] },
+      config: { autoWebCompaction: resolved.autoWebCompaction, gcReplacesCompaction: resolved.gcReplacesCompaction, gcNarrative: resolved.gcNarrative },
+    },
     /** Recompute the exact [ENGRAM] block for a workspace (GUI overview cost). */
     renderIndexBlock(workspace) {
       if (opened === void 0) return "";
@@ -313,6 +346,117 @@ export function apply(ctx, config) {
     // tools
     disposers.push(registerTools(ctx, service));
 
+    // Context GC (host plane) — the auto-GC that REPLACES DSH's built-in
+    // lossy LLM-summary compaction. Mounts the `compaction` service on THIS
+    // fiber (cordis removes it again when the fiber tears down, so reloading /
+    // unloading engram rolls back automatically). The profile patch disables
+    // the base `compaction-basic` row, making engram the sole provider:
+    // `gcReplacesCompaction:true` (default) → ContextGcEngine; `false` → a bare
+    // BasicCompactionEngine so the `compaction` service never disappears while
+    // dsh-engram is installed. Web profiles mount per-session compaction inside
+    // the agent preset's own realm (see README); this host-plane provider
+    // covers headless/TUI/base profiles and any host-plane consumer.
+    const hostCompactionPromise = mountCompactionEngine(ctx, resolved, {
+      readWorkspace: async (workspace, report) => {
+        if (!workspace) return null;
+        try {
+          const domain = await service.getDomain();
+          return collectPointerContext(domain, wk(workspace), report);
+        } catch {
+          return null;
+        }
+      },
+    });
+    disposers.push(() => {
+      // The engine's service registration is fiber-scoped and auto-removed on
+      // teardown; this only settles the async mount and surfaces late errors.
+      void hostCompactionPromise.catch(() => {});
+    });
+
+    // Context GC status: record the settled host/web facts and flush a durable
+    // snapshot to $DSH_HOME/engram/context-gc.status.json once BOTH planes have
+    // settled (the web inject may never fire on a profile without agentPresets,
+    // so a bounded timer marks the web plane done for host-only profiles).
+    let hostSettled = false;
+    let webSettled = resolved.autoWebCompaction === false;
+    let statusTimer = void 0;
+    const flushStatus = () => {
+      if (!hostSettled || !webSettled) return;
+      if (statusTimer !== void 0) { clearTimeout(statusTimer); statusTimer = void 0; }
+      void writeContextGcStatus({
+        planes: resolved.autoWebCompaction === false ? ["host"] : ["host", "web"],
+        host: service.compactionStatus.host,
+        web: service.compactionStatus.web,
+        config: service.compactionStatus.config,
+        configSource: {
+          autoWebCompaction: resolved.autoWebCompaction,
+          gcReplacesCompaction: resolved.gcReplacesCompaction,
+          gcNarrative: resolved.gcNarrative,
+        },
+      }).catch(() => {});
+    };
+    void hostCompactionPromise
+      .then((Engine) => {
+        hostSettled = true;
+        service.compactionStatus.host = Engine
+          ? (resolved.gcReplacesCompaction ? "context-gc" : "default")
+          : "unavailable";
+        flushStatus();
+      })
+      .catch(() => {
+        hostSettled = true;
+        service.compactionStatus.host = "unavailable";
+        flushStatus();
+      });
+
+    // Web-plane auto-wiring (Context GC): web sessions resolve `compaction`
+    // inside the agent preset's own realm, which a profile patch cannot reach.
+    // When the `agentPresets` service is present, swap the stock
+    // `compaction-basic` row for `dsh-engram/compaction` in every stock-layout
+    // preset — the default one plus the whole roster (shipped + user roots) —
+    // so a session composed from any preset gets Context GC. Surgical,
+    // idempotent, backed up, validated; a preset with a custom compaction
+    // layout (or none) is never touched. The row's engine config is derived
+    // from the settings knobs (`gcReplacesCompaction` / `gcNarrative`), so
+    // changing them re-provisions the web rows on the next boot. Flip
+    // `autoWebCompaction:false` to stop auto-wiring on later boots (it does
+    // not un-wire already-wired presets — use `npm run web-compaction:revert`
+    // for that). Best-effort: a failure only warns.
+    if (resolved.autoWebCompaction !== false) {
+      ctx.inject(["agentPresets"], (webCtx) => {
+        const agentPresets = webCtx.get("agentPresets");
+        provisionWebCompaction(agentPresets, {
+          rowConfig: {
+            gcReplacesCompaction: resolved.gcReplacesCompaction,
+            gcNarrative: resolved.gcNarrative,
+          },
+          log: (line) => webCtx.logger.info(line),
+        })
+          .then((report) => {
+            webSettled = true;
+            service.compactionStatus.web = { action: report.action, presets: report.presets };
+            flushStatus();
+          })
+          .catch((error) => {
+            webSettled = true;
+            service.compactionStatus.web = { action: "failed", presets: [], error: String(error?.message ?? error) };
+            webCtx.logger.warn(`engram web-provision failed: ${String(error?.message ?? error)}`);
+            flushStatus();
+          });
+      });
+      // Host-only profiles never provide `agentPresets`; settle the web plane
+      // after a bounded wait so the status flush still happens there.
+      statusTimer = setTimeout(() => {
+        if (!webSettled) {
+          webSettled = true;
+          flushStatus();
+        }
+      }, 15_000);
+      setTimeout(() => { statusTimer = void 0; }, 16_000);
+    } else {
+      flushStatus();
+    }
+
     // systemPrompt sections (frozen per session)
     const systemPrompt = ctx.get("systemPrompt");
     if (systemPrompt !== void 0) {
@@ -359,6 +503,38 @@ export function apply(ctx, config) {
     });
     disposers.push(disposeTrigger);
 
+    // session-end todo auto-sink: a session whose plan still has pending todos
+    // lands them as ESR drafts at its teardown edge, so the plan survives the
+    // session (flip `autoSinkTodosOnEnd` off to opt out). Live-toggleable — the
+    // flag is read per event. Fully contained: a sink failure only warns.
+    const disposeSink = ctx.on("session/disposed", (session) => {
+      if (resolved.autoSinkTodosOnEnd === false) return;
+      const cwd = session?.header?.cwd;
+      const sessionId = session?.id;
+      if (typeof cwd !== "string" || cwd.length === 0) return;
+      if (typeof sessionId !== "string" || sessionId.length === 0) return;
+      const todos = pendingTodosFromSession(session);
+      if (todos.length === 0) return;
+      const workspace = wk(cwd);
+      service
+        .getDomain()
+        .then((domain) =>
+          sinkPendingTodos(domain, workspace, todos, {
+            sessionId,
+            maxTasks: resolved.maxTasksPerWorkspace,
+          }),
+        )
+        .then((report) => {
+          if (report.created.length > 0) {
+            log?.info?.(`engram todo auto-sink: ${report.created.length} pending todo(s) → ${report.created.length} ESR draft(s) in ${workspace}`);
+          } else if (report.existed.length > 0 || report.atCap.length > 0) {
+            log?.info?.(`engram todo auto-sink: ${report.existed.length} already in ESR, ${report.atCap.length} skipped (cap) in ${workspace}`);
+          }
+        })
+        .catch((error) => log?.warn?.(`engram todo auto-sink failed: ${String(error)}`));
+    });
+    disposers.push(disposeSink);
+
     // zero-LLM auto-capture
     if (resolved.autoCapture) {
       // The capture handler needs a storeMemory face, but the domain opens
@@ -374,12 +550,28 @@ export function apply(ctx, config) {
           }
           return domain.storeMemory(...args);
         },
+        // failure→fix closure reads (sync; [] until the domain is open)
+        listMemories(workspace, limit) {
+          const domain = service.openedDomain();
+          return domain === void 0 ? [] : domain.listMemories(workspace, limit);
+        },
+        // failure→fix closure tags prior error rows as resolved (async)
+        tagMemory(workspace, id, tag) {
+          const domain = service.openedDomain();
+          return domain === void 0 ? Promise.resolve(false) : domain.tagMemory(workspace, id, tag);
+        },
       };
       const capture = makeCaptureHandler(captureStore, resolved, log, service.captureStats);
       const disposeCapture = ctx.on("tools/result", (exec, result) => {
         capture(exec, result);
       });
       disposers.push(disposeCapture);
+
+      // DSH goal-domain integration: a completed/blocked goal auto-sediments
+      // as a memory (`goal/change` session event → handoff/error row), so the
+      // outcome survives the session without any LLM call.
+      const disposeGoal = installGoalCapture(ctx, captureStore, log);
+      disposers.push(disposeGoal);
     }
 
     // memory GC scheduling: one sweep after the store is reachable, then on

package/lib/redact.js

@@ -0,0 +1,48 @@
+/**
+ * dsh-engram: deterministic secret redaction for the memory write path.
+ *
+ * Auto-captured tool results, git commit subjects and error messages can
+ * carry real credentials (API keys, tokens, private keys) into long-term
+ * memory — and later straight back into a prompt via recall/[ENGRAM]. This
+ * module strips them BEFORE persistence so nothing sensitive is ever stored.
+ *
+ * Rule-based and deterministic (same input ⇒ same output, zero deps, zero
+ * LLM). Replacement markers are derived from the secret kind, so exact
+ * duplicate detection and error-revival hashing keep behaving consistently
+ * across runs. Applied once at the single store write choke point
+ * (`storeMemory`), which covers engram_store, auto-capture and any future
+ * write path.
+ */
+
+const RULES = [
+  // Private key blocks (longest first so later rules cannot see them).
+  [/-----BEGIN [A-Z0-9 ]+PRIVATE KEY-----[\s\S]*?-----END [A-Z0-9 ]+PRIVATE KEY-----/g, "<REDACTED:private-key>"],
+  // JWT (header.payload.signature).
+  [/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g, "<REDACTED:jwt>"],
+  // Stripe live/test keys.
+  [/\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{16,}\b/g, "<REDACTED:stripe>"],
+  // OpenAI/Anthropic/OpenRouter style sk-… keys.
+  [/\bsk-(?:ant-)?[A-Za-z0-9_-]{16,}\b/g, "<REDACTED:sk>"],
+  // GitHub fine-grained / classic tokens.
+  [/\bgh[pousr]_[A-Za-z0-9]{20,}\b/g, "<REDACTED:github>"],
+  // AWS access key IDs.
+  [/\b(?:AKIA|ASIA|AGPA|AIDA|AROA|AIPA|ANPA|ANVA)[0-9A-Z]{16}\b/g, "<REDACTED:aws>"],
+  // Slack workspace tokens.
+  [/\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g, "<REDACTED:slack>"],
+  // Basic auth user:pass inside URLs.
+  [/\/\/[^:\/\s]+:[^@\s\/]+@/g, "//<REDACTED>@"],
+  // Authorization: Bearer <long token>.
+  [/\bBearer\s+[A-Za-z0-9._~+\/-]{16,}\b/gi, "<REDACTED:bearer>"],
+  // Generic key=value / key: value assignments for obvious secret keys.
+  [/\b(?:api[_-]?key|apikey|access[_-]?token|auth[_-]?token|client[_-]?secret|secret|passwd|password|persist[_-]?token|refresh[_-]?token|token)\b\s*[:=]\s*['"]?[A-Za-z0-9_\-.\/+=]{6,}['"]?/gi, "<REDACTED:key>"],
+];
+
+/**
+ * Redact known secret shapes in `text`. Deterministic: identical input yields
+ * identical output. Non-secret prose is untouched.
+ */
+export function redactText(text) {
+  let out = String(text ?? "");
+  for (const [re, repl] of RULES) out = out.replace(re, repl);
+  return out;
+}