stratagate-dsh 0.2.21 → 0.2.26

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/index.ts
 import { mkdir } from "node:fs/promises";
 import { dirname } from "node:path";
-import { createUserMessage as createUserMessage2 } from "@deepseek-ai/dsh-llm";
+import { createUserMessage as createUserMessage3 } from "@deepseek-ai/dsh-llm";
 
 // src/config.ts
 import z from "@deepseek-ai/schemastery";
@@ -122,12 +122,12 @@ function isFillerSentence(value) {
 }
 function resultSummary(value) {
   if (typeof value === "string") {
-    const text2 = value.replace(/\s+/g, " ").trim();
-    if (!text2) return "";
+    const text3 = value.replace(/\s+/g, " ").trim();
+    if (!text3) return "";
     try {
-      return resultSummary(JSON.parse(text2));
+      return resultSummary(JSON.parse(text3));
     } catch {
-      return text2.slice(0, 160);
+      return text3.slice(0, 160);
     }
   }
   if (typeof value === "number" || typeof value === "boolean") return String(value);
@@ -199,9 +199,9 @@ function condenseMessage(content) {
   const source = content.trim();
   const toolSummary = summarizeToolJson(source);
   if (toolSummary) return [{ text: toolSummary, pasteCandidate: false }];
-  return splitTextAndCode(source).flatMap(({ text: text2, isCode }) => {
-    if (isCode) return text2.trim() ? [{ text: text2.trim(), pasteCandidate: true }] : [];
-    return text2.split(/\n\s*\n+/u).map(removeStandaloneFillers).filter(Boolean).map((paragraph) => ({
+  return splitTextAndCode(source).flatMap(({ text: text3, isCode }) => {
+    if (isCode) return text3.trim() ? [{ text: text3.trim(), pasteCandidate: true }] : [];
+    return text3.split(/\n\s*\n+/u).map(removeStandaloneFillers).filter(Boolean).map((paragraph) => ({
       text: paragraph,
       pasteCandidate: looksLikeCode(paragraph) || normalizedParagraph(paragraph).length >= REPEATED_PASTE_MIN_CHARS
     }));
@@ -209,8 +209,8 @@ function condenseMessage(content) {
 }
 function formatReadableTranscript(messages) {
   return messages.filter((message) => message.role !== "system").flatMap((message) => {
-    const text2 = message.content.trim();
-    const inline = message.role === "tool" ? summarizeToolJson(text2) ?? text2 : text2;
+    const text3 = message.content.trim();
+    const inline = message.role === "tool" ? summarizeToolJson(text3) ?? text3 : text3;
     const lines = inline ? [`${roleLabel(message.role)}: ${inline}`] : [];
     lines.push(...(message.toolCalls ?? []).map(summarizeToolTrace));
     return lines;
@@ -252,36 +252,6 @@ function deterministicBlockLayers(messages) {
   };
 }
 
-// ../../src/retrieval.ts
-var RETRIEVAL_STRATEGIES = [
-  "answer",
-  "search_events",
-  "expand_event",
-  "search_elements",
-  "expand_element",
-  "search_raw_memory",
-  "expand_block"
-];
-function shortText(value) {
-  return typeof value === "string" ? value.trim().replace(/\s+/g, " ").slice(0, 160) : "";
-}
-function normalizeStrategy(value) {
-  return typeof value === "string" && RETRIEVAL_STRATEGIES.includes(value) ? value : "search_events";
-}
-function normalizeRetrievalAssessment(input, latestEvidenceRefs) {
-  const requestedVerdict = input.verdict === "sufficient" || input.verdict === "wrong" ? input.verdict : "partial";
-  const evidenceRefs = Array.isArray(input.evidence_refs) ? [...new Set(input.evidence_refs.filter((id) => typeof id === "string" && latestEvidenceRefs.has(id)))].slice(0, 8) : [];
-  const requestedStrategy = normalizeStrategy(input.next_strategy);
-  const sufficient = requestedVerdict === "sufficient" && evidenceRefs.length > 0 && requestedStrategy === "answer";
-  return {
-    verdict: sufficient ? "sufficient" : requestedVerdict === "wrong" ? "wrong" : "partial",
-    evidenceRefs,
-    fit: shortText(input.fit),
-    missing: sufficient ? "" : shortText(input.missing) || "Direct evidence required to answer the question is still missing.",
-    nextStrategy: sufficient ? "answer" : requestedStrategy === "answer" ? "search_events" : requestedStrategy
-  };
-}
-
 // ../../src/search.ts
 var wordSegmenter = new Intl.Segmenter(void 0, { granularity: "word" });
 function normalizeSearchText(value) {
@@ -359,8 +329,215 @@ function rrfRank(rankings) {
   return [...fused.values()].sort((left, right) => right.score - left.score || left.bestRank - right.bestRank || left.item.id.localeCompare(right.item.id)).map(({ item, score }) => ({ item, score }));
 }
 
+// ../../src/graph.ts
+var NODE_TYPES = /* @__PURE__ */ new Set(["person", "project", "organization", "tool", "place"]);
+var STATUSES = /* @__PURE__ */ new Set(["active", "superseded", "disputed", "archived"]);
+function text(value, limit = 240) {
+  return typeof value === "string" ? value.trim().replace(/\s+/g, " ").slice(0, limit) : "";
+}
+function strings(value, limit = 32) {
+  return Array.isArray(value) ? [...new Set(value.map((item) => text(item)).filter(Boolean))].slice(0, limit) : [];
+}
+function confidence(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.min(1, value)) : 0.8;
+}
+function chronology(events, ids, fallback) {
+  return ids.flatMap((id) => events.find((event) => event.id === id) ?? []).map((event) => event.temporal.happenedStart ?? event.temporal.happenedEnd ?? event.temporal.mentionedAt ?? event.createdAt).sort().at(-1) ?? fallback;
+}
+function sameEntity(node, proposal) {
+  if (node.type !== proposal.type) return false;
+  const key = (value) => normalizeSearchText(value).replace(/[\s_-]+/g, "");
+  const names = new Set([proposal.name, ...proposal.aliases ?? []].map(key));
+  return [node.name, ...node.aliases].some((name2) => names.has(key(name2)));
+}
+function applyGraphProjection(options) {
+  const refs = /* @__PURE__ */ new Map();
+  const touchedNodes = /* @__PURE__ */ new Set();
+  const touchedEdges = /* @__PURE__ */ new Set();
+  const validSources = (value) => {
+    const requested = strings(value, 64);
+    return requested.length > 0 && requested.every((id) => options.allowedEventIds.has(id)) ? requested : [];
+  };
+  for (const proposal of Array.isArray(options.result.nodes) ? options.result.nodes : []) {
+    const ref = text(proposal.ref, 120);
+    const name2 = text(proposal.name, 160);
+    const sources2 = validSources(proposal.sourceEventIds);
+    if (!ref || !name2 || !NODE_TYPES.has(proposal.type) || sources2.length === 0) continue;
+    const aliases = strings(proposal.aliases, 20).filter((alias) => normalizeSearchText(alias) !== normalizeSearchText(name2));
+    let node = options.nodes.find((candidate) => sameEntity(candidate, { ...proposal, name: name2, aliases }));
+    if (!node) {
+      node = {
+        id: options.idFactory("node"),
+        name: name2,
+        type: proposal.type,
+        aliases: [],
+        currentState: "",
+        facts: [],
+        status: "active",
+        confidence: confidence(proposal.confidence),
+        sourceEventIds: [],
+        createdAt: options.now,
+        updatedAt: options.now
+      };
+      options.nodes.push(node);
+    }
+    node.aliases = [.../* @__PURE__ */ new Set([...node.aliases, ...aliases])];
+    node.status = STATUSES.has(proposal.status ?? "active") ? proposal.status ?? "active" : "active";
+    node.confidence = confidence(proposal.confidence);
+    node.sourceEventIds = [.../* @__PURE__ */ new Set([...node.sourceEventIds, ...sources2])];
+    const validFrom = text(proposal.validFrom, 80) || chronology(options.events, sources2, options.now);
+    const validTo = text(proposal.validTo, 80) || void 0;
+    const facts = [
+      ...text(proposal.state, 1200) ? [{ key: "state", value: text(proposal.state, 1200) }] : [],
+      ...Array.isArray(proposal.facts) ? proposal.facts : []
+    ];
+    for (const rawFact of facts) {
+      const key = text(rawFact.key, 160);
+      const value = Array.isArray(rawFact.value) ? strings(rawFact.value, 40) : text(rawFact.value, 1200);
+      if (!key || (Array.isArray(value) ? value.length === 0 : !value)) continue;
+      const factSources = "sourceEventIds" in rawFact ? validSources(rawFact.sourceEventIds) : sources2;
+      if (factSources.length === 0) continue;
+      for (const old of node.facts.filter((fact2) => fact2.status === "active" && fact2.key === key)) {
+        old.status = "superseded";
+        if (!old.validTo) old.validTo = validFrom;
+        old.updatedAt = options.now;
+      }
+      const fact = {
+        id: options.idFactory("gfact"),
+        key,
+        value,
+        status: node.status,
+        validFrom,
+        ...validTo ? { validTo } : {},
+        confidence: node.confidence,
+        sourceEventIds: factSources,
+        createdAt: options.now,
+        updatedAt: options.now
+      };
+      node.facts.push(fact);
+    }
+    node.currentState = node.facts.filter((fact) => fact.status === "active").map((fact) => `${fact.key}: ${Array.isArray(fact.value) ? fact.value.join("\u3001") : fact.value}`).join("\n");
+    node.updatedAt = options.now;
+    refs.set(ref, node);
+    touchedNodes.add(node.id);
+  }
+  for (const proposal of Array.isArray(options.result.edges) ? options.result.edges : []) {
+    const from = refs.get(text(proposal.fromRef, 120));
+    const to = refs.get(text(proposal.toRef, 120));
+    const relation = text(proposal.relation, 100);
+    const sources2 = validSources(proposal.sourceEventIds);
+    if (!from || !to || from.id === to.id || !relation || sources2.length === 0) continue;
+    const status = STATUSES.has(proposal.status ?? "active") ? proposal.status ?? "active" : "active";
+    const validFrom = text(proposal.validFrom, 80) || chronology(options.events, sources2, options.now);
+    const validTo = text(proposal.validTo, 80) || void 0;
+    for (const old of options.edges.filter((edge2) => edge2.status === "active" && edge2.fromNodeId === from.id && edge2.relation === relation && edge2.toNodeId !== to.id)) {
+      old.status = "superseded";
+      if (!old.validTo) old.validTo = validFrom;
+      old.updatedAt = options.now;
+    }
+    let edge = options.edges.find((candidate) => candidate.fromNodeId === from.id && candidate.toNodeId === to.id && candidate.relation === relation && candidate.status === status);
+    if (!edge) {
+      edge = {
+        id: options.idFactory("edge"),
+        fromNodeId: from.id,
+        toNodeId: to.id,
+        relation,
+        status,
+        validFrom,
+        ...validTo ? { validTo } : {},
+        confidence: confidence(proposal.confidence),
+        sourceEventIds: sources2,
+        createdAt: options.now,
+        updatedAt: options.now
+      };
+      options.edges.push(edge);
+    } else {
+      edge.sourceEventIds = [.../* @__PURE__ */ new Set([...edge.sourceEventIds, ...sources2])];
+      edge.confidence = confidence(proposal.confidence);
+      edge.updatedAt = options.now;
+    }
+    touchedEdges.add(edge.id);
+  }
+  for (const event of options.events.filter((candidate) => options.allowedEventIds.has(candidate.id))) {
+    const participantNodeIds = options.nodes.filter((node) => node.sourceEventIds.includes(event.id)).map(({ id }) => id);
+    event.temporal.participantNodeIds = [.../* @__PURE__ */ new Set([...event.temporal.participantNodeIds ?? [], ...participantNodeIds])];
+  }
+  return { nodeIds: [...touchedNodes], edgeIds: [...touchedEdges] };
+}
+
+// ../../src/events.ts
+function normalizeStandardEventType(value) {
+  const normalized = normalizeSearchText(value ?? "").replace(/[\s_-]+/g, "");
+  const aliases = {
+    "\u53D1\u5E03": "release",
+    "\u7248\u672C\u53D1\u5E03": "release",
+    release: "release",
+    released: "release",
+    "\u51B3\u5B9A": "decision",
+    "\u51B3\u7B56": "decision",
+    decision: "decision",
+    "\u5B8C\u6210": "task_completed",
+    "\u4EFB\u52A1\u5B8C\u6210": "task_completed",
+    taskcompleted: "task_completed",
+    completed: "task_completed",
+    "\u8BA1\u5212": "plan",
+    plan: "plan",
+    planned: "plan",
+    "\u53D8\u66F4": "change",
+    "\u4FEE\u6539": "change",
+    change: "change",
+    "\u53D6\u6D88": "cancellation",
+    cancellation: "cancellation",
+    cancelled: "cancellation",
+    canceled: "cancellation",
+    "\u6545\u969C": "incident",
+    incident: "incident",
+    "\u4F1A\u8BAE": "meeting",
+    meeting: "meeting",
+    "\u534F\u4F5C": "collaboration",
+    collaboration: "collaboration",
+    "\u8FC1\u79FB": "migration",
+    migration: "migration",
+    other: "other"
+  };
+  return aliases[normalized] ?? "other";
+}
+
+// ../../src/retrieval.ts
+var RETRIEVAL_STRATEGIES = [
+  "answer",
+  "search_events",
+  "expand_event",
+  "search_graph",
+  "expand_graph_node",
+  "search_elements",
+  "expand_element",
+  "search_raw_memory",
+  "expand_block"
+];
+function shortText(value) {
+  return typeof value === "string" ? value.trim().replace(/\s+/g, " ").slice(0, 160) : "";
+}
+function normalizeStrategy(value) {
+  return typeof value === "string" && RETRIEVAL_STRATEGIES.includes(value) ? value : "search_events";
+}
+function normalizeRetrievalAssessment(input, latestEvidenceRefs) {
+  const requestedVerdict = input.verdict === "sufficient" || input.verdict === "wrong" ? input.verdict : "partial";
+  const evidenceRefs = Array.isArray(input.evidence_refs) ? [...new Set(input.evidence_refs.filter((id) => typeof id === "string" && latestEvidenceRefs.has(id)))].slice(0, 8) : [];
+  const requestedStrategy = normalizeStrategy(input.next_strategy);
+  const sufficient = requestedVerdict === "sufficient" && evidenceRefs.length > 0 && requestedStrategy === "answer";
+  return {
+    verdict: sufficient ? "sufficient" : requestedVerdict === "wrong" ? "wrong" : "partial",
+    evidenceRefs,
+    fit: shortText(input.fit),
+    missing: sufficient ? "" : shortText(input.missing) || "Direct evidence required to answer the question is still missing.",
+    nextStrategy: sufficient ? "answer" : requestedStrategy === "answer" ? "search_events" : requestedStrategy
+  };
+}
+
 // ../../src/storage.ts
-var STRATAGATE_STORAGE_SCHEMA_VERSION = 7;
+var STRATAGATE_STORAGE_SCHEMA_VERSION = 8;
+var KNOWLEDGE_GRAPH_PROJECTOR_VERSION = 1;
 var StorageConflictError = class extends Error {
   constructor(namespace, expectedRevision, actualRevision) {
     super(`Storage revision conflict for ${namespace}: expected ${expectedRevision}, found ${actualRevision ?? "missing"}`);
@@ -376,6 +553,9 @@ var StorageConflictError = class extends Error {
 function cloneSnapshot(snapshot) {
   return structuredClone(snapshot);
 }
+function emptyGraph() {
+  return { graphNodes: [], graphEdges: [], graphProjectionJobs: [] };
+}
 function migrateLegacyBlocks(blocks) {
   return blocks.map((block) => {
     const { pointerAnchorTurn, ...current } = block;
@@ -397,7 +577,8 @@ function normalizeSnapshot(value) {
       elements: [],
       elementProjectionJobs: [],
       usageReceipts: Array.isArray(legacy.usageReceipts) ? legacy.usageReceipts.map((receipt) => ({ ...receipt, elementIds: [] })) : [],
-      ingestionReceipts: []
+      ingestionReceipts: [],
+      ...emptyGraph()
     };
   } else if (schemaVersion === 2) {
     const legacy = value;
@@ -406,7 +587,8 @@ function normalizeSnapshot(value) {
       schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
       blockDecayLambda: BLOCK_DECAY_LAMBDA,
       blocks: migrateLegacyBlocks(legacy.blocks),
-      ingestionReceipts: []
+      ingestionReceipts: [],
+      ...emptyGraph()
     };
   } else if (schemaVersion === 3) {
     const legacy = value;
@@ -414,7 +596,8 @@ function normalizeSnapshot(value) {
       ...structuredClone(legacy),
       schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
       blockDecayLambda: BLOCK_DECAY_LAMBDA,
-      blocks: migrateLegacyBlocks(legacy.blocks)
+      blocks: migrateLegacyBlocks(legacy.blocks),
+      ...emptyGraph()
     };
   } else if (schemaVersion === 4) {
     const legacy = value;
@@ -422,7 +605,8 @@ function normalizeSnapshot(value) {
       ...structuredClone(legacy),
       schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
       blockDecayLambda: BLOCK_DECAY_LAMBDA,
-      blocks: migrateLegacyBlocks(legacy.blocks)
+      blocks: migrateLegacyBlocks(legacy.blocks),
+      ...emptyGraph()
     };
   } else if (schemaVersion === 5) {
     const legacy = value;
@@ -430,15 +614,20 @@ function normalizeSnapshot(value) {
       ...structuredClone(legacy),
       schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
       blockDecayLambda: BLOCK_DECAY_LAMBDA,
-      blocks: migrateLegacyBlocks(legacy.blocks)
+      blocks: migrateLegacyBlocks(legacy.blocks),
+      ...emptyGraph()
     };
   } else if (schemaVersion === 6) {
     const legacy = value;
     snapshot = {
       ...structuredClone(legacy),
       schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
-      blocks: legacy.blocks.map((block) => ({ ...structuredClone(block), lastLiftedBy: null }))
+      blocks: legacy.blocks.map((block) => ({ ...structuredClone(block), lastLiftedBy: null })),
+      ...emptyGraph()
     };
+  } else if (schemaVersion === 7) {
+    const legacy = value;
+    snapshot = { ...structuredClone(legacy), schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION, ...emptyGraph() };
   } else if (schemaVersion === STRATAGATE_STORAGE_SCHEMA_VERSION) {
     snapshot = structuredClone(value);
   } else {
@@ -453,10 +642,13 @@ function normalizeSnapshot(value) {
   if (!Number.isFinite(snapshot.blockDecayLambda) || snapshot.blockDecayLambda < 0) {
     throw new TypeError("Invalid StrataGate snapshot: blockDecayLambda must be a non-negative finite number");
   }
-  for (const key of ["openTail", "blocks", "events", "elements", "extractionJobs", "elementProjectionJobs", "usageReceipts", "ingestionReceipts"]) {
+  for (const key of ["openTail", "blocks", "events", "graphNodes", "graphEdges", "graphProjectionJobs", "elements", "extractionJobs", "elementProjectionJobs", "usageReceipts", "ingestionReceipts"]) {
     if (!Array.isArray(snapshot[key])) throw new TypeError(`Invalid StrataGate snapshot: ${key} must be an array`);
   }
   if (!Array.isArray(snapshot.successfulModelResponses)) snapshot.successfulModelResponses = [];
+  for (const event of snapshot.events) {
+    event.temporal = { ...event.temporal, eventType: normalizeStandardEventType(event.temporal.eventType) };
+  }
   for (const block of snapshot.blocks) {
     if (!Number.isSafeInteger(block.pointerAnchorBlockPosition) || block.pointerAnchorBlockPosition < 1) {
       throw new TypeError("Invalid StrataGate snapshot: pointerAnchorBlockPosition must be a positive integer");
@@ -817,6 +1009,15 @@ CREATE TABLE IF NOT EXISTS element_projection_jobs (
   FOREIGN KEY (namespace) REFERENCES memory_spaces(namespace) ON DELETE CASCADE
 ) STRICT;
 
+CREATE TABLE IF NOT EXISTS graph_state (
+  namespace TEXT PRIMARY KEY,
+  nodes_json TEXT NOT NULL DEFAULT '[]',
+  edges_json TEXT NOT NULL DEFAULT '[]',
+  jobs_json TEXT NOT NULL DEFAULT '[]',
+  updated_at TEXT NOT NULL,
+  FOREIGN KEY (namespace) REFERENCES memory_spaces(namespace) ON DELETE CASCADE
+) STRICT;
+
 CREATE TABLE IF NOT EXISTS usage_receipts (
   namespace TEXT NOT NULL,
   receipt_id TEXT NOT NULL,
@@ -954,7 +1155,10 @@ var SqliteStorage = class {
       quotes: parseJson(row.quotes_json, "events.quotes_json"),
       sourceMessageIds: sourcesByEvent.get(row.id) ?? [],
       sourceBlockId: row.source_block_id,
-      temporal: parseJson(row.temporal_json, "events.temporal_json"),
+      temporal: (() => {
+        const temporal = parseJson(row.temporal_json, "events.temporal_json");
+        return { ...temporal, eventType: normalizeStandardEventType(temporal.eventType) };
+      })(),
       scope: row.scope,
       criticality: row.criticality,
       confidence: row.confidence,
@@ -1092,6 +1296,12 @@ var SqliteStorage = class {
       id: row.receipt_id,
       createdAt: row.created_at
     }));
+    const graphState = this.database.prepare(`
+      SELECT nodes_json, edges_json, jobs_json FROM graph_state WHERE namespace = ?
+    `).get(key);
+    const graphNodes = graphState ? parseJson(graphState.nodes_json, "graph_state.nodes_json") : [];
+    const graphEdges = graphState ? parseJson(graphState.edges_json, "graph_state.edges_json") : [];
+    const graphProjectionJobs = graphState ? parseJson(graphState.jobs_json, "graph_state.jobs_json") : [];
     const snapshot = {
       schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
       currentTurn: space.current_turn,
@@ -1100,6 +1310,9 @@ var SqliteStorage = class {
       openTail,
       blocks,
       events,
+      graphNodes,
+      graphEdges,
+      graphProjectionJobs,
       elements,
       extractionJobs,
       elementProjectionJobs,
@@ -1432,6 +1645,21 @@ var SqliteStorage = class {
         job.updatedAt
       );
     }
+    this.database.prepare(`
+      INSERT INTO graph_state (namespace, nodes_json, edges_json, jobs_json, updated_at)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT (namespace) DO UPDATE SET
+        nodes_json = excluded.nodes_json,
+        edges_json = excluded.edges_json,
+        jobs_json = excluded.jobs_json,
+        updated_at = excluded.updated_at
+    `).run(
+      namespace,
+      JSON.stringify(snapshot.graphNodes),
+      JSON.stringify(snapshot.graphEdges),
+      JSON.stringify(snapshot.graphProjectionJobs),
+      updatedAt
+    );
     const insertReceipt = this.database.prepare(`
       INSERT INTO usage_receipts (namespace, receipt_id, event_ids_json, element_ids_json, audit_json, created_at)
       VALUES (?, ?, ?, ?, ?, ?)
@@ -1476,7 +1704,7 @@ var SqliteStorage = class {
         this.database.exec(THREAD_INDEXES);
         this.database.exec(`PRAGMA user_version = ${STRATAGATE_STORAGE_SCHEMA_VERSION}`);
       });
-    } else if (version === 1 || version === 2 || version === 3 || version === 4 || version === 5 || version === 6) {
+    } else if (version === 1 || version === 2 || version === 3 || version === 4 || version === 5 || version === 6 || version === 7) {
       this.immediateTransaction(() => {
         this.database.exec(SCHEMA);
         if (version === 1) {
@@ -1566,6 +1794,9 @@ function defaultIdFactory(prefix) {
 function defaultElementIdFactory(prefix) {
   return `${prefix}_${crypto.randomUUID()}`;
 }
+function defaultGraphIdFactory(prefix) {
+  return `${prefix}_${crypto.randomUUID()}`;
+}
 function defaultSummary(messages) {
   const natural = messages.filter((message) => message.role === "user" || message.role === "assistant");
   const firstUser = natural.find((message) => message.role === "user");
@@ -1603,15 +1834,21 @@ var StrataGate = class _StrataGate {
   summarizer;
   extractor;
   elementProjector;
+  disableElementProjection;
+  graphProjector;
   now;
   idFactory;
   elementIdFactory;
+  graphIdFactory;
   openTail = [];
   blocks = [];
   events = [];
   elements = [];
+  graphNodes = [];
+  graphEdges = [];
   extractionJobs = /* @__PURE__ */ new Map();
   elementProjectionJobs = /* @__PURE__ */ new Map();
+  graphProjectionJobs = /* @__PURE__ */ new Map();
   usageReceipts = /* @__PURE__ */ new Map();
   successfulModelResponses = [];
   ingestionReceipts = /* @__PURE__ */ new Map();
@@ -1633,9 +1870,12 @@ var StrataGate = class _StrataGate {
     this.summarizer = options.summarizer;
     this.extractor = options.extractor;
     this.elementProjector = options.elementProjector;
+    this.disableElementProjection = options.disableElementProjection ?? false;
+    this.graphProjector = options.graphProjector;
     this.now = options.now ?? (() => /* @__PURE__ */ new Date());
     this.idFactory = options.idFactory ?? defaultIdFactory;
     this.elementIdFactory = options.elementIdFactory ?? defaultElementIdFactory;
+    this.graphIdFactory = options.graphIdFactory ?? defaultGraphIdFactory;
   }
   static inMemory(options = {}) {
     return new _StrataGate(options, STRATAGATE_CONSTRUCTOR_TOKEN);
@@ -1656,9 +1896,12 @@ var StrataGate = class _StrataGate {
         ...options.summarizer ? { summarizer: options.summarizer } : {},
         ...options.extractor ? { extractor: options.extractor } : {},
         ...options.elementProjector ? { elementProjector: options.elementProjector } : {},
+        ...options.disableElementProjection !== void 0 ? { disableElementProjection: options.disableElementProjection } : {},
+        ...options.graphProjector ? { graphProjector: options.graphProjector } : {},
         ...options.now ? { now: options.now } : {},
         ...options.idFactory ? { idFactory: options.idFactory } : {},
-        ...options.elementIdFactory ? { elementIdFactory: options.elementIdFactory } : {}
+        ...options.elementIdFactory ? { elementIdFactory: options.elementIdFactory } : {},
+        ...options.graphIdFactory ? { graphIdFactory: options.graphIdFactory } : {}
       });
     } catch (error) {
       await storage.close();
@@ -1700,9 +1943,12 @@ var StrataGate = class _StrataGate {
     if (options.summarizer) memoryOptions.summarizer = options.summarizer;
     if (options.extractor) memoryOptions.extractor = options.extractor;
     if (options.elementProjector) memoryOptions.elementProjector = options.elementProjector;
+    if (options.disableElementProjection !== void 0) memoryOptions.disableElementProjection = options.disableElementProjection;
+    if (options.graphProjector) memoryOptions.graphProjector = options.graphProjector;
     if (options.now) memoryOptions.now = options.now;
     if (options.idFactory) memoryOptions.idFactory = options.idFactory;
     if (options.elementIdFactory) memoryOptions.elementIdFactory = options.elementIdFactory;
+    if (options.graphIdFactory) memoryOptions.graphIdFactory = options.graphIdFactory;
     const memory = new _StrataGate(memoryOptions, STRATAGATE_CONSTRUCTOR_TOKEN);
     memory.storage = options.storage;
     memory.namespace = namespace;
@@ -1737,6 +1983,21 @@ var StrataGate = class _StrataGate {
           }
         });
       }
+      const interruptedGraphProjections = [...memory.graphProjectionJobs.values()].filter((job) => job.status === "running");
+      if (interruptedGraphProjections.length > 0) {
+        await memory.commitMutation(() => {
+          const now = toUtc8Iso(memory.now());
+          for (const job of interruptedGraphProjections) {
+            memory.graphProjectionJobs.set(job.id, {
+              ...job,
+              status: "failed",
+              lastError: "Graph projection was interrupted before completion.",
+              updatedAt: now
+            });
+          }
+        });
+      }
+      if (memory.graphProjector) await memory.commitMutation(() => memory.queueMissingGraphProjections());
     } else {
       await memory.persist();
     }
@@ -1769,6 +2030,12 @@ var StrataGate = class _StrataGate {
   listElements() {
     return this.elements;
   }
+  listGraphNodes() {
+    return this.graphNodes;
+  }
+  listGraphEdges() {
+    return this.graphEdges;
+  }
   listOpenTail(threadId) {
     if (threadId === void 0) return this.openTail;
     return this.openTail.filter((message) => message.threadId === threadId);
@@ -1779,6 +2046,9 @@ var StrataGate = class _StrataGate {
   listElementProjectionJobs() {
     return [...this.elementProjectionJobs.values()];
   }
+  listGraphProjectionJobs() {
+    return [...this.graphProjectionJobs.values()];
+  }
   listUsageReceipts() {
     return [...this.usageReceipts.values()];
   }
@@ -1806,6 +2076,9 @@ var StrataGate = class _StrataGate {
       openTail: this.openTail,
       blocks: this.blocks,
       events: this.events,
+      graphNodes: this.graphNodes,
+      graphEdges: this.graphEdges,
+      graphProjectionJobs: [...this.graphProjectionJobs.values()],
       elements: this.elements,
       extractionJobs: [...this.extractionJobs.values()],
       elementProjectionJobs: [...this.elementProjectionJobs.values()],
@@ -1856,11 +2129,13 @@ var StrataGate = class _StrataGate {
     }
     if (this.threadOpenTail(threadId).filter((message) => message.role === "user").length < this.blockTurnSize) {
       const projectedElements2 = await this.projectEligibleElements() ?? [];
+      await this.projectEligibleGraph();
       return { sealedBlock: null, extractedEvents: [], projectedElements: projectedElements2 };
     }
     const sealedBlock = await this.sealOpenTail(threadId);
     const extractedEvents = await this.extractEligibleBlock() ?? [];
     const projectedElements = await this.projectEligibleElements() ?? [];
+    await this.projectEligibleGraph();
     return { sealedBlock, extractedEvents, projectedElements };
   }
   async resumePendingWork(options = {}) {
@@ -1873,12 +2148,14 @@ var StrataGate = class _StrataGate {
       sealedBlocks.push(await this.sealOpenTail(sealable.threadId));
       extractedEvents.push(...await this.extractEligibleBlock() ?? []);
       projectedElements.push(...await this.projectEligibleElements() ?? []);
+      await this.projectEligibleGraph();
     }
     while (true) {
       const extracted = await this.extractEligibleBlock();
       if (extracted === null) break;
       extractedEvents.push(...extracted);
       projectedElements.push(...await this.projectEligibleElements() ?? []);
+      await this.projectEligibleGraph();
     }
     if (options.retrySkipped === true) {
       const skippedBlockIds = this.blocks.filter((block) => this.nextBlockInThread(block) !== null && block.shouldExtract && this.extractionJobs.get(block.id)?.status === "skipped").map((block) => block.id);
@@ -1887,6 +2164,7 @@ var StrataGate = class _StrataGate {
         if (extracted === null) continue;
         extractedEvents.push(...extracted);
         projectedElements.push(...await this.projectEligibleElements() ?? []);
+        await this.projectEligibleGraph();
       }
     }
     while (true) {
@@ -1894,12 +2172,14 @@ var StrataGate = class _StrataGate {
       if (projected === null) break;
       projectedElements.push(...projected);
     }
+    await this.projectEligibleGraph();
     return { sealedBlocks, extractedEvents, projectedElements };
   }
   async addEvent(input) {
     return this.commitMutation(() => {
       const event = this.addEventInMemory(input);
       this.queueElementProjection([event.id]);
+      this.queueGraphProjection([event.id], 1e3);
       return event;
     });
   }
@@ -1929,10 +2209,10 @@ var StrataGate = class _StrataGate {
       [event.temporal.originalText ?? "", 4],
       [`${event.temporal.happenedStart ?? ""} ${event.temporal.happenedEnd ?? ""}`, 4]
     ])).map(({ item }) => item);
-    const chronology = (event) => event.temporal.happenedStart ?? event.temporal.happenedEnd ?? event.temporal.mentionedAt ?? event.createdAt;
+    const chronology2 = (event) => event.temporal.happenedStart ?? event.temporal.happenedEnd ?? event.temporal.mentionedAt ?? event.createdAt;
     const structured = (items) => [...items].sort((left, right) => {
-      if (options.temporalIntent === "first") return chronology(left).localeCompare(chronology(right));
-      if (options.temporalIntent === "latest") return chronology(right).localeCompare(chronology(left));
+      if (options.temporalIntent === "first") return chronology2(left).localeCompare(chronology2(right));
+      if (options.temporalIntent === "latest") return chronology2(right).localeCompare(chronology2(left));
       return memoryWeightAt(right, this.currentTurn) - memoryWeightAt(left, this.currentTurn) || right.updatedAt.localeCompare(left.updatedAt);
     });
     const participantIds = new Set(participantMatches.map(({ id }) => id));
@@ -2018,6 +2298,66 @@ var StrataGate = class _StrataGate {
       job.updatedAt = toUtc8Iso(this.now());
     });
   }
+  async claimNextGraphProjection() {
+    return this.commitMutation(() => {
+      const job = [...this.graphProjectionJobs.values()].filter((candidate) => candidate.status === "pending" || candidate.status === "failed").sort((left, right) => right.priority - left.priority || left.createdAt.localeCompare(right.createdAt))[0];
+      if (!job) return null;
+      const events = job.sourceEventIds.flatMap((id) => this.events.find((event) => event.id === id) ?? []);
+      if (events.length === 0) throw new Error(`Graph projection ${job.id} has no available source events`);
+      job.status = "running";
+      job.attempts += 1;
+      job.lastError = null;
+      job.updatedAt = toUtc8Iso(this.now());
+      const eventText = normalizeSearchText(events.map((event) => [
+        event.title,
+        event.summary,
+        event.tags.join(" "),
+        (event.temporal.participants ?? []).join(" ")
+      ].join(" ")).join(" "));
+      const relevantNodes = this.graphNodes.filter((node) => [node.name, ...node.aliases].some((name2) => eventText.includes(normalizeSearchText(name2)))).concat([...this.graphNodes].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)).slice(0, 24));
+      const existingNodes = [...new Map(relevantNodes.map((node) => [node.id, node])).values()].slice(0, 80);
+      const nodeIds = new Set(existingNodes.map(({ id }) => id));
+      return {
+        jobId: job.id,
+        projectorVersion: job.projectorVersion,
+        events: structuredClone(events),
+        existingNodes: structuredClone(existingNodes),
+        existingEdges: structuredClone(this.graphEdges.filter(({ fromNodeId, toNodeId }) => nodeIds.has(fromNodeId) && nodeIds.has(toNodeId)).slice(-120))
+      };
+    });
+  }
+  async completeGraphProjection(jobId, result) {
+    return this.commitMutation(() => {
+      const job = this.requireGraphProjectionJob(jobId);
+      if (job.status === "completed") return { nodeIds: job.nodeIds, edgeIds: job.edgeIds };
+      if (job.status !== "running") throw new Error(`Graph projection ${job.id} is ${job.status}, not running`);
+      const touched = applyGraphProjection({
+        nodes: this.graphNodes,
+        edges: this.graphEdges,
+        events: this.events,
+        result,
+        allowedEventIds: new Set(job.sourceEventIds),
+        now: toUtc8Iso(this.now()),
+        idFactory: this.graphIdFactory
+      });
+      job.status = "completed";
+      job.nodeIds = touched.nodeIds;
+      job.edgeIds = touched.edgeIds;
+      job.reason = typeof result.reason === "string" ? result.reason.trim().replace(/\s+/g, " ").slice(0, 500) || null : null;
+      job.lastError = null;
+      job.updatedAt = toUtc8Iso(this.now());
+      return touched;
+    });
+  }
+  async failGraphProjection(jobId, error) {
+    await this.commitMutation(() => {
+      const job = this.requireGraphProjectionJob(jobId);
+      if (job.status === "completed") return;
+      job.status = "failed";
+      job.lastError = errorMessage(error);
+      job.updatedAt = toUtc8Iso(this.now());
+    });
+  }
   async searchElements(query, options = {}) {
     const normalizedName = normalizeSearchText(options.name ?? "");
     const candidates = this.elements.flatMap((element) => element.facts.map((fact) => ({
@@ -2239,7 +2579,10 @@ var StrataGate = class _StrataGate {
       quotes: [...new Set(input.quotes ?? [])].slice(0, 12),
       sourceMessageIds,
       sourceBlockId: sourceBlock.id,
-      temporal: input.temporal ? { ...input.temporal } : { mentionedAt: now },
+      temporal: {
+        ...input.temporal ? { ...input.temporal } : { mentionedAt: now },
+        eventType: normalizeStandardEventType(input.temporal?.eventType)
+      },
       scope: input.scope ?? "user",
       criticality,
       confidence: Math.max(0, Math.min(1, input.confidence ?? 1)),
@@ -2278,7 +2621,59 @@ var StrataGate = class _StrataGate {
     if (!job) throw new Error(`Unknown element projection: ${id}`);
     return job;
   }
+  async searchGraphNodes(query, limit = 8) {
+    const candidates = this.graphNodes.filter((node) => node.status === "active" || node.status === "disputed");
+    const ranked = bm25Rank(candidates, query, (node) => weightedSearchTokens([
+      [node.name, 6],
+      [node.aliases.join(" "), 5],
+      [node.type, 2],
+      [node.currentState, 4],
+      [node.facts.map((fact) => `${fact.key} ${Array.isArray(fact.value) ? fact.value.join(" ") : fact.value}`).join(" "), 4],
+      [this.graphEdges.filter((edge) => edge.fromNodeId === node.id || edge.toNodeId === node.id).map(({ relation }) => relation).join(" "), 3]
+    ])).slice(0, Math.max(1, Math.min(20, limit)));
+    if (searchTokens(query).length > 0 && ranked.length === 0) return [];
+    return ranked.map(({ item: node, score }) => ({ node, score }));
+  }
+  requireGraphProjectionJob(id) {
+    const job = this.graphProjectionJobs.get(id);
+    if (!job) throw new Error(`Unknown graph projection: ${id}`);
+    return job;
+  }
+  queueGraphProjection(sourceEventIds, priority) {
+    if (!this.graphProjector) return null;
+    const completed = new Set([...this.graphProjectionJobs.values()].filter((job2) => job2.projectorVersion === KNOWLEDGE_GRAPH_PROJECTOR_VERSION && job2.status === "completed").flatMap((job2) => job2.sourceEventIds));
+    const queued = new Set([...this.graphProjectionJobs.values()].filter((job2) => job2.projectorVersion === KNOWLEDGE_GRAPH_PROJECTOR_VERSION && job2.status !== "completed").flatMap((job2) => job2.sourceEventIds));
+    const ids = [...new Set(sourceEventIds.filter((id) => this.events.some((event) => event.id === id) && !completed.has(id) && !queued.has(id)))];
+    if (ids.length === 0) return null;
+    const now = toUtc8Iso(this.now());
+    const job = {
+      id: this.graphIdFactory("gproj"),
+      sourceEventIds: ids,
+      projectorVersion: KNOWLEDGE_GRAPH_PROJECTOR_VERSION,
+      status: "pending",
+      attempts: 0,
+      priority,
+      nodeIds: [],
+      edgeIds: [],
+      reason: null,
+      lastError: null,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.graphProjectionJobs.set(job.id, job);
+    return job;
+  }
+  queueMissingGraphProjections() {
+    const candidates = [...this.events].filter((event) => event.status !== "forgotten" && event.status !== "archived").sort((left, right) => {
+      const score = (event) => (event.status === "active" ? 1e4 : 0) + event.weight.mentionCount * 100 + (event.scope === "project" ? 500 : 0) + (Date.parse(event.temporal.happenedStart ?? event.temporal.mentionedAt ?? event.updatedAt) || 0) / 1e12;
+      return score(right) - score(left);
+    });
+    for (let index = 0; index < candidates.length; index += 8) {
+      this.queueGraphProjection(candidates.slice(index, index + 8).map(({ id }) => id), candidates.length - index);
+    }
+  }
   queueElementProjection(sourceEventIds) {
+    if (this.disableElementProjection) return null;
     const ids = [...new Set(sourceEventIds.filter((id) => this.events.some((event) => event.id === id)))];
     if (ids.length === 0) return null;
     const now = toUtc8Iso(this.now());
@@ -2447,7 +2842,11 @@ var StrataGate = class _StrataGate {
     }
     return this.commitMutation(() => {
       const extracted = result.shouldExtract ? result.events.map((event) => this.addEventInMemory({ ...event, sourceBlockId: target.id })) : [];
-      if (extracted.length > 0) this.queueElementProjection(extracted.map(({ id }) => id));
+      if (extracted.length > 0) {
+        const ids = extracted.map(({ id }) => id);
+        this.queueElementProjection(ids);
+        this.queueGraphProjection(ids, 1e3);
+      }
       const job = this.extractionJobs.get(target.id);
       if (!job) throw new Error(`Missing extraction job for block: ${target.id}`);
       this.extractionJobs.set(target.id, {
@@ -2471,6 +2870,17 @@ var StrataGate = class _StrataGate {
       throw error;
     }
   }
+  async projectEligibleGraph() {
+    if (!this.graphProjector) return null;
+    const batch = await this.claimNextGraphProjection();
+    if (!batch) return null;
+    try {
+      return await this.completeGraphProjection(batch.jobId, await this.graphProjector(batch));
+    } catch (error) {
+      await this.failGraphProjection(batch.jobId, error);
+      return null;
+    }
+  }
   async commitMutation(mutation) {
     const previous = this.mutationQueue;
     let release;
@@ -2514,11 +2924,15 @@ var StrataGate = class _StrataGate {
     this.openTail.splice(0, this.openTail.length, ...copy.openTail);
     this.blocks.splice(0, this.blocks.length, ...copy.blocks);
     this.events.splice(0, this.events.length, ...copy.events);
+    this.graphNodes.splice(0, this.graphNodes.length, ...copy.graphNodes);
+    this.graphEdges.splice(0, this.graphEdges.length, ...copy.graphEdges);
     this.elements.splice(0, this.elements.length, ...copy.elements);
     this.extractionJobs.clear();
     for (const job of copy.extractionJobs) this.extractionJobs.set(job.blockId, job);
     this.elementProjectionJobs.clear();
     for (const job of copy.elementProjectionJobs) this.elementProjectionJobs.set(job.id, job);
+    this.graphProjectionJobs.clear();
+    for (const job of copy.graphProjectionJobs) this.graphProjectionJobs.set(job.id, job);
     this.usageReceipts.clear();
     for (const receipt of copy.usageReceipts) this.usageReceipts.set(receipt.id, receipt);
     this.ingestionReceipts.clear();
@@ -2582,6 +2996,42 @@ var StrataGate = class _StrataGate {
         if (!elementIds.has(elementId)) throw new Error(`Element projection ${job.id} references unknown element ${elementId}`);
       }
     }
+    const graphNodeIds = /* @__PURE__ */ new Set();
+    for (const node of this.graphNodes) {
+      if (graphNodeIds.has(node.id)) throw new Error(`Duplicate graph node ID in snapshot: ${node.id}`);
+      graphNodeIds.add(node.id);
+      for (const eventId of node.sourceEventIds) {
+        if (!eventIds.has(eventId)) throw new Error(`Graph node ${node.id} references unknown event ${eventId}`);
+      }
+      for (const fact of node.facts) for (const eventId of fact.sourceEventIds) {
+        if (!eventIds.has(eventId)) throw new Error(`Graph fact ${fact.id} references unknown event ${eventId}`);
+      }
+    }
+    const graphEdgeIds = /* @__PURE__ */ new Set();
+    for (const edge of this.graphEdges) {
+      if (graphEdgeIds.has(edge.id)) throw new Error(`Duplicate graph edge ID in snapshot: ${edge.id}`);
+      graphEdgeIds.add(edge.id);
+      if (!graphNodeIds.has(edge.fromNodeId) || !graphNodeIds.has(edge.toNodeId)) {
+        throw new Error(`Graph edge ${edge.id} references an unknown node`);
+      }
+      for (const eventId of edge.sourceEventIds) {
+        if (!eventIds.has(eventId)) throw new Error(`Graph edge ${edge.id} references unknown event ${eventId}`);
+      }
+    }
+    for (const event of this.events) for (const nodeId of event.temporal.participantNodeIds ?? []) {
+      if (!graphNodeIds.has(nodeId)) throw new Error(`Event ${event.id} references unknown graph node ${nodeId}`);
+    }
+    for (const job of this.graphProjectionJobs.values()) {
+      for (const eventId of job.sourceEventIds) if (!eventIds.has(eventId)) {
+        throw new Error(`Graph projection ${job.id} references unknown event ${eventId}`);
+      }
+      for (const nodeId of job.nodeIds) if (!graphNodeIds.has(nodeId)) {
+        throw new Error(`Graph projection ${job.id} references unknown node ${nodeId}`);
+      }
+      for (const edgeId of job.edgeIds) if (!graphEdgeIds.has(edgeId)) {
+        throw new Error(`Graph projection ${job.id} references unknown edge ${edgeId}`);
+      }
+    }
   }
 };
 
@@ -2718,10 +3168,10 @@ var CRITICALITIES = /* @__PURE__ */ new Set(["routine", "preference", "identity"
 function object(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function strings(value) {
+function strings2(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
-function text(value, fallback = "") {
+function text2(value, fallback = "") {
   return typeof value === "string" ? value.trim() : fallback;
 }
 function l2Neighbor(block) {
@@ -2751,7 +3201,8 @@ var RETRY_MAX_TOKENS = 1e4;
 var STRUCTURED_FIELDS = {
   summarizer: ["l0Title", "l0Tags", "l1Summary", "l2Keypoints", "shouldExtract"],
   extractor: ["shouldExtract", "reason", "events"],
-  projector: ["reason", "changes"]
+  projector: ["reason", "changes"],
+  graphProjector: ["reason", "nodes", "edges"]
 };
 var STRING_ARRAY = { type: "array", items: { type: "string" } };
 var OPEN_OBJECT = { type: "object", additionalProperties: true };
@@ -2817,6 +3268,47 @@ var PROJECTOR_PARAMETERS = {
   reason: { type: "string", required: true },
   changes: { type: "array", items: ELEMENT_CHANGE, required: true }
 };
+var GRAPH_FACT = {
+  type: "object",
+  additionalProperties: false,
+  properties: { key: { type: "string", required: true }, value: { ...VALUE, required: true }, sourceEventIds: { ...STRING_ARRAY, required: true } }
+};
+var GRAPH_NODE = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    ref: { type: "string", required: true },
+    name: { type: "string", required: true },
+    type: { type: "string", enum: ["person", "project", "organization", "tool", "place"], required: true },
+    aliases: STRING_ARRAY,
+    state: { type: "string" },
+    facts: { type: "array", items: GRAPH_FACT },
+    status: { type: "string", enum: ["active", "superseded", "disputed", "archived"] },
+    validFrom: { type: "string" },
+    validTo: { type: "string" },
+    confidence: { type: "number" },
+    sourceEventIds: { ...STRING_ARRAY, required: true }
+  }
+};
+var GRAPH_EDGE = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    fromRef: { type: "string", required: true },
+    toRef: { type: "string", required: true },
+    relation: { type: "string", required: true },
+    status: { type: "string", enum: ["active", "superseded", "disputed", "archived"] },
+    validFrom: { type: "string" },
+    validTo: { type: "string" },
+    confidence: { type: "number" },
+    sourceEventIds: { ...STRING_ARRAY, required: true }
+  }
+};
+var GRAPH_PROJECTOR_PARAMETERS = {
+  reason: { type: "string", required: true },
+  nodes: { type: "array", items: GRAPH_NODE, required: true },
+  edges: { type: "array", items: GRAPH_EDGE, required: true }
+};
 var STRUCTURED_TOOLS = {
   summarizer: {
     name: "stratagate_summarize_block",
@@ -2832,6 +3324,11 @@ var STRUCTURED_TOOLS = {
     name: "stratagate_project_element_cards",
     description: "Submit element-card changes supported by the supplied event cards.",
     parameters: PROJECTOR_PARAMETERS
+  },
+  graphProjector: {
+    name: "stratagate_project_knowledge_graph",
+    description: "Project stable graph nodes and directed edges from supplied event evidence.",
+    parameters: GRAPH_PROJECTOR_PARAMETERS
   }
 };
 function toolSchema(kind) {
@@ -2869,10 +3366,10 @@ var DshModelBridge = class {
       { messages }
     ));
     return {
-      l0Title: text(raw.l0Title, "Conversation block").slice(0, 120),
-      l0Tags: strings(raw.l0Tags).slice(0, 12),
-      l1Summary: text(raw.l1Summary).slice(0, 2e3),
-      l2Keypoints: strings(raw.l2Keypoints).slice(0, 20),
+      l0Title: text2(raw.l0Title, "Conversation block").slice(0, 120),
+      l0Tags: strings2(raw.l0Tags).slice(0, 12),
+      l1Summary: text2(raw.l1Summary).slice(0, 2e3),
+      l2Keypoints: strings2(raw.l2Keypoints).slice(0, 20),
       shouldExtract: raw.shouldExtract === true
     };
   };
@@ -2880,21 +3377,21 @@ var DshModelBridge = class {
     const validMessageIds = new Set(context.target.l5Raw.map((message) => message.id));
     const raw = object(await this.callStructured(
       "extractor",
-      `Extract only durable, evidence-backed events from target.l5Raw, then call ${STRUCTURED_TOOLS.extractor.name} exactly once. The target block is the only legal source of new facts, quotations, and sourceMessageIds. neighbors.previous and neighbors.next are context-only L2 summaries; never extract from them. Every sourceMessageIds entry must exactly match allowedSourceMessageIds. If a fact appears only in a neighbor, do not extract it in this call. Events must be understandable later without the original chat. Use project scope for repository decisions, user scope for stable preferences/identity, and session scope for temporary task state. Use ISO-8601 timestamps with the explicit +08:00 offset in temporal fields. Do not turn an assistant statement that merely recalls older memory into a new event; require new human input or a new observable task/tool outcome from target.l5Raw. Do not return the result as text.`,
+      `Extract only durable, evidence-backed events from target.l5Raw, then call ${STRUCTURED_TOOLS.extractor.name} exactly once. The target block is the only legal source of new facts, quotations, and sourceMessageIds. neighbors.previous and neighbors.next are context-only L2 summaries; never extract from them. Every sourceMessageIds entry must exactly match allowedSourceMessageIds. If a fact appears only in a neighbor, do not extract it in this call. Events must be understandable later without the original chat. Use project scope for repository decisions, user scope for stable preferences/identity, and session scope for temporary task state. temporal.eventType must use exactly one stable value: decision, release, task_completed, plan, change, cancellation, incident, meeting, collaboration, migration, or other. temporal.participants contains canonical entity names. Use ISO-8601 timestamps with the explicit +08:00 offset in temporal fields. Keep happened time separate from mentionedAt; when happened time is unknown omit it and set precision/basis to unknown. Do not turn an assistant statement that merely recalls older memory into a new event; require new human input or a new observable task/tool outcome from target.l5Raw. Do not return the result as text.`,
       extractorPayload(context)
     ));
     const events = (Array.isArray(raw.events) ? raw.events : []).map((candidate) => {
       const item = object(candidate);
-      const sourceMessageIds = strings(item.sourceMessageIds).filter((id) => validMessageIds.has(id));
+      const sourceMessageIds = strings2(item.sourceMessageIds).filter((id) => validMessageIds.has(id));
       const scope = SCOPES.has(item.scope) ? item.scope : "project";
       const criticality = CRITICALITIES.has(item.criticality) ? item.criticality : "routine";
-      if (!text(item.title) || !text(item.summary) || sourceMessageIds.length === 0) return null;
+      if (!text2(item.title) || !text2(item.summary) || sourceMessageIds.length === 0) return null;
       return {
-        title: text(item.title).slice(0, 200),
-        summary: text(item.summary).slice(0, 1e3),
-        narrative: text(item.narrative),
-        tags: strings(item.tags).slice(0, 16),
-        quotes: strings(item.quotes).slice(0, 12),
+        title: text2(item.title).slice(0, 200),
+        summary: text2(item.summary).slice(0, 1e3),
+        narrative: text2(item.narrative),
+        tags: strings2(item.tags).slice(0, 16),
+        quotes: strings2(item.quotes).slice(0, 12),
         sourceMessageIds,
         sourceBlockId: context.target.id,
         temporal: object(item.temporal),
@@ -2905,7 +3402,7 @@ var DshModelBridge = class {
     }).filter((event) => event !== null);
     return {
       shouldExtract: raw.shouldExtract === true,
-      reason: text(raw.reason, events.length ? "Durable evidence extracted." : "No durable evidence."),
+      reason: text2(raw.reason, events.length ? "Durable evidence extracted." : "No durable evidence."),
       events
     };
   };
@@ -2920,27 +3417,82 @@ var DshModelBridge = class {
       const item = object(candidate);
       const element = object(item.element);
       const type = element.type;
-      const sourceEventIds = strings(item.sourceEventIds).filter((id) => eventIds.has(id));
+      const sourceEventIds = strings2(item.sourceEventIds).filter((id) => eventIds.has(id));
       const operation = item.operation;
       const mode = item.mode;
       const value = item.value;
-      if (!text(element.name) || !ELEMENT_TYPES2.has(type) || sourceEventIds.length === 0) return [];
+      if (!text2(element.name) || !ELEMENT_TYPES2.has(type) || sourceEventIds.length === 0) return [];
       if (!["set_state", "add_set_item", "set_relation"].includes(String(operation))) return [];
       if (!["state", "set", "relation"].includes(String(mode))) return [];
       if (!(typeof value === "string" || Array.isArray(value) && value.every((entry) => typeof entry === "string"))) return [];
       return [{
-        element: { name: text(element.name), type, aliases: strings(element.aliases) },
+        element: { name: text2(element.name), type, aliases: strings2(element.aliases) },
         operation,
-        key: text(item.key, "state"),
+        key: text2(item.key, "state"),
         mode,
         value,
-        ...text(item.validFrom) ? { validFrom: text(item.validFrom) } : {},
-        ...text(item.validTo) ? { validTo: text(item.validTo) } : {},
+        ...text2(item.validFrom) ? { validFrom: text2(item.validFrom) } : {},
+        ...text2(item.validTo) ? { validTo: text2(item.validTo) } : {},
         sourceEventIds,
         ...typeof item.confidence === "number" ? { confidence: item.confidence } : {}
       }];
     });
-    return { reason: text(raw.reason, "Projected event evidence."), changes };
+    return { reason: text2(raw.reason, "Projected event evidence."), changes };
+  };
+  graphProjector = async (context) => {
+    const eventIds = new Set(context.events.map((event) => event.id));
+    const raw = object(await this.callStructured(
+      "graphProjector",
+      `Project the supplied Events into the current Knowledge Graph, then call ${STRUCTURED_TOOLS.graphProjector.name} exactly once. Events are the sole source of truth; never use legacy Element data. Return stable entity nodes for people, projects, organizations, tools, and places. Use aliases to merge spelling/case/separator variants. Put attributes in node facts and every relationship in a directed edge using fromRef/toRef\u2014never encode a relationship as a fact string. Prefer concise canonical Chinese relation labels such as \u4F7F\u7528\u3001\u5C5E\u4E8E\u3001\u521B\u5EFA\u3001\u53C2\u4E0E\u3001\u8D21\u732E\u3001\u4F9D\u8D56\u3001\u4F4D\u4E8E\u3001\u76F8\u5173. Every node, fact, and edge must cite only supplied Event ids. Do not return text.`,
+      context
+    ));
+    const nodes = (Array.isArray(raw.nodes) ? raw.nodes : []).flatMap((candidate) => {
+      const item = object(candidate);
+      const sourceEventIds = strings2(item.sourceEventIds).filter((id) => eventIds.has(id));
+      const type = item.type;
+      if (!text2(item.ref) || !text2(item.name) || !ELEMENT_TYPES2.has(type) || sourceEventIds.length === 0) return [];
+      const facts = (Array.isArray(item.facts) ? item.facts : []).flatMap((candidateFact) => {
+        const fact = object(candidateFact);
+        const value = fact.value;
+        if (!text2(fact.key) || !(typeof value === "string" || Array.isArray(value) && value.every((entry) => typeof entry === "string"))) return [];
+        const sourceEventIds2 = strings2(fact.sourceEventIds).filter((id) => eventIds.has(id));
+        if (sourceEventIds2.length === 0) return [];
+        return [{ key: text2(fact.key), value, sourceEventIds: sourceEventIds2 }];
+      });
+      return [{
+        ref: text2(item.ref),
+        name: text2(item.name),
+        type,
+        aliases: strings2(item.aliases),
+        ...text2(item.state) ? { state: text2(item.state) } : {},
+        facts,
+        ...typeof item.status === "string" ? { status: item.status } : {},
+        ...text2(item.validFrom) ? { validFrom: text2(item.validFrom) } : {},
+        ...text2(item.validTo) ? { validTo: text2(item.validTo) } : {},
+        ...typeof item.confidence === "number" ? { confidence: item.confidence } : {},
+        sourceEventIds
+      }];
+    });
+    const refs = new Set(nodes.map(({ ref }) => ref));
+    const edges = (Array.isArray(raw.edges) ? raw.edges : []).flatMap((candidate) => {
+      const item = object(candidate);
+      const sourceEventIds = strings2(item.sourceEventIds).filter((id) => eventIds.has(id));
+      const fromRef = text2(item.fromRef);
+      const toRef = text2(item.toRef);
+      const relation = text2(item.relation);
+      if (!refs.has(fromRef) || !refs.has(toRef) || !relation || sourceEventIds.length === 0) return [];
+      return [{
+        fromRef,
+        toRef,
+        relation,
+        ...typeof item.status === "string" ? { status: item.status } : {},
+        ...text2(item.validFrom) ? { validFrom: text2(item.validFrom) } : {},
+        ...text2(item.validTo) ? { validTo: text2(item.validTo) } : {},
+        ...typeof item.confidence === "number" ? { confidence: item.confidence } : {},
+        sourceEventIds
+      }];
+    });
+    return { reason: text2(raw.reason, "Projected Event evidence into the Knowledge Graph."), nodes, edges };
   };
   async callStructured(kind, system, payload) {
     const session = this.sessions.getStore();
@@ -3063,6 +3615,7 @@ ${JSON_RETRY_INSTRUCTION}`,
 import { createHash } from "node:crypto";
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
+import { createUserMessage as createUserMessage2 } from "@deepseek-ai/dsh-llm";
 
 // src/fold.ts
 function renderBlocks(blocks) {
@@ -3116,13 +3669,13 @@ var TurnFolder = class {
         if (event.data.source.kind !== "user") return null;
         const turn = this.activeTurn.get(sessionId);
         if (turn === void 0) return null;
-        const text2 = renderBlocks(event.data.content);
-        if (text2) this.pending(sessionId, turn).user.push(text2);
+        const text3 = renderBlocks(event.data.content);
+        if (text3) this.pending(sessionId, turn).user.push(text3);
         return null;
       }
       case "assistant/message": {
-        const text2 = renderBlocks(event.data.message.content);
-        if (text2) this.pending(sessionId, event.data.turn).assistant.push(text2);
+        const text3 = renderBlocks(event.data.message.content);
+        if (text3) this.pending(sessionId, event.data.turn).assistant.push(text3);
         return null;
       }
       case "tool/call": {
@@ -3158,7 +3711,8 @@ var TurnFolder = class {
           threadId: sessionId,
           assistantToolCalls: [...pending.tools.values()],
           createdAt: toUtc8Iso(event.time),
-          receiptId: `dsh:${sessionId}:turn:${event.data.turn}`
+          receiptId: `dsh:${sessionId}:turn:${event.data.turn}`,
+          dshTurn: event.data.turn
         };
       }
       default:
@@ -3238,6 +3792,7 @@ var DshMetadataStore = class {
 var AUTO_EVENT_LIMIT = 4;
 var AUTO_ELEMENT_LIMIT = 4;
 var AUTO_MEMORY_TOKEN_BUDGET = 900;
+var COMPACTION_SOURCE_PLUGIN = "stratagate-memory";
 function projectKey(cwd) {
   const canonical = resolve(cwd ?? process.cwd()).replaceAll("\\", "/").toLowerCase();
   return createHash("sha256").update(canonical).digest("hex").slice(0, 20);
@@ -3248,21 +3803,25 @@ function workspaceDisplayName(cwd) {
 }
 var StrataGateRuntime = class {
   constructor(config, models, onIngestError = () => {
+  }, flushNativeSession = async () => {
   }) {
     this.config = config;
     this.models = models;
     this.onIngestError = onIngestError;
+    this.flushNativeSession = flushNativeSession;
     this.blockDecayLambda = config.blockDecayLambda;
   }
   config;
   models;
   onIngestError;
+  flushNativeSession;
   folder = new TurnFolder();
   spaces = /* @__PURE__ */ new Map();
   batches = /* @__PURE__ */ new Map();
   adopted = /* @__PURE__ */ new Map();
   pendingUse = /* @__PURE__ */ new Set();
   workspaceNames = /* @__PURE__ */ new Map();
+  migrationTimers = /* @__PURE__ */ new Map();
   ingestTail = Promise.resolve();
   settingsTail = Promise.resolve();
   batchSequence = 0;
@@ -3278,7 +3837,15 @@ var StrataGateRuntime = class {
     }).then(async () => {
       const memory = await this.space(session);
       try {
-        await this.models.run(session, () => memory.appendTurn(turn));
+        const result = await this.models.run(session, () => memory.appendTurn(turn));
+        if (result.sealedBlock) {
+          const contexts = memory.getBlockContext(String(session.id));
+          const sealedContext = contexts.find(({ id }) => id === result.sealedBlock.id);
+          if (!sealedContext) throw new Error(`Missing context for sealed StrataGate block ${result.sealedBlock.id}`);
+          this.replaceSealedSurface(session, result.sealedBlock, sealedContext, turn.dshTurn);
+          this.syncDecayedBlockSurface(session, contexts);
+          await this.flushNativeSession(session);
+        }
       } finally {
         await this.persistSuccessfulResponses(memory);
       }
@@ -3436,23 +4003,78 @@ var StrataGateRuntime = class {
     await this.flush();
     const memory = await this.space(session);
     const threadId = String(session.id);
+    const blockContexts = memory.getBlockContext(threadId);
+    if (this.syncDecayedBlockSurface(session, blockContexts)) {
+      await this.flushNativeSession(session);
+    }
     const openTail = memory.listOpenTail(threadId);
     const activationQuery = [currentUserMessage(session), renderMessages(recentTurns(openTail, 2))].filter(Boolean).join("\n\n");
-    const [eventHits, elementHits] = activationQuery ? await Promise.all([
-      memory.searchEvents(activationQuery, { limit: 20 }),
-      memory.searchElements(activationQuery, { limit: 12 })
-    ]) : [[], []];
-    const events = activatedEvents(memory, eventHits).slice(0, AUTO_EVENT_LIMIT);
-    const elements = activatedElements(memory, elementHits).slice(0, AUTO_ELEMENT_LIMIT);
-    return [
-      "[Current conversation]",
-      openTail.length > 0 ? renderMessages(openTail) : "(open tail is empty)",
-      "",
-      "[Decayed memory blocks]",
-      renderBlocks2(memory.getBlockContext(threadId)),
-      "",
-      renderActivatedMemory(events, elements)
-    ].join("\n");
+    const eventHits = activationQuery ? await memory.searchEvents(activationQuery, { limit: 20 }) : [];
+    let graphNodes = [];
+    if (activationQuery && typeof memory.searchGraphNodes === "function") {
+      graphNodes = (await memory.searchGraphNodes(activationQuery, 12)).map(({ node }) => node);
+    } else if (activationQuery) {
+      const legacy = activatedElements(memory, await memory.searchElements(activationQuery, { limit: 12 }));
+      graphNodes = legacy.map((item) => ({
+        id: item.elementId,
+        name: item.name,
+        type: item.type,
+        aliases: [],
+        currentState: "",
+        status: "active",
+        confidence: item.fact.confidence ?? 0.8,
+        sourceEventIds: item.fact.sourceEventIds,
+        facts: [{ ...item.fact, confidence: item.fact.confidence ?? 0.8, status: item.fact.status === "disputed" ? "disputed" : item.fact.status === "superseded" ? "superseded" : "active" }],
+        createdAt: item.fact.createdAt,
+        updatedAt: item.fact.updatedAt
+      }));
+    }
+    const events = activatedEvents(memory, eventHits);
+    const currentBlockIds = new Set(memory.listBlocks().filter((block) => block.threadId === threadId).map(({ id }) => id));
+    const currentEventIds = new Set(memory.listEvents().filter((event) => currentBlockIds.has(event.sourceBlockId)).map(({ id }) => id));
+    const longTermEvents = events.filter((event) => !currentEventIds.has(event.id)).slice(0, AUTO_EVENT_LIMIT);
+    graphNodes = graphNodes.filter((node) => !node.sourceEventIds.some((id) => currentEventIds.has(id))).slice(0, AUTO_ELEMENT_LIMIT);
+    return renderActivatedMemory(longTermEvents, graphNodes);
+  }
+  /**
+   * Replace the just-sealed DSH turns with one native surface message. The raw
+   * events remain in the append-only log for transcript/evidence provenance,
+   * while deriveMessages() sees only this compressed checkpoint.
+   */
+  replaceSealedSurface(session, block, context, endTurn) {
+    const sourceEventSeqs = sealedSurfaceSeqs(session, endTurn, block.endTurn - block.startTurn + 1);
+    const start = sourceEventSeqs[0];
+    const end = sourceEventSeqs.at(-1);
+    if (start === void 0 || end === void 0) {
+      throw new Error(`Cannot compact StrataGate block ${block.id}: no DSH surface range was found`);
+    }
+    session.append("user/message", createUserMessage2({
+      content: [{ type: "text", text: renderBlockSurfaceMessage(context) }],
+      source: { kind: "plugin", plugin: COMPACTION_SOURCE_PLUGIN }
+    }), {
+      surfaceOp: { op: "replace", start, end },
+      sourceEventSeqs
+    });
+  }
+  /** Keep each native Block checkpoint synchronized with its current decay pointer. */
+  syncDecayedBlockSurface(session, contexts) {
+    const current = currentBlockSurfaceMessages(session);
+    let changed = false;
+    for (const context of contexts) {
+      const node = current.get(context.id);
+      if (!node) continue;
+      const text3 = renderBlockSurfaceMessage(context);
+      if (node.text === text3) continue;
+      session.append("user/message", createUserMessage2({
+        content: [{ type: "text", text: text3 }],
+        source: { kind: "plugin", plugin: COMPACTION_SOURCE_PLUGIN }
+      }), {
+        surfaceOp: { op: "replace", start: node.seq, end: node.seq },
+        sourceEventSeqs: [node.seq]
+      });
+      changed = true;
+    }
+    return changed;
   }
   // Keep the ingestion error for callers that explicitly require a flushed run.
   async settleIngestion() {
@@ -3464,6 +4086,8 @@ var StrataGateRuntime = class {
   async close() {
     if (this.closed) return;
     this.closed = true;
+    for (const timer of this.migrationTimers.values()) clearTimeout(timer);
+    this.migrationTimers.clear();
     let flushError;
     try {
       await this.flush();
@@ -3564,7 +4188,8 @@ var StrataGateRuntime = class {
         blockDecayLambda: this.blockDecayLambda,
         summarizer: this.models.summarizer,
         extractor: this.models.extractor,
-        elementProjector: this.models.projector
+        graphProjector: this.models.graphProjector,
+        disableElementProjection: true
       });
       try {
         return await memory.expandBlock(id, target, "user");
@@ -3620,14 +4245,28 @@ var StrataGateRuntime = class {
         blockDecayLambda: this.blockDecayLambda,
         summarizer: this.models.summarizer,
         extractor: this.models.extractor,
-        elementProjector: this.models.projector
+        graphProjector: this.models.graphProjector,
+        disableElementProjection: true
       }).then(async (memory) => {
         try {
           try {
-            await this.models.run(session, () => memory.resumePendingWork({ retrySkipped: true }));
+            const resumed = await this.models.run(session, () => memory.resumePendingWork({ retrySkipped: true }));
+            const contexts = memory.getBlockContext(String(session.id));
+            for (const block of resumed.sealedBlocks) {
+              if (block.threadId !== String(session.id)) continue;
+              const endTurn = dshTurnAtBlockEnd(session, block);
+              const context = contexts.find(({ id }) => id === block.id);
+              if (!context) throw new Error(`Missing context for recovered StrataGate block ${block.id}`);
+              this.replaceSealedSurface(session, block, context, endTurn);
+            }
+            this.syncDecayedBlockSurface(session, contexts);
+            if (resumed.sealedBlocks.some((block) => block.threadId === String(session.id))) {
+              await this.flushNativeSession(session);
+            }
           } finally {
             await this.persistSuccessfulResponses(memory);
           }
+          this.scheduleGraphMigration(session, memory);
           return memory;
         } catch (error) {
           await memory.close().catch(() => {
@@ -3642,6 +4281,46 @@ var StrataGateRuntime = class {
     }
     return opening;
   }
+  async searchGraph(session, query, limit = 8) {
+    await this.flush();
+    const results = await (await this.space(session)).searchGraphNodes(query, limit);
+    return this.batch(session, results.map(({ node }) => ({
+      ref: `graph-node:${node.id}`,
+      target: { eventIds: node.sourceEventIds, elementIds: [] }
+    })), results);
+  }
+  async expandGraphNode(session, id) {
+    await this.flush();
+    const memory = await this.space(session);
+    const node = memory.listGraphNodes().find((candidate) => candidate.id === id);
+    if (!node) throw new Error(`Unknown graph node: ${id}`);
+    const edges = memory.listGraphEdges().filter(({ fromNodeId, toNodeId }) => fromNodeId === id || toNodeId === id);
+    return this.batch(session, [{
+      ref: `graph-node:${node.id}:expanded`,
+      target: { eventIds: [.../* @__PURE__ */ new Set([...node.sourceEventIds, ...edges.flatMap(({ sourceEventIds }) => sourceEventIds)])], elementIds: [] }
+    }], { node, edges });
+  }
+  scheduleGraphMigration(session, memory) {
+    const namespace = this.namespaceFor(session);
+    if (this.closed || this.migrationTimers.has(namespace)) return;
+    if (typeof memory.listGraphProjectionJobs !== "function") return;
+    const pending = memory.listGraphProjectionJobs().some(({ status }) => status === "pending" || status === "failed");
+    if (!pending) return;
+    const timer = setTimeout(() => {
+      this.migrationTimers.delete(namespace);
+      if (this.closed) return;
+      const completedBefore = memory.listGraphProjectionJobs().filter(({ status }) => status === "completed").length;
+      void this.models.run(session, () => memory.resumePendingWork()).then(async () => {
+        await this.persistSuccessfulResponses(memory);
+        const completedAfter = memory.listGraphProjectionJobs().filter(({ status }) => status === "completed").length;
+        if (completedAfter > completedBefore) this.scheduleGraphMigration(session, memory);
+      }).catch((error) => {
+        this.onIngestError(error);
+      });
+    }, 1500);
+    timer.unref?.();
+    this.migrationTimers.set(namespace, timer);
+  }
   rememberWorkspace(namespace, cwd) {
     const name2 = workspaceDisplayName(cwd);
     this.workspaceNames.set(namespace, name2);
@@ -3710,12 +4389,75 @@ function renderMessages(messages) {
     return details.join("\n");
   }).join("\n\n");
 }
-function renderBlocks2(blocks) {
-  if (blocks.length === 0) return "(no sealed blocks)";
-  return blocks.map((block) => [
-    `block ${block.id} | turns ${block.turnRange[0]}-${block.turnRange[1]} | age ${block.age} | L${block.level}`,
-    block.content
-  ].join("\n")).join("\n\n");
+function dshTurnAtBlockEnd(session, block) {
+  const blockEnd = Date.parse(block.createdAt);
+  for (let index = session.events.length - 1; index >= 0; index -= 1) {
+    const event = session.events[index];
+    if (event?.type === "turn/end" && event.time === blockEnd) return event.data.turn;
+  }
+  throw new Error(`Cannot match StrataGate block ${block.id} to its completed DSH turn`);
+}
+function sealedSurfaceSeqs(session, endTurn, turnCount) {
+  const currentSurface = [...session.surface.nodes];
+  const currentSet = new Set(currentSurface);
+  const completed = [];
+  let open;
+  for (const event of session.events) {
+    if (event.type === "turn/start") {
+      open = { turn: event.data.turn, start: event.seq };
+      continue;
+    }
+    if (event.type !== "turn/end" || !open || event.data.turn !== open.turn) continue;
+    const turnEvents = session.events.slice(open.start + 1, event.seq);
+    const hasHumanMessage = turnEvents.some((candidate) => candidate.type === "user/message" && candidate.data.source.kind === "user");
+    if (hasHumanMessage && event.data.turn <= endTurn) {
+      completed.push({
+        turn: event.data.turn,
+        start: open.start,
+        end: event.seq,
+        nodes: currentSurface.filter((seq) => seq > open.start && seq < event.seq && currentSet.has(seq))
+      });
+    }
+    open = void 0;
+  }
+  const selected = completed.slice(-turnCount);
+  if (selected.length !== turnCount || selected.at(-1)?.turn !== endTurn) {
+    throw new Error(`Cannot identify ${turnCount} completed DSH turns ending at turn ${endTurn}`);
+  }
+  const emptyTurn = selected.find((turn) => turn.nodes.length === 0);
+  if (emptyTurn) {
+    throw new Error(`Cannot compact DSH turn ${emptyTurn.turn}: its original messages are no longer on the surface`);
+  }
+  const start = selected[0].nodes[0];
+  const end = selected.at(-1).nodes.at(-1);
+  const startIndex = currentSurface.indexOf(start);
+  const endIndex = currentSurface.indexOf(end);
+  if (startIndex < 0 || endIndex < startIndex) {
+    throw new Error(`Cannot identify a contiguous DSH surface range ending at turn ${endTurn}`);
+  }
+  return currentSurface.slice(startIndex, endIndex + 1);
+}
+function renderBlockSurfaceMessage(context) {
+  return [
+    "[StrataGate conversation block]",
+    `Block: ${context.id}`,
+    `Turns: ${context.turnRange[0]}-${context.turnRange[1]}`,
+    `Level: L${context.level} (${context.label})`,
+    "",
+    context.content
+  ].join("\n");
+}
+function currentBlockSurfaceMessages(session) {
+  const blocks = /* @__PURE__ */ new Map();
+  if (!session.surface?.nodes) return blocks;
+  for (const seq of session.surface.nodes) {
+    const event = session.events[seq];
+    if (event?.type !== "user/message" || event.data.source.kind !== "plugin" || event.data.source.plugin !== COMPACTION_SOURCE_PLUGIN) continue;
+    const text3 = event.data.content.flatMap((block) => block.type === "text" ? [block.text] : []).join("\n");
+    const blockId = text3.match(/^\[StrataGate conversation block\]\nBlock: ([^\n]+)/u)?.[1] ?? text3.match(/^\[StrataGate compressed conversation\]\nBlock ([^;\n]+);/u)?.[1];
+    if (blockId) blocks.set(blockId, { seq, text: text3 });
+  }
+  return blocks;
 }
 function activatedEvents(memory, relevance) {
   const allowed = new Map(relevance.map(({ event }) => [event.id, event]));
@@ -3759,7 +4501,7 @@ function activatedElements(memory, relevance) {
     weight
   ]).map(({ item }) => item);
 }
-function renderActivatedMemory(events, elements) {
+function renderActivatedMemory(events, graphNodes) {
   const heading = [
     "[Activated long-term memory]",
     "Historical memory context.",
@@ -3769,7 +4511,7 @@ function renderActivatedMemory(events, elements) {
   const lines = [...heading];
   let tokens = estimateTokens(lines.join("\n"));
   let eventCount = 0;
-  let elementCount = 0;
+  let nodeCount = 0;
   for (const event of events) {
     const rendered = JSON.stringify({
       id: event.id,
@@ -3788,25 +4530,24 @@ Events:
     tokens += cost;
     eventCount += 1;
   }
-  for (const element of elements) {
+  for (const node of graphNodes) {
     const rendered = JSON.stringify({
-      elementId: element.elementId,
-      name: element.name,
-      key: element.fact.key,
-      value: element.fact.value,
-      validFrom: element.fact.validFrom,
-      validTo: element.fact.validTo
+      nodeId: node.id,
+      name: node.name,
+      type: node.type,
+      currentState: node.currentState,
+      facts: node.facts.filter(({ status }) => status === "active").map(({ key, value, validFrom, validTo }) => ({ key, value, validFrom, validTo }))
     });
     const cost = estimateTokens(`
-ElementFacts:
+KnowledgeGraph:
 - ${rendered}`);
     if (tokens + cost > AUTO_MEMORY_TOKEN_BUDGET) break;
-    if (elementCount === 0) lines.push("ElementFacts:");
+    if (nodeCount === 0) lines.push("KnowledgeGraph:");
     lines.push(`- ${rendered}`);
     tokens += cost;
-    elementCount += 1;
+    nodeCount += 1;
   }
-  if (eventCount === 0 && elementCount === 0) lines.push("(no activated memory)");
+  if (eventCount === 0 && nodeCount === 0) lines.push("(no activated memory)");
   return lines.join("\n");
 }
 function estimateTokens(value) {
@@ -3866,9 +4607,26 @@ function registerMemoryTools(ctx, runtime) {
       ...args.participants ? { participants: args.participants } : {}
     })
   }));
+  ctx.tools.register(defineTool({
+    name: "memory_search_graph",
+    description: "Search the current Event-backed Knowledge Graph for people, projects, organizations, tools, places, facts, and relations.",
+    parameters: {
+      query: { type: "string", required: true },
+      limit: { type: "integer", description: "Maximum results, 1-20." }
+    },
+    output: jsonOutput,
+    execute: async (args, exec) => runtime.searchGraph(sessionOf(exec), args.query, args.limit ?? 8)
+  }));
+  ctx.tools.register(defineTool({
+    name: "memory_expand_graph_node",
+    description: "Expand one Knowledge Graph node with its current facts, directed edges, and supporting Event evidence.",
+    parameters: { id: { type: "string", required: true } },
+    output: jsonOutput,
+    execute: async (args, exec) => runtime.expandGraphNode(sessionOf(exec), args.id)
+  }));
   ctx.tools.register(defineTool({
     name: "memory_search_elements",
-    description: "Search current Element-card facts about people, projects, organizations, tools, or places. Returns evidenceRefs that must be assessed before use.",
+    description: "Deprecated compatibility search for legacy Element-card data. Prefer memory_search_graph.",
     parameters: {
       query: { type: "string", required: true },
       limit: { type: "integer" },
@@ -3938,7 +4696,7 @@ function registerMemoryTools(ctx, runtime) {
       missing: { type: "string", required: true },
       next_strategy: {
         type: "string",
-        enum: ["answer", "search_events", "expand_event", "search_elements", "expand_element", "search_raw_memory", "expand_block"],
+        enum: ["answer", "search_events", "expand_event", "search_graph", "expand_graph_node", "search_elements", "expand_element", "search_raw_memory", "expand_block"],
         required: true
       }
     },
@@ -3962,7 +4720,7 @@ function registerMemoryTools(ctx, runtime) {
 
 // src/web.ts
 import { createRequire } from "node:module";
-var STRATAGATE_DSH_VERSION = "0.2.21";
+var STRATAGATE_DSH_VERSION = "0.2.22";
 var LEGACY_THREAD_ID = "__legacy__";
 var nodeRequire = createRequire(import.meta.url);
 function installedPackageVersion(names) {
@@ -3985,8 +4743,8 @@ function numeric(value, fallback, minimum, maximum) {
   const parsed = Number(value);
   return Number.isFinite(parsed) ? Math.min(maximum, Math.max(minimum, Math.floor(parsed))) : fallback;
 }
-function redact(text2) {
-  return text2.replace(/\b(?:sk|gh[opasu]|github_pat)_[A-Za-z0-9_-]{12,}\b/g, "[REDACTED_TOKEN]").replace(/\b(Bearer\s+)[A-Za-z0-9._~+/-]{12,}={0,2}\b/gi, "$1[REDACTED]").replace(/\b(api[_-]?key|token|password|secret)\s*[:=]\s*([^\s,;]+)/gi, "$1=[REDACTED]");
+function redact(text3) {
+  return text3.replace(/\b(?:sk|gh[opasu]|github_pat)_[A-Za-z0-9_-]{12,}\b/g, "[REDACTED_TOKEN]").replace(/\b(Bearer\s+)[A-Za-z0-9._~+/-]{12,}={0,2}\b/gi, "$1[REDACTED]").replace(/\b(api[_-]?key|token|password|secret)\s*[:=]\s*([^\s,;]+)/gi, "$1=[REDACTED]");
 }
 function redactValue(value) {
   if (typeof value === "string") return redact(value);
@@ -4033,6 +4791,7 @@ function eventSummary(event) {
     id: event.id,
     title: event.title,
     summary: event.summary,
+    narrative: event.narrative,
     tags: event.tags,
     sourceBlockId: event.sourceBlockId,
     sourceMessageIds: event.sourceMessageIds,
@@ -4084,8 +4843,8 @@ async function overview(runtime) {
   for (const namespace of namespaces) {
     const snapshot = await runtime.adminSnapshot(namespace);
     if (!snapshot) continue;
-    const failedJobs = snapshot.extractionJobs.filter(({ status }) => status === "failed").length + snapshot.elementProjectionJobs.filter(({ status }) => status === "failed").length;
-    const processingJobs = snapshot.extractionJobs.filter(({ status }) => status === "running").length + snapshot.elementProjectionJobs.filter(({ status }) => status === "pending" || status === "running").length;
+    const failedJobs = snapshot.extractionJobs.filter(({ status }) => status === "failed").length + snapshot.graphProjectionJobs.filter(({ status }) => status === "failed").length;
+    const processingJobs = snapshot.extractionJobs.filter(({ status }) => status === "running").length + snapshot.graphProjectionJobs.filter(({ status }) => status === "pending" || status === "running").length;
     const failedJobDetails = [
       ...snapshot.extractionJobs.filter(({ status }) => status === "failed").map((job) => ({
         id: job.blockId,
@@ -4095,9 +4854,9 @@ async function overview(runtime) {
         lastErrorFull: job.lastError,
         updatedAt: job.updatedAt
       })),
-      ...snapshot.elementProjectionJobs.filter(({ status }) => status === "failed").map((job) => ({
+      ...snapshot.graphProjectionJobs.filter(({ status }) => status === "failed").map((job) => ({
         id: job.id,
-        kind: "element-projection",
+        kind: "graph-projection",
         attempts: job.attempts,
         lastError: job.lastError?.slice(0, 500) ?? null,
         lastErrorFull: job.lastError,
@@ -4108,6 +4867,7 @@ async function overview(runtime) {
       ...snapshot.blocks.map(({ createdAt }) => createdAt),
       ...snapshot.events.map(({ updatedAt }) => updatedAt),
       ...snapshot.elements.map(({ updatedAt }) => updatedAt),
+      ...snapshot.graphNodes.map(({ updatedAt }) => updatedAt),
       ...snapshot.usageReceipts.map(({ createdAt }) => createdAt)
     ].sort();
     rows.push({
@@ -4122,6 +4882,15 @@ async function overview(runtime) {
       events: snapshot.events.length,
       activeEvents: snapshot.events.filter(({ status }) => status === "active").length,
       elements: snapshot.elements.length,
+      graphNodes: snapshot.graphNodes.length,
+      graphEdges: snapshot.graphEdges.length,
+      graphMigration: (() => {
+        const projected = new Set(snapshot.graphProjectionJobs.filter(({ status, projectorVersion }) => status === "completed" && projectorVersion === KNOWLEDGE_GRAPH_PROJECTOR_VERSION).flatMap(({ sourceEventIds }) => sourceEventIds)).size;
+        const failed = snapshot.graphProjectionJobs.filter(({ status }) => status === "failed").length;
+        const running = snapshot.graphProjectionJobs.filter(({ status }) => status === "running").length;
+        const total = snapshot.events.filter(({ status }) => status !== "forgotten" && status !== "archived").length;
+        return { projected, total, failed, running, complete: projected >= total };
+      })(),
       usageReceipts: snapshot.usageReceipts.length,
       memoryUseCount: snapshot.usageReceipts.filter((receipt) => receipt.eventIds.length > 0 || receipt.elementIds.length > 0).length,
       failedJobs,
@@ -4276,11 +5045,38 @@ async function memories(runtime, url) {
   const offset = numeric(url.searchParams.get("offset"), 0, 0, Number.MAX_SAFE_INTEGER);
   const limit = numeric(url.searchParams.get("limit"), 100, 1, 200);
   let values;
-  if (kind === "events") values = snapshot.events.map((event) => ({
+  if (kind === "events") values = [...snapshot.events].sort((left, right) => {
+    const time = (event) => event.temporal.happenedStart ?? event.temporal.happenedEnd ?? event.temporal.mentionedAt ?? event.createdAt;
+    return time(right).localeCompare(time(left));
+  }).map((event) => ({
     ...eventSummary(event),
+    relatedNodes: snapshot.graphNodes.filter(({ id, sourceEventIds }) => sourceEventIds.includes(event.id) || (event.temporal.participantNodeIds ?? []).includes(id)).map(({ id, name: name2, type }) => ({ id, name: name2, type })),
     relatedElements: snapshot.elements.filter(({ sourceEventIds }) => sourceEventIds.includes(event.id)).map(({ id, name: name2 }) => ({ id, name: name2 }))
   }));
-  else if (kind === "elements") values = snapshot.elements.map(elementSummary);
+  else if (kind === "graph") {
+    const eventMap = new Map(snapshot.events.map((event) => [event.id, event]));
+    return {
+      namespace,
+      kind,
+      projectorVersion: KNOWLEDGE_GRAPH_PROJECTOR_VERSION,
+      nodes: snapshot.graphNodes.map((node) => ({
+        ...node,
+        supportingEvents: node.sourceEventIds.flatMap((id) => eventMap.get(id) ?? []).map(eventSummary)
+      })),
+      edges: snapshot.graphEdges,
+      migration: (() => {
+        const projected = new Set(snapshot.graphProjectionJobs.filter(({ status, projectorVersion }) => status === "completed" && projectorVersion === KNOWLEDGE_GRAPH_PROJECTOR_VERSION).flatMap(({ sourceEventIds }) => sourceEventIds)).size;
+        return {
+          projected,
+          total: snapshot.events.filter(({ status }) => status !== "forgotten" && status !== "archived").length,
+          pending: snapshot.graphProjectionJobs.filter(({ status }) => status === "pending").length,
+          running: snapshot.graphProjectionJobs.filter(({ status }) => status === "running").length,
+          failed: snapshot.graphProjectionJobs.filter(({ status }) => status === "failed").length,
+          complete: projected >= snapshot.events.filter(({ status }) => status !== "forgotten" && status !== "archived").length
+        };
+      })()
+    };
+  } else if (kind === "elements") values = snapshot.elements.map(elementSummary);
   else if (kind === "blocks") {
     const recovered = recoverSnapshotView(snapshot);
     const conversations = conversationRows(snapshot, recovered);
@@ -4293,8 +5089,8 @@ async function memories(runtime, url) {
       const blockMessageIds = new Set(block.messages.map(({ id }) => id));
       const relatedEvents = snapshot.events.filter((event) => event.sourceBlockId === source.id && (!block.virtual || event.sourceMessageIds.some((id) => blockMessageIds.has(id))));
       const eventIds = new Set(relatedEvents.map(({ id }) => id));
-      const projections = snapshot.elementProjectionJobs.filter(({ sourceEventIds }) => sourceEventIds.some((id) => eventIds.has(id)));
-      const relatedElements = snapshot.elements.filter(({ sourceEventIds }) => sourceEventIds.some((id) => eventIds.has(id))).map(({ id, name: name2 }) => ({ id, name: name2 }));
+      const projections = snapshot.graphProjectionJobs.filter(({ sourceEventIds }) => sourceEventIds.some((id) => eventIds.has(id)));
+      const relatedNodes = snapshot.graphNodes.filter(({ sourceEventIds }) => sourceEventIds.some((id) => eventIds.has(id))).map(({ id, name: name2, type }) => ({ id, name: name2, type }));
       const failedProjection = projections.find(({ status: status2 }) => status2 === "failed");
       const pendingProjection = projections.some(({ status: status2 }) => status2 === "pending" || status2 === "running");
       const needsExtraction = source.shouldExtract === true;
@@ -4331,13 +5127,13 @@ async function memories(runtime, url) {
           updatedAt: extraction.updatedAt,
           lastError: extraction.lastError
         } : null,
-        elementProjection: projections.length ? {
+        graphProjection: projections.length ? {
           status: failedProjection ? "failed" : pendingProjection ? "processing" : "completed",
           jobs: projections.length,
           lastError: failedProjection?.lastError ?? null
         } : null,
         relatedEvents: relatedEvents.map(eventSummary),
-        relatedElements
+        relatedNodes
       };
     });
     const filtered2 = values.filter((value) => matchesQuery(value, query));
@@ -4368,6 +5164,7 @@ async function sources(runtime, url) {
   if (!namespace) throw new AdminHttpError(400, "namespace is required");
   const snapshot = await requiredSnapshot(runtime, namespace);
   const eventId = url.searchParams.get("eventId");
+  const nodeId = url.searchParams.get("nodeId");
   const elementId = url.searchParams.get("elementId");
   const blockId = url.searchParams.get("blockId");
   let events = [];
@@ -4378,6 +5175,18 @@ async function sources(runtime, url) {
     if (!event) throw new AdminHttpError(404, `Unknown event: ${eventId}`);
     events = [event];
     ids = new Set(event.sourceMessageIds);
+  } else if (nodeId) {
+    const node = snapshot.graphNodes.find(({ id }) => id === nodeId);
+    if (!node) throw new AdminHttpError(404, `Unknown graph node: ${nodeId}`);
+    events = snapshot.events.filter(({ id }) => node.sourceEventIds.includes(id));
+    ids = new Set(events.flatMap(({ sourceMessageIds }) => sourceMessageIds));
+    return {
+      namespace,
+      node,
+      edges: snapshot.graphEdges.filter(({ fromNodeId, toNodeId }) => fromNodeId === node.id || toNodeId === node.id),
+      events: events.map(eventSummary),
+      messages: sourceMessages(snapshot, ids)
+    };
   } else if (elementId) {
     const element = snapshot.elements.find(({ id }) => id === elementId);
     if (!element) throw new AdminHttpError(404, `Unknown element: ${elementId}`);
@@ -4402,12 +5211,13 @@ async function sources(runtime, url) {
       virtual: displayBlock?.virtual ?? false
     };
   } else {
-    throw new AdminHttpError(400, "eventId, elementId, or blockId is required");
+    throw new AdminHttpError(400, "eventId, nodeId, elementId, or blockId is required");
   }
   return {
     namespace,
     events: events.map(eventSummary),
     elements: elements.map(elementSummary),
+    blocks: events.map((event) => snapshot.blocks.find(({ id }) => id === event.sourceBlockId)).filter((block) => Boolean(block)).map((block) => ({ id: block.id, title: block.l0Title, createdAt: block.createdAt })),
     messages: sourceMessages(snapshot, ids)
   };
 }
@@ -4488,7 +5298,7 @@ var MEMORY_PROTOCOL = `[StrataGate memory protocol]
 StrataGate provides durable, evidence-gated memory through memory_* tools.
 
 - Search memory when the current task could depend on prior project decisions, user preferences, people, tools, historical outcomes, or unresolved work. Do not search for facts already established in the current conversation.
-- Start with memory_search_events for decisions and history, or memory_search_elements for the current state of a person/project/tool/place/organization.
+- Start with memory_search_events for decisions and history, or memory_search_graph for the current state of a person/project/tool/place/organization.
 - Every retrieval replaces the latest batch. Call memory_assess after each batch before relying on it. Cite only evidenceRefs returned by that exact latest batch.
 - If assessment is partial or wrong, follow nextStrategy: refine the search, expand an Element/block, or search raw memory. Do not present uncertain memory as fact.
 - Every retrieval batch must be closed with memory_record_use before the turn can end. Pass evidence_refs containing exactly the refs actually used, or [] when no retrieved evidence was used. Non-empty refs require a sufficient assessment of that latest batch. Never use a numeric increment; StrataGate applies one reinforcement per selected card.
@@ -4502,6 +5312,8 @@ async function apply(ctx, config) {
   const models = new DshModelBridge(ctx, resolved);
   const runtime = new StrataGateRuntime(resolved, models, (error) => {
     ctx.logger.error(`stratagate-memory ingestion failed: ${renderError(error)}`);
+  }, async (session) => {
+    await ctx.sessions.flush(session);
   });
   await runtime.syncConfiguredSettings();
   ctx.systemPrompt.section({ name: "tool:stratagate-memory", order: 113, text: MEMORY_PROTOCOL });
@@ -4510,10 +5322,10 @@ async function apply(ctx, config) {
     const session = context.agent?.session;
     if (!session) return assembled;
     try {
-      const text2 = await runtime.buildAutoContext(session);
+      const text3 = await runtime.buildAutoContext(session);
       return {
         ...assembled,
-        contexts: [...assembled.contexts, { name: "stratagate:auto-memory", text: text2 }]
+        contexts: [...assembled.contexts, { name: "stratagate:auto-memory", text: text3 }]
       };
     } catch (error) {
       ctx.logger.warn(`stratagate-memory auto-context failed: ${renderError(error)}`);
@@ -4522,7 +5334,7 @@ async function apply(ctx, config) {
   });
   ctx.on("agent/turn-stopping", ({ agent }) => {
     if (!runtime.needsRecordUse(agent.session)) return;
-    agent.steer(createUserMessage2({
+    agent.steer(createUserMessage3({
       content: [{
         type: "text",
         text: "A StrataGate retrieval batch is still unresolved. Before ending this turn, call memory_record_use with evidence_refs set to exactly the retrieved refs used in the answer, or [] if none were used."