dsh-trivium 0.2.0 → 0.4.0

package/lib/episode.js

@@ -0,0 +1,278 @@
+/** Compaction checkpoints and fork lineage as episode nodes. Not recalled by find. */
+
+import { EDGE_LABELS, nowIso } from "./schema.js";
+import { ensureLink, findByType, findByUri, insertNode, updateNode } from "./store.js";
+
+const FALLBACK_SUMMARY = "已压缩";
+const TAIL_SUMMARY = "当前";
+const FORK_SUMMARY = "分叉";
+
+/** Auto titles. A hand-set name that is not one of these is the box title. */
+export const GENERIC_EPISODE_NAMES = Object.freeze([TAIL_SUMMARY, FALLBACK_SUMMARY, FORK_SUMMARY]);
+
+export function isGenericEpisodeName(name) {
+  const n = String(name || "").trim();
+  return !n || GENERIC_EPISODE_NAMES.includes(n);
+}
+
+function genericNameOf(kind) {
+  if (kind === "tail") return TAIL_SUMMARY;
+  if (kind === "fork") return FORK_SUMMARY;
+  return FALLBACK_SUMMARY;
+}
+
+export function episodeUri(sessionId, atSeq) {
+  return `ctx://episode/${sessionId}/${atSeq}`;
+}
+
+export function tailUri(sessionId) {
+  return `ctx://episode/${sessionId}/tail`;
+}
+
+function sessionOf(payload) {
+  return String(payload?.sessionId || "");
+}
+
+export function listEpisodeRecords(db, sessionId) {
+  const want = sessionId == null || sessionId === "" ? null : String(sessionId);
+  const rows = [];
+  const fromIndex = findByType(db, "episode");
+  const ids = fromIndex.length
+    ? fromIndex.map((n) => n.id)
+    : db.allNodeIds?.() || [];
+  const seen = new Set();
+  for (const raw of ids) {
+    const id = Number(raw?.id ?? raw);
+    if (!Number.isFinite(id) || seen.has(id)) continue;
+    seen.add(id);
+    const node = db.get(id);
+    const payload = node?.payload || {};
+    if (payload.type !== "episode" || payload.status === "archived") continue;
+    if (want && sessionOf(payload) !== want) continue;
+    rows.push(recordOf(id, payload, node?.edges || []));
+  }
+  return rows.sort((a, b) => (a.atSeq || 0) - (b.atSeq || 0) || a.id - b.id);
+}
+
+function recordOf(id, payload, edges) {
+  const summary = String(payload.summary || payload.text || "").trim();
+  return {
+    id: Number(id),
+    type: "episode",
+    sessionId: sessionOf(payload),
+    kind: payload.kind || "checkpoint",
+    atSeq: Number.isFinite(Number(payload.atSeq)) ? Number(payload.atSeq) : 0,
+    summary,
+    compactionId: payload.compactionId || "",
+    status: payload.status || "active",
+    createdAt: payload.createdAt || "",
+    updatedAt: payload.updatedAt || "",
+    uri: payload.uri || "",
+    name: payload.name || "",
+    text: payload.text || summary,
+    edges,
+  };
+}
+
+function upsertEpisode(db, payload) {
+  const uri = String(payload.uri || "").trim();
+  let id = uri ? findByUri(db, uri) : null;
+  if (id == null && payload.kind === "tail" && payload.sessionId) {
+    const existing = listEpisodeRecords(db, payload.sessionId).find((e) => e.kind === "tail");
+    if (existing) id = existing.id;
+  }
+  const body = {
+    type: "episode",
+    kind: payload.kind,
+    sessionId: String(payload.sessionId || ""),
+    atSeq: Number.isFinite(Number(payload.atSeq)) ? Number(payload.atSeq) : 0,
+    summary: String(payload.summary || payload.text || "").trim(),
+    compactionId: payload.compactionId || undefined,
+    uri,
+    name: payload.name || genericNameOf(payload.kind),
+    text: String(payload.summary || payload.text || "").trim(),
+    status: "active",
+    updatedAt: nowIso(),
+  };
+  if (id != null) {
+    const old = db.get(Number(id))?.payload || {};
+    const next = {
+      ...old,
+      ...body,
+      name: old.name || body.name,
+      kind: old.kind === "checkpoint" ? "checkpoint" : body.kind,
+      createdAt: old.createdAt || nowIso(),
+    };
+    if (payload.kind === "checkpoint") next.kind = "checkpoint";
+    db.updatePayload(Number(id), next);
+    db.flush();
+    return Number(id);
+  }
+  return insertNode(db, { ...body, createdAt: nowIso() });
+}
+
+function linkChain(db, sessionId) {
+  const rows = listEpisodeRecords(db, sessionId);
+  const checks = rows
+    .filter((e) => e.kind === "checkpoint" || e.kind === "fork")
+    .sort((a, b) => (a.atSeq || 0) - (b.atSeq || 0) || a.id - b.id);
+  const tail = rows.find((e) => e.kind === "tail");
+  for (let i = 0; i < checks.length - 1; i += 1) {
+    ensureLink(db, checks[i].id, checks[i + 1].id, EDGE_LABELS.continues);
+  }
+  if (tail && checks.length) {
+    ensureLink(db, checks[checks.length - 1].id, tail.id, EDGE_LABELS.continues);
+  }
+}
+
+/** At most one tail episode per session. Stable uri so compaction can reuse the node. */
+export function ensureTail(db, sessionId, { atSeq, summary } = {}) {
+  const sid = String(sessionId || "");
+  if (!sid) return null;
+  const existing = listEpisodeRecords(db, sid).find((e) => e.kind === "tail");
+  let text;
+  if (summary === undefined) {
+    text = existing && !isGenericEpisodeName(existing.summary) ? existing.summary : "";
+  } else {
+    text = String(summary || "").trim();
+  }
+  const id = upsertEpisode(db, {
+    kind: "tail",
+    sessionId: sid,
+    atSeq: Number.isFinite(Number(atSeq)) ? Number(atSeq) : existing?.atSeq || 0,
+    summary: text,
+    uri: tailUri(sid),
+    name: existing?.name || TAIL_SUMMARY,
+  });
+  linkChain(db, sid);
+  return id;
+}
+
+export function recordCheckpoint(db, { sessionId, atSeq, compactionId, summary } = {}) {
+  const sid = String(sessionId || "");
+  const seq = Number(atSeq);
+  if (!sid || !Number.isFinite(seq)) return null;
+  const text = String(summary || "").trim() || FALLBACK_SUMMARY;
+  const id = upsertEpisode(db, {
+    kind: "checkpoint",
+    sessionId: sid,
+    atSeq: seq,
+    compactionId: compactionId ? String(compactionId) : undefined,
+    summary: text,
+    uri: episodeUri(sid, seq),
+  });
+  ensureTail(db, sid, { atSeq: seq, summary: "" });
+  return id;
+}
+
+function isCheckpointPayload(payload) {
+  return payload?.type === "episode" && payload.kind === "checkpoint";
+}
+
+function parentCutId(db, parent, seq) {
+  if (seq != null) {
+    const existing = findByUri(db, episodeUri(parent, seq));
+    if (existing != null && isCheckpointPayload(db.get(existing)?.payload)) return existing;
+  }
+  const parentRows = listEpisodeRecords(db, parent);
+  if (seq != null) {
+    const hit = [...parentRows]
+      .reverse()
+      .find((e) => e.kind === "checkpoint" && (e.atSeq || 0) <= seq);
+    if (hit) return hit.id;
+  }
+  const lastCheck = [...parentRows].reverse().find((e) => e.kind === "checkpoint");
+  return lastCheck?.id ?? parentRows.find((e) => e.kind === "tail")?.id ?? null;
+}
+
+/**
+ * Project a native or canvas fork onto the graph.
+ * Branch from an existing checkpoint or the parent's tail — never insert a dummy cut box.
+ */
+export function syncForkLineage(db, { childSessionId, parentSessionId, atSeq } = {}) {
+  const child = String(childSessionId || "");
+  const parent = String(parentSessionId || "");
+  if (!child || !parent) return null;
+  const seq = Number.isFinite(Number(atSeq)) ? Number(atSeq) : null;
+  const cutId = parentCutId(db, parent, seq);
+  const childTail = ensureTail(db, child, { atSeq: seq ?? 0 });
+  if (cutId != null && childTail != null) {
+    ensureLink(db, childTail, cutId, EDGE_LABELS.forksFrom);
+  }
+  linkChain(db, parent);
+  return { cutId, childTail };
+}
+
+export function sessionMapSnapshot(db, sessionId) {
+  const sid = String(sessionId || "");
+  const all = listEpisodeRecords(db);
+  const mineIds = new Set(all.filter((n) => n.sessionId === sid).map((n) => n.id));
+  const edges = [];
+  for (const n of all) {
+    const node = db.get(n.id);
+    for (const e of node?.edges || []) {
+      const label = e.label || "";
+      if (label !== EDGE_LABELS.continues && label !== EDGE_LABELS.forksFrom) continue;
+      const to = Number(e.targetId ?? e.target_id);
+      if (!Number.isFinite(to)) continue;
+      edges.push({ from: n.id, to, label });
+    }
+  }
+  const related = new Set(mineIds);
+  let grew = true;
+  while (grew) {
+    grew = false;
+    for (const e of edges) {
+      if (related.has(e.from) && !related.has(e.to)) {
+        related.add(e.to);
+        grew = true;
+      }
+      if (related.has(e.to) && !related.has(e.from)) {
+        related.add(e.from);
+        grew = true;
+      }
+    }
+  }
+  const nodes = all
+    .filter((n) => related.has(n.id) || n.sessionId === sid)
+    .map((n) => ({
+      id: n.id,
+      sessionId: n.sessionId,
+      kind: n.kind,
+      atSeq: n.atSeq,
+      summary: n.summary,
+      compactionId: n.compactionId,
+      status: n.status,
+      createdAt: n.createdAt,
+      uri: n.uri,
+      name: n.name || "",
+      current: n.sessionId === sid && n.kind === "tail",
+    }));
+  return {
+    sessionId: sid,
+    nodes,
+    edges: edges.filter((e) => related.has(e.from) && related.has(e.to)),
+  };
+}
+
+/**
+ * Hand-rename a box. Writes only `name`. Rejects non-episode ids.
+ * Callers must not pass text/summary into updateNode.
+ */
+export function renameEpisode(db, id, name) {
+  const nid = Number(id);
+  if (!Number.isFinite(nid)) return { ok: false, status: 400, message: "bad id" };
+  const node = db.get(nid);
+  if (!node) return { ok: false, status: 404, message: "not found" };
+  const payload = node.payload || {};
+  if (payload.type !== "episode") {
+    return { ok: false, status: 400, message: "not an episode" };
+  }
+  const next = updateNode(db, nid, { name: String(name ?? "").trim() });
+  return {
+    ok: true,
+    id: nid,
+    name: next?.name || "",
+    summary: String(next?.summary || payload.summary || payload.text || ""),
+  };
+}

package/lib/extract.js

@@ -18,6 +18,11 @@ export const ONESHOT_CUES =
 export const CHITCHAT_CUES =
   /^(哈哈+|呵呵+|嗯+|哦+|好的|谢谢|天气|吃了吗|在吗)[\s!！.。?？]*$/;
 
+/** WorkBuddy-style per-batch write cap. Not a file-size limit. */
+export const MAX_WRITE_CHARS = 3000;
+export const MAX_LINE_CHARS = 240;
+export const MAX_WRITE_ITEMS = 24;
+
 const NAME_RE =
   /`([^`]{2,64})`|\b([A-Z][a-z]+[A-Z][A-Za-z0-9]*)\b|\b([A-Z][A-Za-z0-9]*(?:[_-][A-Z][A-Za-z0-9]*)+)\b|\b([a-z][a-z0-9]*(?:-[a-z][a-z0-9]*)+)\b|\b([A-Z]{3,}[A-Z0-9_-]{0,})\b/g;
 
@@ -170,6 +175,10 @@ function linkNameOf(span, turnText, uniqueTurn, { inSpanOnly = false } = {}) {
   );
 }
 
+export function firstEntityName(text) {
+  return collectNames(text, 1)[0]?.name;
+}
+
 function collectNames(text, min = 2) {
   const counts = new Map();
   const s = String(text || "");
@@ -298,10 +307,12 @@ export function ruleCandidates(turns) {
   return out;
 }
 
-export function filterCandidates(candidates) {
+export function filterCandidates(candidates, { importFile = false } = {}) {
   const seen = new Set();
   const out = [];
-  const caps = { entity: 8, preference: 8, decision: 6, experience: 4 };
+  const caps = importFile
+    ? { entity: 24, preference: 24, decision: 12, experience: 8 }
+    : { entity: 8, preference: 8, decision: 6, experience: 4 };
   const used = { entity: 0, preference: 0, decision: 0, experience: 0 };
   for (const raw of candidates || []) {
     if (!raw || !WRITE_TYPES.has(raw.type)) continue;
@@ -315,7 +326,7 @@ export function filterCandidates(candidates) {
       const blob = `${raw.text || ""} ${raw.quote || ""}`;
       if (CHITCHAT_CUES.test(String(raw.text || "").trim())) continue;
       if (ONESHOT_CUES.test(blob) && !PREFERENCE_CUES.test(blob)) continue;
-      if (!PREFERENCE_CUES.test(blob)) continue;
+      if (!importFile && !PREFERENCE_CUES.test(blob)) continue;
     }
     if ((used[raw.type] || 0) >= (caps[raw.type] || 4)) continue;
     const key = `${raw.type}|${(raw.name || "").toLowerCase()}|${text.toLowerCase()}`;
@@ -325,7 +336,7 @@ export function filterCandidates(candidates) {
     out.push({
       type: raw.type,
       name: raw.name ? String(raw.name).slice(0, 80) : undefined,
-      text: clip(text, 400),
+      text: clip(text, MAX_LINE_CHARS),
       linkName: raw.linkName ? String(raw.linkName).slice(0, 80) : undefined,
       linkLabel: raw.linkLabel || undefined,
       fail: raw.fail ? clip(raw.fail, 200) : undefined,
@@ -377,8 +388,29 @@ function resolveEntityId(db, name) {
   return findMergeTarget(db, { type: "entity", name, text: name });
 }
 
-export function applyCandidates(db, candidates, { sessionId } = {}) {
-  const list = filterCandidates(candidates);
+/** Drop the tail once the WorkBuddy-style char/item budget is spent. */
+export function capWriteBatch(candidates, { maxChars = MAX_WRITE_CHARS, maxItems = MAX_WRITE_ITEMS } = {}) {
+  const kept = [];
+  let used = 0;
+  for (const cand of candidates || []) {
+    if (kept.length >= maxItems) break;
+    const n = String(cand.text || cand.name || "").length;
+    if (used + n > maxChars && kept.length) break;
+    if (n > maxChars && !kept.length) {
+      kept.push({ ...cand, text: clip(cand.text || cand.name || "", MAX_LINE_CHARS) });
+      used += Math.min(n, MAX_LINE_CHARS);
+      break;
+    }
+    kept.push(cand);
+    used += n;
+  }
+  return { kept, used, dropped: Math.max(0, (candidates || []).length - kept.length) };
+}
+
+export function applyCandidates(db, candidates, { sessionId, via } = {}) {
+  const { kept: list } = capWriteBatch(
+    filterCandidates(candidates, { importFile: via === "workbuddy-import" }),
+  );
   const ordered = [
     ...list.filter((c) => c.type === "entity"),
     ...list.filter((c) => c.type !== "entity"),
@@ -398,7 +430,7 @@ export function applyCandidates(db, candidates, { sessionId } = {}) {
       source: {
         sessionId: sessionId ? String(sessionId) : "",
         quote: cand.quote,
-        via: "extract",
+        via: via || cand.via || "extract",
       },
     };
     const untilAt = cand.until ? resolveUntilAt(cand.until) : undefined;

package/lib/index.js

@@ -22,6 +22,8 @@ import {
 import { readUiSettings, registerMemoryApi } from "./server.js";
 import { applyRecallMode, recallModeOf } from "./settings.js";
 import { configureEmbedding } from "./embed.js";
+import { recordCheckpoint, ensureTail, syncForkLineage } from "./episode.js";
+import { buildPinInject } from "./pins.js";
 
 export const name = "dsh-trivium";
 export const inject = ["tools"];
@@ -206,6 +208,15 @@ function onSessionEvent(session, event) {
       if (buf.dirty && buf.cwd && buf.turns.length) {
         savePending(buf.cwd, { sessionId: buf.sessionId, turns: buf.turns });
       }
+      buf.lastTurnEndSeq = event.seq;
+      break;
+    }
+    case "compaction/summary": {
+      buf.compactionSummary = {
+        id: event.data?.compactionId,
+        text: textFromContent(event.data?.summary),
+        end: event.data?.shadowedRange?.end,
+      };
       break;
     }
     default:
@@ -245,6 +256,25 @@ export function apply(ctx, config = {}) {
           },
         }),
       );
+      try {
+        const session = agent.session;
+        const sessionId = sessionKey(session);
+        if (sessionId) {
+          const seedLen = session?.header?.seedLength;
+          ensureTail(db, sessionId, {
+            atSeq: Number.isFinite(Number(seedLen)) && seedLen > 0 ? seedLen - 1 : 0,
+          });
+          if (session?.header?.parentSession) {
+            syncForkLineage(db, {
+              childSessionId: sessionId,
+              parentSessionId: session.header.parentSession,
+              atSeq: Number.isFinite(Number(seedLen)) && seedLen > 0 ? seedLen - 1 : undefined,
+            });
+          }
+        }
+      } catch (err) {
+        log.warn?.(`[dsh-trivium] episode tail skipped: ${err.message}`);
+      }
       const pending = loadPending(cwd);
       if (pending?.turns?.length && optionsOf().extractEnabled !== false) {
         runExtract(runtime, {
@@ -278,9 +308,45 @@ export function apply(ctx, config = {}) {
           options: optionsOf(),
           reason: "compaction/end",
         }).catch((err) => log.warn?.(`[dsh-trivium] compaction extract: ${err.message}`));
+        const cwd = buf.cwd || session.header?.cwd;
+        const sessionId = buf.sessionId || session.id;
+        if (cwd && sessionId) {
+          const summary =
+            buf.compactionSummary?.id === event.data?.compactionId && buf.compactionSummary.text
+              ? buf.compactionSummary.text
+              : "已压缩";
+          const atSeq = Number.isFinite(Number(event.seq))
+            ? Number(event.seq)
+            : Number.isFinite(Number(buf.compactionSummary?.end))
+              ? Number(buf.compactionSummary.end)
+              : Number(buf.lastTurnEndSeq) || 0;
+          openWorkspaceDb(cwd)
+            .then((db) => {
+              recordCheckpoint(db, {
+                sessionId,
+                atSeq,
+                compactionId: event.data?.compactionId,
+                summary,
+              });
+            })
+            .catch((err) => log.warn?.(`[dsh-trivium] episode checkpoint skipped: ${err.message}`));
+        }
       }
       if (event.type === "turn/end") {
         const id = sessionKey(session);
+        const bufEnd = bufOf(session);
+        const lastUser = [...(bufEnd.turns || [])].reverse().find((t) => t.role === "user");
+        const preview = String(lastUser?.text || "").trim();
+        if (bufEnd.cwd && bufEnd.sessionId && preview && !preview.startsWith("/")) {
+          openWorkspaceDb(bufEnd.cwd)
+            .then((db) => {
+              ensureTail(db, bufEnd.sessionId, {
+                atSeq: Number(event.seq) || bufEnd.lastTurnEndSeq || 0,
+                summary: preview.slice(0, 240),
+              });
+            })
+            .catch((err) => log.warn?.(`[dsh-trivium] episode tail preview skipped: ${err.message}`));
+        }
         clearIdle(id);
         const timer = setTimeout(() => {
           idleTimers.delete(id);
@@ -310,50 +376,72 @@ export function apply(ctx, config = {}) {
   ctx.on("agent/pre-step", async ({ agent, messages }, next) => {
     const decision = await next();
     try {
-      const options = optionsOf();
-      const mode = recallModeOf(options);
-      if (mode === "off") return decision;
       if (!decision || decision.kind !== "enter") return decision;
-      const proposed = [...(decision.messages || []), ...(messages || [])];
-      const lastUser = [...proposed].reverse().find((m) => m?.source?.kind === "user");
-      if (!lastUser) return decision;
-      const query = textFromContent(lastUser.content).trim();
-      if (!query) return decision;
+      const extra = [];
       const db = await openWorkspaceDb(cwdOf(agent));
-      let hits;
-      if (mode === "anchor") {
-        hits = namedRecallHits(db, query, { topK: 8 }).slice(0, 8);
-      } else {
-        const queryVector = await embedQueryVector(query);
-        hits = searchNodes(db, query, {
-          topK: 3,
-          expandDepth: 1,
-          queryVector: queryVector || undefined,
-        }).slice(0, 3);
+      const sessionId = sessionKey(agent.session);
+      try {
+        const pin = buildPinInject(db, sessionId, 300);
+        if (pin.text) {
+          extra.push(
+            createUserMessage({
+              content: [{ type: "text", text: pin.text }],
+              source: {
+                kind: "plugin",
+                plugin: "dsh-trivium",
+                form: "pins",
+              },
+            }),
+          );
+        }
+      } catch (err) {
+        log.warn?.(`[dsh-trivium] pre-step pins skipped: ${err.message}`);
       }
-      if (!hits.length) return decision;
-      const lines = hits.map((hit) => {
-        const row = formatHit(db, hit);
-        return `- [${row.type}#${row.id}] ${row.l0} (${row.path.join(" | ") || "no path"})`;
-      });
-      const form = mode === "anchor" ? "anchorRecall" : "autoRecall";
-      const text = clipToTokenBudget(
-        `dsh-trivium ${form} (L0 only; use ctx_read for full text):\n${lines.join("\n")}`,
-        300,
-      );
+      const options = optionsOf();
+      const mode = recallModeOf(options);
+      if (mode !== "off") {
+        const proposed = [...(decision.messages || []), ...(messages || [])];
+        const lastUser = [...proposed].reverse().find((m) => m?.source?.kind === "user");
+        const query = lastUser ? textFromContent(lastUser.content).trim() : "";
+        if (query) {
+          let hits;
+          if (mode === "anchor") {
+            hits = namedRecallHits(db, query, { topK: 8 }).slice(0, 8);
+          } else {
+            const queryVector = await embedQueryVector(query);
+            hits = searchNodes(db, query, {
+              topK: 3,
+              expandDepth: 1,
+              queryVector: queryVector || undefined,
+            }).slice(0, 3);
+          }
+          if (hits.length) {
+            const lines = hits.map((hit) => {
+              const row = formatHit(db, hit);
+              return `- [${row.type}#${row.id}] ${row.l0} (${row.path.join(" | ") || "no path"})`;
+            });
+            const form = mode === "anchor" ? "anchorRecall" : "autoRecall";
+            const text = clipToTokenBudget(
+              `dsh-trivium ${form} (L0 only; use ctx_read for full text):\n${lines.join("\n")}`,
+              300,
+            );
+            extra.push(
+              createUserMessage({
+                content: [{ type: "text", text }],
+                source: {
+                  kind: "plugin",
+                  plugin: "dsh-trivium",
+                  form: "recall",
+                },
+              }),
+            );
+          }
+        }
+      }
+      if (!extra.length) return decision;
       return {
         kind: "enter",
-        messages: [
-          createUserMessage({
-            content: [{ type: "text", text }],
-            source: {
-              kind: "plugin",
-              plugin: "dsh-trivium",
-              form: "recall",
-            },
-          }),
-          ...decision.messages,
-        ],
+        messages: [...extra, ...decision.messages],
       };
     } catch (err) {
       log.warn?.(`[dsh-trivium] pre-step recall skipped: ${err.message}`);