dsh-trivium 0.3.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/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}`);

package/lib/pins.js

@@ -0,0 +1,155 @@
+/** Per-session memory chips. Pins inject into the next turn of the current session. */
+
+import { listEpisodeRecords } from "./episode.js";
+import { clipToTokenBudget, estimateTokens } from "./tokens.js";
+import { pinsOf, writePins } from "./settings.js";
+import { suggestedNeighborIds } from "./store.js";
+
+export const PIN_TOKEN_BUDGET = 300;
+export const CHIP_TYPES = Object.freeze(["preference", "decision", "entity"]);
+
+const CHIP_SET = new Set(CHIP_TYPES);
+
+function l0Of(payload) {
+  return String(payload?.text || payload?.name || "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, 200);
+}
+
+function chipMatches(row, q) {
+  const needle = String(q || "").trim().toLowerCase();
+  if (!needle) return true;
+  return [row.name, row.text, row.type, row.l0].some((s) => String(s || "").toLowerCase().includes(needle));
+}
+
+function episodeSuggestText(db, sessionId) {
+  const rows = listEpisodeRecords(db, sessionId);
+  const tail = rows.find((e) => e.kind === "tail");
+  const lastCheck = [...rows].reverse().find((e) => e.kind === "checkpoint");
+  const tailText = String(tail?.summary || tail?.text || "").trim();
+  if (tailText && tailText !== "当前" && tailText !== "分叉") return tailText;
+  return String(lastCheck?.summary || lastCheck?.text || tailText || "").trim();
+}
+
+function suggestedChipIdSet(db, sessionId) {
+  const sid = String(sessionId || "");
+  if (!sid) return new Set();
+  const text = episodeSuggestText(db, sid);
+  if (!text) return new Set();
+  const ids = new Set();
+  for (const nid of suggestedNeighborIds(db, text)) {
+    const payload = db.get(Number(nid))?.payload || {};
+    if (payload.status === "archived") continue;
+    if (!CHIP_SET.has(payload.type)) continue;
+    ids.add(Number(nid));
+  }
+  return ids;
+}
+
+function parentSessionOf(db, sessionId) {
+  const rows = listEpisodeRecords(db, sessionId);
+  const tail = rows.find((e) => e.kind === "tail");
+  for (const e of tail?.edges || []) {
+    if (e.label !== "forks_from") continue;
+    const payload = db.get(Number(e.targetId ?? e.target_id))?.payload;
+    if (payload?.sessionId) return String(payload.sessionId);
+  }
+  return "";
+}
+
+export function listChips(db, { q, sessionId } = {}) {
+  const suggested = suggestedChipIdSet(db, sessionId);
+  const rows = [];
+  for (const id of db.allNodeIds?.() || []) {
+    const payload = db.get(id)?.payload || {};
+    if (payload.status === "archived") continue;
+    if (!CHIP_SET.has(payload.type)) continue;
+    const row = {
+      id: Number(id),
+      type: payload.type,
+      name: payload.name || "",
+      text: payload.text || "",
+      l0: l0Of(payload),
+      updatedAt: payload.updatedAt || payload.createdAt || "",
+      suggested: suggested.has(Number(id)),
+    };
+    if (!chipMatches(row, q)) continue;
+    rows.push(row);
+  }
+  return rows.sort((a, b) => {
+    if (a.suggested !== b.suggested) return a.suggested ? -1 : 1;
+    return String(b.updatedAt).localeCompare(String(a.updatedAt));
+  });
+}
+
+export function livePinIds(db, sessionId) {
+  const ids = pinsOf(sessionId);
+  return ids.filter((id) => {
+    const payload = db.get(Number(id))?.payload;
+    return payload && payload.status !== "archived" && CHIP_SET.has(payload.type);
+  });
+}
+
+export function prunePins(db, sessionId) {
+  const ids = pinsOf(sessionId);
+  const kept = livePinIds(db, sessionId);
+  if (kept.length !== ids.length) writePins(sessionId, kept);
+  return kept;
+}
+
+export function buildPinInject(db, sessionId, budget = PIN_TOKEN_BUDGET) {
+  const ids = prunePins(db, sessionId);
+  if (!ids.length) return { text: "", tokens: 0, clipped: false, ids: [] };
+  const lines = ["dsh-trivium pins (L0 only; use ctx_read for full text):"];
+  const used = [];
+  for (const id of ids) {
+    const payload = db.get(Number(id))?.payload;
+    if (!payload) continue;
+    lines.push(`- [${payload.type}#${id}] ${l0Of(payload)}`);
+    used.push(Number(id));
+  }
+  const full = lines.join("\n");
+  const cap = Math.max(1, Number(budget) || PIN_TOKEN_BUDGET);
+  const text = clipToTokenBudget(full, cap);
+  return {
+    text,
+    tokens: estimateTokens(text),
+    clipped: estimateTokens(full) > cap,
+    ids: used,
+  };
+}
+
+export function setSessionPins(db, sessionId, ids) {
+  writePins(sessionId, ids);
+  return buildPinInject(db, sessionId);
+}
+
+export function readSessionPins(db, sessionId) {
+  return buildPinInject(db, sessionId);
+}
+
+/** Copy live (unarchived chip-type) pin ids. Child stays empty unless this is called. */
+export function copyPins(db, fromSessionId, toSessionId) {
+  const ids = livePinIds(db, fromSessionId);
+  writePins(toSessionId, ids);
+  return ids;
+}
+
+/**
+ * POST /pins body. inherit defaults false — `{ sessionId, ids }` still replaces.
+ * inherit true copies live ids from inheritFrom (or graph parent), then merges ids if given.
+ */
+export function applyPinsUpdate(db, body = {}) {
+  const sessionId = String(body.sessionId || "");
+  if (body.inherit === true) {
+    const from = String(body.inheritFrom || body.parentSessionId || parentSessionOf(db, sessionId) || "");
+    const copied = from && from !== sessionId ? copyPins(db, from, sessionId) : livePinIds(db, sessionId);
+    if (Array.isArray(body.ids)) {
+      const merged = [...new Set([...copied, ...body.ids.map(Number).filter((id) => Number.isFinite(id))])];
+      return setSessionPins(db, sessionId, merged);
+    }
+    return readSessionPins(db, sessionId);
+  }
+  return setSessionPins(db, sessionId, Array.isArray(body.ids) ? body.ids : []);
+}

package/lib/schema.js

@@ -8,6 +8,7 @@ export const NODE_TYPES = Object.freeze([
   "preference",
   "decision",
   "experience",
+  "episode",
 ]);
 
 export const EDGE_LABELS = Object.freeze({
@@ -18,6 +19,8 @@ export const EDGE_LABELS = Object.freeze({
   fixed: "fixed",
   sameAs: "same_as",
   fromSession: "from_session",
+  continues: "continues",
+  forksFrom: "forks_from",
 });
 
 export const BUSINESS_EDGES = Object.freeze(["about", "decided", "broke", "fixed"]);
@@ -31,6 +34,8 @@ export const EDGE_WEIGHTS = Object.freeze({
   in_workspace: 0.15,
   same_as: 0.5,
   from_session: 0.1,
+  continues: 0.4,
+  forks_from: 0.6,
 });
 
 export function weightOf(label) {