dsh-engram 0.2.0 → 0.3.2

package/lib/index-block.js

@@ -9,7 +9,7 @@
  * cache reuse.
  */
 
-import { label, shortId, fmtDate, escapeLt, truncate } from "./util.js";
+import { label, shortId, fmtDate, escapeLt, truncate, byRecency } from "./util.js";
 
 /** Deterministic index line prefix per memory kind. */
 export function prefixFor(kind) {
@@ -37,10 +37,17 @@ function isGitPlumbingEcho(m) {
   return /(^|\s)(cd\s|\&\&|;|\|)/.test(text);
 }
 
+/** A procedure that has been used (hit) enough times to count as proven. */
+export function isProvenProcedure(m, config) {
+  return (m?.kind ?? "") === "procedure" && (m?.hits ?? 0) >= (config?.promoteHits ?? 3);
+}
+
 /**
  * Select the memories that earn an index line: knowingly stored high-signal
  * entries, auto-captures past minIndexSignal, and low-signal entries promoted
- * by repeated recall (hits >= promoteHits). Sorted newest first.
+ * by repeated recall (hits >= promoteHits). Proven procedures (a Skill-ish
+ * asset: a workflow validated by repeated use) are ranked first, stably —
+ * each group still newest-first so the block stays deterministic per session.
  */
 export function selectIndexMemories(store, workspace, config) {
   const all = store.listMemories(workspace, 200);
@@ -53,14 +60,21 @@ export function selectIndexMemories(store, workspace, config) {
             (m.hits ?? 0) >= config.promoteHits ||
             m.kind === "task"),
     )
+    .sort((a, b) => {
+      const ap = isProvenProcedure(a, config) ? 0 : 1;
+      const bp = isProvenProcedure(b, config) ? 0 : 1;
+      if (ap !== bp) return ap - bp;
+      return byRecency(a, b);
+    })
     .slice(0, config.indexMaxLines);
 }
 
-function memoryLine(m) {
+function memoryLine(m, config) {
   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(), INDEX_LINE_CHARS);
-  return `[${px}] ${date} ${escapeLt(text)} #${shortId(m.id)}`;
+  return `[${mark}] ${date} ${escapeLt(text)} #${shortId(m.id)}`;
 }
 
 function taskStateLine(t) {
@@ -95,7 +109,7 @@ export function renderIndex(store, workspace, cwd, config) {
   lines.push(`[ENGRAM] workspace: ${label(cwd)} · ${entries.memories} memories · ${tasks.length} task(s) active · ${links} links · ${entries.nodes} node(s)`);
   const entityNames = store.listEntities(workspace).map((e) => e.name);
   if (entityNames.length > 0) lines.push(`nodes: ${truncate(entityNames.join(", "), 72)}`);
-  for (const m of memories.slice(0, config.indexMaxLines)) lines.push(memoryLine(m));
+  for (const m of memories.slice(0, config.indexMaxLines)) lines.push(memoryLine(m, config));
   for (const t of tasks.slice(0, 4)) lines.push(taskStateLine(t));
   lines.push("drill: engram_recall <query> | engram_detail <id> | esr_task (multi-step work → create now) | esr_node (recurring domain object → create now) | esr_link (relate nodes/tasks)");
   return enforceCharCap(lines, config.indexMaxChars);
@@ -116,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"];
@@ -136,44 +170,146 @@ 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;
+}
+
+/**
+ * "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.
+ */
+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. */
+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 (b.updatedAt ?? 0) - (a.updatedAt ?? 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 }));
 }
 
 /**
  * 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.
+ *
+ * @param opts {{
+ *   recorder?: import("./trigger.js").TriggerRecorder,  // decision-point recorder (P0-A–P3)
+ *   sessionId?: string,                                  // live session for the hints
+ * }}
  */
-export function renderEsr(store, workspace, config) {
+export function renderEsr(store, workspace, config, opts = {}) {
+  const recorder = opts?.recorder;
+  const sessionId = opts?.sessionId;
+  const live = recorder !== void 0 && sessionId !== void 0;
   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 ordered = sortActiveForNext(active);
+  // Prefer the live in-memory balance (recorder); fall back to the legacy
+  // usage-table view so store-driven callers/tests keep working unchanged.
+  const balance = recorder !== void 0 ? recorder.recentBalance(workspace) : usageBalanceView(store, workspace);
+  const hint = esrBalanceHint(balance);
+  const promote = live ? recorder.promoteHint(sessionId, workspace, active.length) : "";
+  const rootCause = live ? recorder.errorHint(sessionId, workspace, selectRootCauseCandidates(store, workspace, config)) : "";
+  const closure = live ? recorder.closureHint(sessionId, workspace, ordered.filter((t) => evidenceGaps(t).length === 0)) : "";
+  const stale = live ? recorder.staleHint(sessionId, workspace, selectStaleCandidates(active, config)) : "";
+  // P4: count only what is actually injected for a live session (never the
+  // GUI preview, which renders the same lines without a sessionId).
+  if (live) {
+    if (promote !== "") recorder.emitHint("promote", workspace, sessionId);
+    if (rootCause !== "") recorder.emitHint("rootcause", workspace, sessionId);
+    if (closure !== "") recorder.emitHint("close", workspace, sessionId);
+    if (stale !== "") recorder.emitHint("stale", workspace, sessionId);
+    if (hint !== "") recorder.emitHint("escalate", workspace, sessionId);
+  }
+
   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}`;
+    const rest = [promote, rootCause, hint].filter((l) => l !== "");
+    return rest.length === 0 ? base : `${base}\n${rest.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)}`);
+  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 (promote !== "") lines.push(promote);
+  if (rootCause !== "") lines.push(rootCause);
+  if (closure !== "") lines.push(closure);
+  if (stale !== "") lines.push(stale);
   if (hint !== "") lines.push(hint);
   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

@@ -21,6 +21,7 @@ import { openEngramDomain } from "./store.js";
 import { registerTools } from "./tools.js";
 import { makeCaptureHandler } from "./capture.js";
 import { renderIndex, renderEsr } from "./index-block.js";
+import { makeTriggerRecorder } from "./trigger.js";
 import { installEngramSettings } from "./settings.js";
 import { makeEngramRoutes } from "./api.js";
 
@@ -39,6 +40,9 @@ const DEFAULTS = {
   autoCaptureGlobalCap: 500,
   // recall
   sessionSearch: true,
+  // session-diversified recall: max memories per session before cross-session
+  // evidence takes over (agentmemory 候选①; "few and precise")
+  maxRecallPerSession: 3,
   // [ENGRAM] index budget (token discipline)
   indexMaxLines: 12,
   indexMaxChars: 700,
@@ -56,9 +60,23 @@ const DEFAULTS = {
   // GUI access: hostnames allowed past the loopback fence for /api/dsh-engram
   // (e.g. an operator-authorized cloudflare tunnel). Empty = loopback-only.
   trustedHosts: [],
+  // ESR evidence hardening: a non-URL artifact must exist on disk (relative
+  // artifacts resolve against the workspace = the session cwd DSH provides).
+  // esr_close's force:true bypasses this existence check.
+  verifyArtifact: true,
   // prompt section order (before the persona/tools bands per DSH convention)
   engramIndexOrder: 40,
   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) {
@@ -120,10 +138,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(() => {});
     },
@@ -142,6 +165,15 @@ export function apply(ctx, config) {
         return "";
       }
     },
+    /** Recompute the exact [ESR] block for a workspace (GUI inject preview). */
+    renderEsrBlock(workspace) {
+      if (opened === void 0) return "";
+      try {
+        return renderEsr(opened, workspace, resolved, { recorder });
+      } catch {
+        return "";
+      }
+    },
   };
 
   // Mechanical, archive-only memory GC (pi-esr constraints). Runs the first
@@ -250,7 +282,10 @@ export function apply(ctx, config) {
           if (cwd === void 0 || cwd.length === 0) return "";
           if (opened === void 0) return "";
           try {
-            return renderEsr(opened, resolvePath(cwd), resolved);
+            return renderEsr(opened, resolvePath(cwd), resolved, {
+              recorder,
+              sessionId: session.id,
+            });
           } catch {
             return "";
           }
@@ -259,6 +294,13 @@ export function apply(ctx, config) {
       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

package/lib/mental.js

@@ -0,0 +1,170 @@
+/**
+ * Mental models — precomputed standing answers over a workspace.
+ *
+ * Hindsight lets you define a question once and rewrites the answer in the
+ * background as the bank learns; reading one is a DB read, no LLM call, so an
+ * agent boots with a page of settled knowledge instead of rediscovering it
+ * every session. This is the zero-LLM analogue: `compileSummary` aggregates
+ * the workspace's tasks / entity graph / observations / memory kinds into a
+ * compact markdown blob, `getModel` serves the cached copy and recomputes only
+ * when a write happened (`dirty`), the input set changed (`sources_hash`) or
+ * the cache went stale (>10 min, a safety net for missed bumps).
+ *
+ * Pure + deterministic: `now` injectable, no model calls.
+ */
+
+import { hashText } from "./util.js";
+
+const DEFAULT_MAX_AGE_MS = 10 * 60 * 1000;
+
+/** Escape a name for markdown (pipes/newlines). */
+function mdCell(value) {
+  return String(value ?? "")
+    .replace(/\|/g, "\\|")
+    .replace(/\n/g, " ")
+    .trim();
+}
+
+/**
+ * Aggregate the workspace into a standing-answer markdown blob. Purely derives
+ * from already-indexed data — safe to run on every read.
+ */
+export function compileSummary(domain, ws, { now = Date.now() } = {}) {
+  const summary = domain.summarize();
+  const scope = ws && summary.workspaces[ws] ? { ...summary.workspaces[ws] } : { ...summary.totals };
+  const label = ws ? String(ws).replace(/^.*[\\/]/, "") : "全部工作区";
+
+  let tasks = [];
+  try {
+    tasks = domain.listTasks?.(ws, { includeStable: true }) ?? [];
+  } catch {
+    tasks = [];
+  }
+  const active = tasks.filter((t) => t.state === "active" || t.state === "draft");
+  let ready = 0;
+  const risky = [];
+  for (const t of active) {
+    let gaps = [];
+    try {
+      gaps = domain.evidenceGate?.(ws, t, { verifyArtifact: false })?.gaps ?? [];
+    } catch {
+      gaps = [];
+    }
+    if (gaps.length === 0) ready += 1;
+    else {
+      const ageDays = Math.max(0, Math.floor((now - (t.createdAt ?? now)) / 86400000));
+      risky.push(`- ${mdCell(t.name)} · ${gaps.join("/")} · ${ageDays}天`);
+    }
+  }
+  const stable = tasks.filter((t) => t.state === "stable").length;
+
+  const obs = domain.listObservations?.(ws) ?? [];
+  const obsEvidence = obs.reduce((s, o) => s + (o.proof?.count ?? 0), 0);
+  const topObs = obs
+    .slice()
+    .sort((a, b) => (b.proof?.count ?? 0) - (a.proof?.count ?? 0))
+    .slice(0, 3);
+
+  let kindHist = "";
+  try {
+    const mems = domain.listMemories?.(ws, 1000) ?? [];
+    const byKind = {};
+    for (const m of mems) byKind[m.kind] = (byKind[m.kind] ?? 0) + 1;
+    const top = Object.entries(byKind).sort((a, b) => b[1] - a[1]).slice(0, 3);
+    if (top.length > 0) kindHist = top.map(([k, n]) => `${k} ${n}`).join(" · ");
+  } catch {
+    kindHist = "";
+  }
+
+  const lines = [
+    `## ${label} · 常驻摘要`,
+    `- 任务：${active.length} 进行中（${ready} 就绪）· ${stable} 已闭环`,
+    `- 实体图：${scope.nodes ?? 0} 节点 · ${scope.links ?? 0} 链接`,
+    `- 观测：${obs.length} 条信念（累计 ${obsEvidence} 证据）`,
+    `- 记忆：${scope.memories ?? 0} 条${kindHist ? `（${kindHist}）` : ""}`,
+  ];
+  if (topObs.length > 0) {
+    lines.push("", "重点信念：");
+    for (const o of topObs) lines.push(`- ${mdCell(o.text)} — ×${o.proof?.count ?? 0}`);
+  }
+  if (risky.length > 0) {
+    lines.push("", "未闭环风险：");
+    lines.push(...risky.slice(0, 5));
+  }
+  return lines.join("\n");
+}
+
+/** Hash of the aggregation inputs — detects changes even when a bump was missed. */
+export function computeSourcesHash(domain, ws) {
+  const parts = [];
+  try {
+    const summary = domain.summarize();
+    parts.push(JSON.stringify(ws ? summary.workspaces[ws] : summary.totals));
+    const tasks = domain.listTasks?.(ws, { includeStable: true }) ?? [];
+    parts.push(tasks.map((t) => `${t.id}:${t.state}:${t.updatedAt ?? 0}`).join(","));
+    const obs = domain.listObservations?.(ws) ?? [];
+    parts.push(obs.map((o) => `${o.id}:${o.proof?.count ?? 0}:${o.negations ?? 0}:${o.updated_at ?? 0}`).join(","));
+  } catch {
+    parts.push("err");
+  }
+  return hashText(parts.join("|"));
+}
+
+/** Whether the cached model needs a recompute. */
+export function modelStale(model, domain, ws, { now = Date.now(), maxAgeMs = DEFAULT_MAX_AGE_MS } = {}) {
+  if (model === void 0 || model === null) return true;
+  if (model.dirty === true) return true;
+  if (typeof model.generated_at === "number" && now - model.generated_at > maxAgeMs) return true;
+  if (model.sources_hash !== computeSourcesHash(domain, ws)) return true;
+  return false;
+}
+
+/**
+ * Read the standing answer: cached copy unless stale, then recompute + persist.
+ * Pure aggregation — cheap enough to rebuild on a cold cache.
+ *
+ * @returns {Promise<{ws: string; content: string; generated_at: number; dirty: boolean; sources_hash: string; fresh: boolean}>}
+ */
+/**
+ * Prime-style brief mode: fold the standing answer's headline rows into a
+ * one-liner (~50-token reminder). Derived from the full content — same source
+ * of truth, so the brief can never drift from what the full model says.
+ */
+export function briefify(fullContent) {
+  const bits = [];
+  for (const prefix of ["- 任务：", "- 实体图：", "- 观测："]) {
+    for (const line of fullContent.split("\n")) {
+      if (line.startsWith(prefix)) { bits.push(line.slice(2)); break; }
+    }
+  }
+  let risks = 0;
+  const lines = fullContent.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim().startsWith("未闭环风险")) {
+      for (let j = i + 1; j < lines.length && lines[j].startsWith("- "); j++) risks++;
+    }
+  }
+  bits.push(risks > 0 ? `风险 ${risks}` : "无未闭环风险");
+  return bits.join(" · ").slice(0, 240);
+}
+
+export async function getModel(domain, ws, { now = Date.now(), maxAgeMs, compile = compileSummary, hash = computeSourcesHash, mode = "full" } = {}) {
+  const current = domain.getModel(ws);
+  if (!modelStale(current, domain, ws, { now, maxAgeMs })) {
+    const hit = { ...current, fresh: false };
+    if (mode === "brief") hit.content = briefify(hit.content);
+    return hit;
+  }
+  const ev = { now };
+  const content = compile(domain, ws, ev);
+  const fresh = {
+    ws,
+    content,
+    generated_at: now,
+    dirty: false,
+    sources_hash: hash(domain, ws),
+  };
+  await domain.putModel(ws, fresh);
+  if (mode === "brief") fresh.content = briefify(fresh.content);
+  return { ...fresh, fresh: true };
+}

package/lib/obs.js

@@ -0,0 +1,71 @@
+/**
+ * Observation VIEW — evidence-grounded beliefs, derived not persisted.
+ *
+ * Assessment P2 (2026-08-22): observations were a second persisted
+ * representation with write-path side effects (`integrateObservation` ran on
+ * every store). Demoted to a pure deterministic projection of memories: a
+ * memory with `hits >= OBSERVATION_MIN_PROOF` IS an observation — proof count
+ * is its hit count, its span is created→updated, trend is computed from
+ * recency. Nothing is written, nothing is stored; the GUI/API/tools keep the
+ * exact same shape (`o.proof.count`, `o.negations`, `o.trend`, `o.updated_at`).
+ *
+ * All functions are pure — zero LLM, zero storage.
+ */
+
+/** A memory only counts as a belief once it has been evidenced twice. */
+export const OBSERVATION_MIN_PROOF = 2;
+
+/**
+ * Trend from evidence recency (30/90-day windows, mirroring Hindsight):
+ *   - no evidence in the old window at all             -> stale
+ *   - newest evidence older than recentDays            -> weakening
+ *   - every source within recentDays                   -> new
+ *   - ≥2 sources, latest recent and history before     -> strengthening
+ *   - otherwise                                        -> stable
+ */
+export function computeTrend(span, now = Date.now(), { recentDays = 30, oldDays = 90 } = {}) {
+  const DAY = 86400000;
+  const first = span?.first_seen_at ?? null;
+  const last = span?.last_seen_at ?? first;
+  if (first === null || last === null) return "new";
+  const firstAge = Math.max(0, now - first) / DAY;
+  const lastAge = Math.max(0, now - last) / DAY;
+  if (firstAge > oldDays && lastAge > oldDays) return "stale";
+  if (lastAge > recentDays) return "weakening";
+  if (firstAge <= recentDays) return "new";
+  return "strengthening";
+}
+
+/**
+ * Derive the observations of a workspace from its active memories.
+ * Best-first by proof (hits), then newest first. Shape is stable and
+ * compatible with the old persisted records so every consumer
+ * (tools / mental / api / client) keeps working unchanged.
+ */
+export function deriveObservations(memories, { now = Date.now() } = {}) {
+  return memories
+    .filter((m) => (m.hits ?? 0) >= OBSERVATION_MIN_PROOF)
+    .map((m) => {
+      const createdAt = m.createdAt ?? now;
+      const updatedAt = m.updatedAt ?? createdAt;
+      const span = { first_seen_at: createdAt, last_seen_at: updatedAt };
+      return {
+        id: m.id,
+        workspace: m.workspace,
+        text: m.text,
+        kind: m.kind === "error" ? "pattern" : "belief",
+        proof: { count: m.hits ?? 0, sources: [m.id] },
+        span,
+        negations: 0,
+        trend: computeTrend(span, now),
+        tags: Array.isArray(m.tags) ? m.tags : [],
+        entity: m.entity ?? null,
+        updated_at: updatedAt,
+      };
+    })
+    .sort(
+      (a, b) =>
+        (b.proof?.count ?? 0) - (a.proof?.count ?? 0) ||
+        (b.updated_at ?? 0) - (a.updated_at ?? 0),
+    );
+}

package/lib/rerank.js

@@ -0,0 +1,50 @@
+/**
+ * Evidence-aware reranking signals for deterministic recall.
+ *
+ * Hindsight's reranking folds proof strength into the relevance score as a
+ * multiplicative boost (conservative, ±5% at weight 0.1). Here the analogue
+ * of "proof count" is a memory's cumulative recall hits — which our D2
+ * failure-revival path already increments on repeat failures, so high-hits
+ * memories are exactly the ones we want to stay findable. All functions are
+ * pure and dependency-free: `now` and weights are injectable for deterministic
+ * tests, matching the injectability of `util.bm25Rank`.
+ */
+
+/**
+ * Multiplicative evidence strength boost: 1 + alpha·min(max(0, hits), cap).
+ * Flat beyond `cap` so one runaway popular memory can't dominate ranking.
+ */
+export function evidenceBoost(hits, { alpha = 0.1, cap = 5 } = {}) {
+  const h = Math.max(0, Number.isFinite(hits) ? hits : 0);
+  return 1 + alpha * Math.min(h, cap);
+}
+
+/** Combine a base match score with the evidence boost. */
+export function scoreCandidate(matchScore, hits, { alpha = 0.1, cap = 5 } = {}) {
+  return (Number.isFinite(matchScore) ? matchScore : 0) * evidenceBoost(hits, { alpha, cap });
+}
+
+/**
+ * Stable sort of candidates by (score desc, tiebreak). Returns a new array;
+ * equal scores keep their input order.
+ *
+ * @param {Array} list
+ * @param {object} opts
+ * @param {(r:any)=>number} [opts.getScore] base score per candidate (default 0)
+ * @param {(r:any)=>number} [opts.getHits] evidence count per candidate
+ * @param {number} [opts.alpha] boost weight
+ * @param {number} [opts.cap] boost saturation point
+ * @param {(a:any,b:any)=>number} [opts.tiebreak] secondary comparator
+ */
+export function sortByEvidence(list, { getScore = () => 0, getHits = (r) => r.hits ?? 0, alpha = 0.1, cap = 5, tiebreak = null } = {}) {
+  const scored = list.map((r, i) => ({ r, i, s: scoreCandidate(getScore(r), getHits(r), { alpha, cap }) }));
+  scored.sort((a, b) => {
+    if (b.s !== a.s) return b.s - a.s;
+    if (tiebreak) {
+      const t = tiebreak(a.r, b.r);
+      if (t !== 0) return t;
+    }
+    return a.i - b.i; // stable
+  });
+  return scored.map((e) => e.r);
+}