dsh-engram 0.3.4 → 0.3.6

package/lib/api.js

@@ -18,6 +18,9 @@ export const API_PREFIX = "/api/dsh-engram";
 /** Cap on JSON request bodies (archives/deletes are tiny). */
 const MAX_JSON_BODY_BYTES = 32 * 1024;
 
+/** Import dumps carry whole workspaces of memories/tasks — allow up to 32 MiB. */
+const MAX_IMPORT_BODY_BYTES = 32 * 1024 * 1024;
+
 /** Loopback literal check plus browser same-origin markers. */
 function isLoopbackRequest(request, trustedHosts = []) {
   const address = request.socket?.remoteAddress;
@@ -67,13 +70,13 @@ function readQuery(req) {
   return url.searchParams;
 }
 
-function readJsonBody(req) {
+function readJsonBody(req, maxBytes = MAX_JSON_BODY_BYTES) {
   return new Promise((resolve) => {
     let size = 0;
     const chunks = [];
     req.on("data", (chunk) => {
       size += chunk.length;
-      if (size > MAX_JSON_BODY_BYTES) {
+      if (size > maxBytes) {
         resolve({ error: "body too large" });
         req.destroy();
         return;
@@ -157,6 +160,7 @@ export function makeEngramRoutes(service) {
       indexes,
       captures: service.captureStats ?? { total: 0, git: 0, file: 0, error: 0 },
       gc: service.gcStats ?? { lastRun: 0, archivedMemories: 0, archivedTasks: 0, removedLinks: 0 },
+      compaction: service.compactionStatus ?? { host: "unknown", web: { action: "unknown", presets: [] } },
       config: service.config ?? {},
       anonymous: {
         version: 2,
@@ -180,6 +184,23 @@ export function makeEngramRoutes(service) {
     writeJson(res, 200, { items });
   };
 
+  // Goal-domain sediment: memories auto-captured from `goal/change` events
+  // (tag "goal"). A compact read surface for the GUI, backed by the same
+  // searchMemory view as /memories.
+  const goals = async (req, res) => {
+    const domain = await withDomain(res);
+    if (domain === void 0) return;
+    const params = readQuery(req);
+    const limit = Number(params.get("limit") ?? 50);
+    const items = domain.searchMemories({
+      workspace: params.get("workspace") || void 0,
+      tag: "goal",
+      status: "active",
+      limit,
+    }).map((m) => ({ id: m.id, kind: m.kind, text: m.text, createdAt: m.createdAt, workspace: m.workspace }));
+    writeJson(res, 200, { items });
+  };
+
   const tasks = async (req, res) => {
     const domain = await withDomain(res);
     if (domain === void 0) return;
@@ -282,6 +303,56 @@ export function makeEngramRoutes(service) {
     }
   };
 
+  /**
+   * Data contract — dump every row (memories/tasks/links/entities, archived
+   * included) of one workspace (`?workspace=`) or of every workspace, in the
+   * machine-readable `dsh-engram/export` v1 format that `POST /import`
+   * round-trips. Export is the stable, format-versioned exit door: the memory
+   * corpus never depends on engram's internal tables, and a thin adapter
+   * (another harness, MCP, a plain backup script) only needs this shape.
+   */
+  const exportData = async (req, res) => {
+    const domain = await withDomain(res);
+    if (domain === void 0) return;
+    const workspace = readQuery(req).get("workspace") || void 0;
+    try {
+      writeJson(res, 200, domain.exportAll(workspace));
+    } catch (error) {
+      writeError(res, 500, String(error?.message ?? error));
+    }
+  };
+
+  /** Data contract — restore a `dsh-engram/export` dump (see store.importAll:
+   *  merge = idempotent add-missing, replace = wipe workspace then restore;
+   *  `dryRun` plans without writing; `confirm: "restore"` is required for the
+   *  destructive replace mode). Memory text passes the same secret redactor as
+   *  every other write path. */
+  const importData = async (req, res) => {
+    const domain = await withDomain(res);
+    if (domain === void 0) return;
+    const body = await readJsonBody(req, MAX_IMPORT_BODY_BYTES);
+    if (body.error) return writeError(res, 400, body.error);
+    const { payload, mode, dryRun, workspace, confirm } = body.value ?? {};
+    if (mode !== "merge" && mode !== "replace") {
+      return writeError(res, 400, "mode must be 'merge' or 'replace'");
+    }
+    if (mode === "replace" && confirm !== "restore") {
+      return writeError(res, 400, "replace mode is destructive — pass confirm: \"restore\" to proceed");
+    }
+    try {
+      const report = await domain.importAll(payload, {
+        mode: mode ?? "merge",
+        dryRun: dryRun === true,
+        workspace: typeof workspace === "string" && workspace.length > 0 ? workspace : void 0,
+        config: service.config ?? {},
+      });
+      writeJson(res, 200, report);
+    } catch (error) {
+      const status = error instanceof Error && error.code === "ENGRAM_INVALID_ARGS" ? 400 : 500;
+      writeError(res, status, String(error?.message ?? error));
+    }
+  };
+
   const guard = (req, res, method, handler) => {
     if ((req.method ?? "GET").toUpperCase() !== method) {
       writeError(res, 405, "method not allowed");
@@ -503,6 +574,7 @@ export function makeEngramRoutes(service) {
   return [
     make("GET", "/overview", overview),
     make("GET", "/memories", memories),
+    make("GET", "/goals", goals),
     makeUnion("/tasks", { GET: tasks, POST: createTask }),
     make("GET", "/links", links),
     make("GET", "/nodes", entities),
@@ -517,5 +589,7 @@ export function makeEngramRoutes(service) {
     make("POST", "/memories/delete", remove),
     make("POST", "/tasks/close", closeTask),
     make("POST", "/gc", gcRun),
+    make("GET", "/export", exportData),
+    make("POST", "/import", importData),
   ];
 }

package/lib/capture.js

@@ -11,6 +11,8 @@
  *     branch / tag / cherry-pick). Pure plumbing (`push`, `stash`, `status`)
  *     is deliberately NOT captured: those are operational echoes, not lasting
  *     decisions, and would only drown the memory pool and the [ENGRAM] index.
+ *   - failing test runs (`npm test` / `node --test` / vitest / jest / pytest)
+ *     as high-signal error memories tagged `test`.
  *   - writes/edits to significant config & doc paths
  *   - repeated tool errors (error signal, deduped by message)
  * symbolic-index's own insight: one file edit is noise; accumulated edits and rare
@@ -22,6 +24,56 @@ import { workspaceKey as workspaceKeyOf } from "./util.js";
 
 const GIT_MILESTONE_SIGNAL = 0.5;
 const GIT_COMMIT_SIGNAL = 0.55;
+const TEST_FAILURE_SIGNAL = 0.35;
+const FIX_CLOSURE_SIGNAL = 0.45;
+
+/** Concrete text: a test-run command (npm/pnpm/yarn/bun/npx/node --test/…). */
+const TEST_RUN_RE = /\b(npm|pnpm|yarn|bun|npx|corepack)\s+(?:run\s+)?test\b|\bnode\s+--test\b|\bvitest\b|\bpytest\b|\bjest\b/;
+/** A result line that reads as a failure point (deterministic keyword scan). */
+const FAILURE_LINE_RE = /(assertionerror|#\s*fail(?:ed)?|not\s+ok|✗|✖|✘|\bFAIL(?:ED)?\b|tests?\s+failed|failed\s+tests?\b|\d+\s+failed|non-zero exit|exception|traceback|error:\s)/i;
+
+/**
+ * Normalize a command to a stable short signature tag (first two tokens,
+ * spaces → underscores, ≤48 chars) used to pair a failure with its later
+ * successful run. Returns null for empty commands.
+ */
+export function cmdTag(command) {
+  const tokens = String(command ?? "").trim().split(/\s+/).filter(Boolean).slice(0, 2);
+  if (tokens.length === 0) return null;
+  return `cmd:${tokens.join("_").slice(0, 48)}`;
+}
+
+/**
+ * Failure→fix closure (zero LLM): when a command that previously failed (an
+ * ACTIVE kind:error memory tagged with the same `cmd:` signature) now runs
+ * successfully, produce a `procedure` memory plus the ids of the resolved
+ * error rows. Deterministic; fires only on genuine same-command
+ * success-after-failure.
+ */
+export function fixClosureEntry(name, command, result, previousErrors) {
+  if (!["bash", "shell", "exec"].includes(name)) return null;
+  if (result?.isError === true) return null; // not a success
+  if (typeof command !== "string" || command.trim().length === 0) return null;
+  const tag = cmdTag(command);
+  if (tag === null) return null;
+  const failing = (previousErrors ?? []).filter(
+    (m) => m.kind === "error" && m.status === "active" && (m.tags ?? []).includes(tag),
+  );
+  if (failing.length === 0) return null;
+  const head = command.trim().split(/\s+/).slice(0, 2).join(" ");
+  const isTest = TEST_RUN_RE.test(command);
+  const plural = failing.length > 1 ? "s" : "";
+  return {
+    entry: {
+      kind: "procedure",
+      text: `fixed: ${head} — ${failing.length} earlier failing run${plural} now succeed`,
+      signal: FIX_CLOSURE_SIGNAL,
+      tags: ["procedure", "auto-captured", "fix", tag, ...(isTest ? ["test"] : [])],
+      filePath: null,
+    },
+    resolvedIds: failing.map((m) => m.id),
+  };
+}
 
 /** Git operations that carry lasting meaning (milestones). */
 const GIT_OPS = [
@@ -109,9 +161,30 @@ export function makeCaptureHandler(store, config, log, stats) {
         // Errors take precedence over tool-name classification: a failed edit
         // tool is a FAILURE of that file, not an "Edited" event (filePath anchor).
         const errPath = String(args.path ?? args.file_path ?? args.filePath ?? "");
-        const msg = errorHead(result);
-        if (msg !== null) {
-          entry = { kind: "error", text: `${name} failed: ${msg}`, signal: 0.25, tags: ["error", "auto-captured"], filePath: errPath || null };
+        const cmd = cmdTag(args.command); // pairs this failure with a later success
+        // A failing test run is the highest-value coding signal: name it
+        // explicitly and surface the concrete failure point.
+        const testFail = extractTestFailure(name, args.command, result);
+        if (testFail !== null) {
+          entry = { kind: "error", text: testFail, signal: TEST_FAILURE_SIGNAL, tags: ["error", "test", "auto-captured", cmd].filter(Boolean), filePath: null };
+        } else {
+          const msg = errorHead(result);
+          if (msg !== null) {
+            entry = { kind: "error", text: `${name} failed: ${msg}`, signal: 0.25, tags: ["error", "auto-captured", cmd].filter(Boolean), filePath: errPath || null };
+          }
+        }
+      } else if (isCommandRun(name) && typeof args.command === "string" && store.listMemories !== void 0) {
+        // Failure→fix closure: the same command that once failed now succeeds —
+        // sediment a `procedure` and resolve the earlier error rows.
+        const fix = fixClosureEntry(
+          name,
+          args.command,
+          result,
+          store.listMemories(workspaceKeyOf(cwd), 200),
+        );
+        if (fix !== null) {
+          entry = fix.entry;
+          entry._resolvedIds = fix.resolvedIds;
         }
       } else if (EDIT_TOOLS.has(name)) {
         const path = String(args.path ?? args.file_path ?? args.filePath ?? "");
@@ -142,6 +215,7 @@ export function makeCaptureHandler(store, config, log, stats) {
         recent.delete(first);
       }
 
+      const resolvedIds = entry._resolvedIds ?? [];
       void store
         .storeMemory(
           {
@@ -156,7 +230,13 @@ export function makeCaptureHandler(store, config, log, stats) {
           },
           config,
         )
-        .then(() => {})
+        .then(() => {
+          // Failure→fix closure: mark the earlier error rows resolved (tag
+          // append only — never re-ranks them, per store.tagMemory's contract).
+          for (const id of resolvedIds) {
+            void store.tagMemory?.(workspaceKeyOf(cwd), id, "resolved")?.catch?.(() => null);
+          }
+        })
         .catch((error) => log?.warn?.(`engram auto-capture failed: ${String(error)}`));
     } catch (error) {
       // fully contained — a capture bug must never disturb the tool pipeline
@@ -187,6 +267,11 @@ function extractGit(name, command) {
   return null;
 }
 
+/** Shell-run tool names whose failures/successes carry a command signature. */
+function isCommandRun(name) {
+  return name === "bash" || name === "shell" || name === "exec";
+}
+
 function errorHead(result) {
   // canonical value or rendered content
   const value = result?.value;
@@ -206,6 +291,49 @@ function errorHead(result) {
   return null;
 }
 
+/**
+ * When a bash/shell run of a test command exits non-zero, produce a
+ * deterministic failure memory: `tests failed (<cmd>): <failure line>`.
+ * Returns null for non-test commands, successful runs, or when no failure
+ * line can be pinned down (generic error extraction then applies).
+ */
+function extractTestFailure(name, command, result) {
+  if (name !== "bash" && name !== "shell" && name !== "exec") return null;
+  if (typeof command !== "string" || !TEST_RUN_RE.test(command)) return null;
+  if (result?.isError !== true) return null;
+  const line = failureLine(result);
+  if (line === null) return null;
+  const head = command.trim().split(/\s+/).slice(0, 2).join(" ");
+  return `tests failed (${head}): ${line}`;
+}
+
+/** First failure-flavoured line of a result (≤120 chars), else its head. */
+function failureLine(result) {
+  const blocks = [];
+  const value = result?.value;
+  if (typeof value === "string" && value.length > 0) blocks.push(value);
+  if (value !== null && typeof value === "object") {
+    for (const k of ["error", "stderr", "message", "stdout"]) {
+      if (typeof value[k] === "string" && value[k].length > 0) blocks.push(value[k]);
+    }
+  }
+  const content = result?.content;
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (block?.type === "text" && typeof block.text === "string") blocks.push(block.text);
+    }
+  }
+  for (const block of blocks) {
+    const lines = block.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim().replace(/\s+/g, " ").slice(0, 120);
+      if (FAILURE_LINE_RE.test(trimmed)) return trimmed;
+    }
+  }
+  const first = blocks[0];
+  return typeof first === "string" && first.length > 0 ? first.split("\n")[0].trim().slice(0, 120) : null;
+}
+
 function dirOf(path) {
   const i = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
   return i > 0 ? path.slice(0, i) : ".";

package/lib/client.js

@@ -3341,6 +3341,7 @@ 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: "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 },
   { key: "indexMaxChars", label: "\u7D22\u5F15\u5B57\u7B26\u4E0A\u9650", hint: "[ENGRAM] \u5757 token \u9884\u7B97", kind: "num", min: 0, max: 4e3 }
@@ -3352,7 +3353,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: "sessionSearch", label: "\u4F1A\u8BDD\u5386\u53F2\u641C\u7D22", hint: "engram_recall \u652F\u6301\u8DE8\u4F1A\u8BDD FTS \u515C\u5E95", kind: "bool" }
+      { 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"] }
     ]
   },
   {
@@ -3374,7 +3377,17 @@ var ADVANCED_GROUPS = [
       { key: "gcEnabled", label: "\u8BB0\u5FC6 GC", hint: "\u5B9A\u65F6\u56DE\u6536\uFF08\u8FC7\u671F/\u8D85\u5BB9\u91CF/stable \u8D85\u7A97/\u60AC\u7A7A\u94FE\u63A5\uFF09", kind: "bool" },
       { key: "gcNarrative", label: "Context GC \u53D9\u4E8B\u515C\u5E95", hint: "\u81EA\u52A8 compact \u65F6\u65E0\u951A\u8F6E\u6B21\u7528 LLM \u6458\u8981\uFF1B\u5173\u6389=\u7EAF\u673A\u68B0\uFF08\u96F6 LLM\uFF09", kind: "bool" },
       { key: "gcStableRetentionDays", label: "stable \u4EFB\u52A1\u4FDD\u7559\uFF08\u5929\uFF09", hint: "\u8D85\u7A97\u540E\u7531 GC \u5F52\u6863\u3001\u79BB\u5F00 [ESR] \u8868\u9762", kind: "num", min: 0, max: 3650 },
-      { key: "verifyArtifact", label: "\u6821\u9A8C artifact \u5B58\u5728", hint: "esr_close \u7684 artifact \u987B\u5728\u5DE5\u4F5C\u533A\u78C1\u76D8\u4E0A\u771F\u5B9E\u5B58\u5728\uFF08URL \u8C41\u514D\uFF09\uFF1Bforce:true/\u5173\u6389\u53EF\u8DF3\u8FC7", kind: "bool" }
+      { key: "verifyArtifact", label: "\u6821\u9A8C artifact \u5B58\u5728", hint: "esr_close \u7684 artifact \u987B\u5728\u5DE5\u4F5C\u533A\u78C1\u76D8\u4E0A\u771F\u5B9E\u5B58\u5728\uFF08URL \u8C41\u514D\uFF09\uFF1Bforce:true/\u5173\u6389\u53EF\u8DF3\u8FC7", kind: "bool" },
+      { key: "autoSinkTodosOnEnd", label: "\u4F1A\u8BDD\u7ED3\u675F\u81EA\u52A8\u6C89\u6DC0 todo", hint: "\u4F1A\u8BDD\u7ED3\u675F\u65F6\u4ECD pending \u7684 todo \u81EA\u52A8\u8F6C\u6210 ESR draft\uFF08\u6309\u540D\u53BB\u91CD\u3001\u53D7\u4EFB\u52A1\u4E0A\u9650\u7EA6\u675F\uFF09\uFF1B\u5173\u6389=\u968F\u4F1A\u8BDD\u5F03\u53BB", kind: "bool" },
+      { key: "autoWebCompaction", label: "web \u9762\u81EA\u52A8\u542F\u7528 Context GC", hint: "\u542F\u52A8\u65F6\u628A\u5168\u90E8 stock \u5E03\u5C40\u7684 agent \u9884\u8BBE\uFF08shipped + \u81EA\u5B9A\u4E49\u6839\uFF09\u7684 compaction \u7EC4\u81EA\u52A8\u6362\u6210 dsh-engram/compaction\uFF1B\u5173\u6389=\u4E0D\u518D\u81EA\u52A8\u63A5\u7BA1\uFF08\u5DF2\u63A5\u7BA1\u7684\u9700 web-compaction:revert \u8FD8\u539F\uFF09", kind: "bool" }
+    ]
+  },
+  {
+    id: "semantics-adv",
+    title: "\u8BB0\u5FC6\u8BED\u4E49\uFF08\u9AD8\u7EA7\uFF09",
+    description: "supersedes / contradict \u7684\u542F\u53D1\u5F0F",
+    fields: [
+      { key: "autoSupersede", label: "\u81EA\u52A8 supersedes", hint: "\u5B9E\u4F53\u951A\u5B9A + \u66FF\u6362\u5F0F\u66F4\u65B0\uFF08\u6539\u7528/\u4E0D\u518D/no longer\u2026\uFF09\u81EA\u52A8\u628A\u65E7\u8BB0\u5FC6\u6807\u4E3A superseded\uFF1B\u65E7\u884C\u4FDD\u7559\u3001\u53EC\u56DE\u964D\u7EA7\u3002\u9ED8\u8BA4\u5173\uFF0C\u663E\u5F0F supersedes \u6C38\u8FDC\u4F18\u5148", kind: "bool" }
     ]
   },
   {
@@ -3641,6 +3654,15 @@ function EngramConfigCard({ scope }) {
             disabled: !writable,
             onChange: (e) => setField(field.key, e.target.checked)
           }
+        ) : field.kind === "select" ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+          "select",
+          {
+            style: { ...s3.input, width: field.width ?? 160 },
+            value: raw === void 0 ? "" : String(raw),
+            disabled: !writable,
+            onChange: (e) => setField(field.key, e.target.value),
+            children: (field.options ?? []).map((opt) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("option", { value: opt, children: opt }, opt))
+          }
         ) : field.kind === "text" ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
           "input",
           {
@@ -3882,6 +3904,26 @@ var TREND_LABEL = {
   weakening: "\u51CF\u5F31",
   stale: "\u9648\u65E7"
 };
+function ContextGcChip({ compaction }) {
+  const host = compaction?.host ?? "unknown";
+  const hostLabel = host === "context-gc" ? "Context GC\xB7\u4E3B\u673A" : host === "default" ? "\u9ED8\u8BA4\u6458\u8981" : host === "unavailable" ? "GC \u4E0D\u53EF\u7528" : "GC \u72B6\u6001\u2026";
+  const wired = (compaction?.web?.presets ?? []).filter((p) => p.action === "swapped" || p.action === "already").length;
+  const webLabel = wired > 0 ? `\xB7${wired} \u9884\u8BBE` : "";
+  const color = host === "context-gc" ? "var(--dsw-alias-success-strong, #059669)" : host === "default" || host === "unavailable" ? "var(--dsw-alias-label-secondary, var(--dsh-color-muted, #6b7280))" : "var(--dsw-alias-label-tertiary, #9ca3af)";
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(
+    "span",
+    {
+      title: `host \u5E73\u9762\uFF1A${host}
+web \u5E73\u9762\uFF1A${compaction?.web?.action ?? "?"}\uFF08${wired} \u4E2A\u9884\u8BBE\u5DF2\u63A5\u7BA1\uFF09
+\u5173\u6389\u81EA\u52A8\u88C5\u914D\u89C1\u8BBE\u7F6E\u5361\u300Cweb \u9762\u81EA\u52A8\u542F\u7528 Context GC\u300D\uFF1B\u8FD8\u539F\u7528 npx dsh-engram revert`,
+      style: { fontSize: 11, fontWeight: 600, color, border: `1px solid ${color}55`, borderRadius: 999, padding: "2px 8px", whiteSpace: "nowrap" },
+      children: [
+        hostLabel,
+        webLabel
+      ]
+    }
+  );
+}
 function EngramBoard({ api, onRequestClose }) {
   const { vars } = useEngramTheme();
   const [overview, setOverview] = (0, import_react9.useState)(null);
@@ -4108,6 +4150,7 @@ function EngramBoard({ api, onRequestClose }) {
       /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { style: hb.title, children: "ESR \u4EFB\u52A1\u770B\u677F" }),
       /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { style: hb.sub, children: "draft \u2192 active(\u8BC1\u636E) \u2192 stable \xB7 \u8DE8\u5DE5\u4F5C\u533A \xB7 \u4E0E esr_task/esr_close \u540C\u4E00\u8BC1\u636E\u95E8" }),
       /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { style: hb.legendChip, children: "\u4EC5 ESR \xB7 \u4F1A\u8BDD\u5185 todo \u89C1\u8F93\u5165\u6846\u4E0A\u65B9\u4EFB\u52A1\u6761" }),
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(ContextGcChip, { compaction: overview?.compaction }),
       /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)("span", { style: hb.seg, children: [
         /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("button", { type: "button", style: viewMode === "board" ? hb.segActive : hb.segBtn, onClick: () => setViewMode("board"), title: "\u56DB\u5217\u4EFB\u52A1\u770B\u677F", children: "\u770B\u677F" }),
         /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("button", { type: "button", style: viewMode === "graph" ? hb.segActive : hb.segBtn, onClick: () => setViewMode("graph"), title: "\u5B9E\u4F53\u5173\u7CFB\u56FE\u8C31\uFF08esr_node / esr_link\uFF09", children: "\u56FE\u8C31" })

package/lib/compaction.js

@@ -31,7 +31,7 @@
  * entry never writes).
  */
 import { openEngramDomain } from "./store.js";
-import { loadCompactionEngine, collectPointerContext } from "./context-gc.js";
+import { mountCompactionEngine, collectPointerContext } from "./context-gc.js";
 import { workspaceKey as wk } from "./util.js";
 
 export const name = "dsh-engram-compaction";
@@ -56,9 +56,6 @@ export function apply(ctx, config = {}) {
   const deps =
     mode === "context-gc"
       ? {
-          narrativeEnabled: config.gcNarrative !== false,
-          narrativeMaxTokens: config.gcNarrativeMaxTokens ?? 1024,
-          narrativeMaxChars: config.gcNarrativeMaxChars ?? 4000,
           readWorkspace: async (workspace, report) => {
             if (!workspace) return null;
             const domain = await domainFor(ctx);
@@ -68,18 +65,5 @@ export function apply(ctx, config = {}) {
         }
       : {};
 
-  return loadCompactionEngine(ctx, { auto: true }, deps, { mode })
-    .then((Engine) => {
-      if (!Engine) {
-        ctx.logger?.warn?.("engram context-gc: dsh-compaction-basic unavailable — no compaction engine");
-        return;
-      }
-      new Engine();
-      ctx.logger?.info?.(
-        `engram context-gc: compaction = ${mode === "context-gc" ? "Context GC (mechanical eviction + re-fetch pointers)" : "default LLM summarizer (gcReplacesCompaction:false)"}`,
-      );
-    })
-    .catch((error) => {
-      ctx.logger?.warn?.(`engram context-gc mount failed: ${String(error)}`);
-    });
+  return mountCompactionEngine(ctx, config, deps);
 }