stratagate-dsh 0.2.70 → 0.2.72

package/dist/plugin.js

@@ -1314,7 +1314,7 @@ function normalizeRetrievalAssessment(input, batchEvidenceRefs) {
 }
 
 // packages/core/src/storage.ts
-var STRATAGATE_STORAGE_SCHEMA_VERSION = 10;
+var STRATAGATE_STORAGE_SCHEMA_VERSION = 11;
 var KNOWLEDGE_GRAPH_PROJECTOR_VERSION = 1;
 var DERIVATION_MAX_ATTEMPTS = 3;
 var StorageConflictError = class extends Error {
@@ -1449,6 +1449,11 @@ function normalizeSnapshot(value) {
       schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
       externalMemoryImportJobs: []
     };
+  } else if (schemaVersion === 10) {
+    snapshot = {
+      ...structuredClone(value),
+      schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION
+    };
   } else if (schemaVersion === STRATAGATE_STORAGE_SCHEMA_VERSION) {
     snapshot = structuredClone(value);
   } else {
@@ -1471,8 +1476,16 @@ function normalizeSnapshot(value) {
   for (const job of snapshot.graphProjectionJobs) {
     if (job.nextRetryAt === void 0) job.nextRetryAt = null;
   }
+  const sourceBlockMap = new Map(snapshot.blocks.map((block) => [block.id, block]));
   for (const event of snapshot.events) {
     event.temporal = { ...event.temporal, eventType: normalizeStandardEventType(event.temporal.eventType) };
+    if (event.formedTurn === void 0) {
+      const sourceBlock = sourceBlockMap.get(event.sourceBlockId);
+      const reliableSource = sourceBlock && !sourceBlock.threadId?.startsWith("external-import:") && Number.isSafeInteger(sourceBlock.endTurn) && sourceBlock.endTurn >= 0;
+      if (reliableSource) event.formedTurn = sourceBlock.endTurn;
+    } else if (!Number.isSafeInteger(event.formedTurn) || event.formedTurn < 0) {
+      throw new TypeError("Invalid StrataGate snapshot: Event formedTurn must be a non-negative integer");
+    }
   }
   for (const block of snapshot.blocks) {
     if (block.processingStatus !== "pending" && block.processingStatus !== "ready") {
@@ -1719,6 +1732,7 @@ CREATE TABLE IF NOT EXISTS events (
   tags_json TEXT NOT NULL,
   quotes_json TEXT NOT NULL,
   source_block_id TEXT NOT NULL,
+  formed_turn INTEGER,
   temporal_json TEXT NOT NULL,
   scope TEXT NOT NULL,
   criticality TEXT NOT NULL,
@@ -2024,6 +2038,7 @@ var SqliteStorage = class {
       quotes: parseJson(row.quotes_json, "events.quotes_json"),
       sourceMessageIds: sourcesByEvent.get(row.id) ?? [],
       sourceBlockId: row.source_block_id,
+      ...row.formed_turn === null ? {} : { formedTurn: row.formed_turn },
       temporal: (() => {
         const temporal = parseJson(row.temporal_json, "events.temporal_json");
         return { ...temporal, eventType: normalizeStandardEventType(temporal.eventType) };
@@ -2334,10 +2349,10 @@ var SqliteStorage = class {
     const insertEvent = this.database.prepare(`
       INSERT INTO events (
         namespace, id, position, title, summary, narrative, tags_json, quotes_json, source_block_id,
-        temporal_json, scope, criticality, confidence, status, superseded_by,
+        formed_turn, temporal_json, scope, criticality, confidence, status, superseded_by,
         mention_count, last_adopted_turn, last_retrieved_at, pinned, floor_weight, forced_cap,
         created_at, updated_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT (namespace, id) DO UPDATE SET
         position = excluded.position,
         title = excluded.title,
@@ -2346,6 +2361,7 @@ var SqliteStorage = class {
         tags_json = excluded.tags_json,
         quotes_json = excluded.quotes_json,
         source_block_id = excluded.source_block_id,
+        formed_turn = excluded.formed_turn,
         temporal_json = excluded.temporal_json,
         scope = excluded.scope,
         criticality = excluded.criticality,
@@ -2376,6 +2392,7 @@ var SqliteStorage = class {
         JSON.stringify(event.tags),
         JSON.stringify(event.quotes),
         event.sourceBlockId,
+        event.formedTurn ?? null,
         JSON.stringify(event.temporal),
         event.scope,
         event.criticality,
@@ -2644,6 +2661,23 @@ var SqliteStorage = class {
         if (!blockColumns.some(({ name: name2 }) => name2 === "processing_status")) {
           this.database.exec("ALTER TABLE blocks ADD COLUMN processing_status TEXT NOT NULL DEFAULT 'ready' CHECK (processing_status IN ('pending', 'ready'))");
         }
+        const eventColumns = this.database.prepare("PRAGMA table_info('events')").all();
+        if (!eventColumns.some(({ name: name2 }) => name2 === "formed_turn")) {
+          this.database.exec("ALTER TABLE events ADD COLUMN formed_turn INTEGER");
+        }
+        this.database.exec(`
+          UPDATE events
+          SET formed_turn = (
+            SELECT blocks.end_turn FROM blocks
+            WHERE blocks.namespace = events.namespace AND blocks.id = events.source_block_id
+          )
+          WHERE formed_turn IS NULL AND EXISTS (
+            SELECT 1 FROM blocks
+            WHERE blocks.namespace = events.namespace
+              AND blocks.id = events.source_block_id
+              AND (blocks.thread_id IS NULL OR blocks.thread_id NOT LIKE 'external-import:%')
+          )
+        `);
         const extractionColumns = this.database.prepare("PRAGMA table_info('extraction_jobs')").all();
         if (!extractionColumns.some(({ name: name2 }) => name2 === "next_retry_at")) {
           this.database.exec("ALTER TABLE extraction_jobs ADD COLUMN next_retry_at TEXT");
@@ -4059,8 +4093,10 @@ var StrataGate = class _StrataGate {
     const sourceMessageIds = requestedRefs.length > 0 ? requestedRefs : sourceBlock.l5Raw.map((message) => message.id);
     const now = toUtc8Iso(this.now());
     const criticality = input.criticality ?? "routine";
+    const formedTurn = sourceBlock.threadId?.startsWith("external-import:") ? this.currentTurn : sourceBlock.endTurn;
     const event = {
       id: input.id ?? this.idFactory("evt"),
+      formedTurn,
       title: input.title.trim(),
       summary: input.summary.trim(),
       narrative: input.narrative?.trim() || input.summary.trim(),
@@ -4079,7 +4115,7 @@ var StrataGate = class _StrataGate {
       supersededBy: null,
       weight: {
         mentionCount: 1,
-        lastAdoptedTurn: this.currentTurn,
+        lastAdoptedTurn: formedTurn,
         lastRetrievedAt: null,
         pinned: false,
         floorWeight: criticalityFloor(criticality),
@@ -5631,6 +5667,20 @@ var SUPPORTED_RUNTIME_FAMILIES = [
       "@deepseek-ai/dsh-tools": "0.1.5-rc.2",
       "@deepseek-ai/schemastery": "3.18.2"
     }
+  },
+  {
+    cli: "0.1.6-alpha.1",
+    versions: {
+      "@deepseek-ai/cordis": "4.0.2",
+      "@deepseek-ai/dsh-agent-default-model": "0.1.6-alpha.1",
+      "@deepseek-ai/dsh-client-ui-conversation": "0.1.6-alpha.1",
+      "@deepseek-ai/dsh-llm": "0.1.6-alpha.1",
+      "@deepseek-ai/dsh-session": "0.1.6-alpha.1",
+      "@deepseek-ai/dsh-settings": "0.1.6-alpha.1",
+      "@deepseek-ai/dsh-system-prompt": "0.1.6-alpha.1",
+      "@deepseek-ai/dsh-tools": "0.1.6-alpha.1",
+      "@deepseek-ai/schemastery": "3.18.2"
+    }
   }
 ];
 function installedVersion(packageName) {
@@ -5653,7 +5703,7 @@ function classifyDshRuntime(packageVersions) {
   if (family) return { cliVersion: family.cli, packageVersions };
   const found = RUNTIME_PACKAGES.map((name2) => `${name2}@${packageVersions[name2]}`).join(", ");
   throw new Error(
-    `StrataGate cannot start because this DSH profile resolves an unsupported or mixed core runtime. Resolved: ${found}. Supported tested hosts are @deepseek-ai/dsh@0.1.2-rc.1 (internal DSH packages 0.1.2-rc.1) and @deepseek-ai/dsh@0.1.5-rc.1 (its real dependency tree uses internal DSH packages 0.1.5-rc.2). Reinstall or update stratagate-dsh through \`dsh plugin --profile <name> add <package>\` so the host supplies its peers.`
+    `StrataGate cannot start because this DSH profile resolves an unsupported or mixed core runtime. Resolved: ${found}. Supported tested hosts are @deepseek-ai/dsh@0.1.2-rc.1 (internal DSH packages 0.1.2-rc.1) and @deepseek-ai/dsh@0.1.5-rc.1 (its real dependency tree uses internal DSH packages 0.1.5-rc.2), and @deepseek-ai/dsh@0.1.6-alpha.1 (internal DSH packages 0.1.6-alpha.1). Reinstall or update stratagate-dsh through \`dsh plugin --profile <name> add <package>\` so the host supplies its peers.`
   );
 }
 function assertCompatibleDshRuntime() {
@@ -7983,7 +8033,8 @@ function appendWeightSegment(points, event, fromTurn, toTurn, mentionCount) {
   if (toTurn < fromTurn) return;
   if (toTurn === fromTurn) return;
   const span = toTurn - fromTurn;
-  const step = Math.max(1, Math.ceil(span / 32));
+  const samples = Math.min(256, Math.max(12, Math.ceil(span * 12)));
+  const step = span / samples;
   for (let turn = fromTurn; turn < toTurn; turn += step) {
     points.push({ turn, weight: sampledEventWeight(event, turn, fromTurn, mentionCount), kind: "sample" });
   }
@@ -7991,65 +8042,116 @@ function appendWeightSegment(points, event, fromTurn, toTurn, mentionCount) {
 }
 function eventWeightTrajectory(snapshot, event) {
   const currentTurn = snapshot.currentTurn;
+  const formedTurn = Number.isSafeInteger(event.formedTurn) && event.formedTurn >= 0 ? event.formedTurn : null;
+  const sourceBlock = snapshot.blocks.find(({ id }) => id === event.sourceBlockId);
+  const sourceBlockEndTurn = Number.isSafeInteger(sourceBlock?.endTurn) && sourceBlock.endTurn >= 0 ? sourceBlock.endTurn : null;
   const effectiveAdoptions = Math.max(0, event.weight.mentionCount - 1);
   const adoptionReceipts = snapshot.usageReceipts.filter(({ eventIds }) => eventIds.includes(event.id));
   const adoptionTurns = adoptionReceipts.map(({ audit: audit2 }) => audit2?.turn).filter((turn) => Number.isSafeInteger(turn) && turn >= 0).sort((left, right) => left - right);
-  const historyComplete = adoptionReceipts.length === effectiveAdoptions && adoptionTurns.length === adoptionReceipts.length && (effectiveAdoptions === 0 || adoptionTurns.at(-1) === event.weight.lastAdoptedTurn);
+  const confirmedAdoptionTurns = [...adoptionTurns];
+  if (effectiveAdoptions > 0 && Number.isSafeInteger(event.weight.lastAdoptedTurn) && event.weight.lastAdoptedTurn >= 0) {
+    confirmedAdoptionTurns.push(event.weight.lastAdoptedTurn);
+  }
+  confirmedAdoptionTurns.sort((left, right) => left - right);
+  const groupedAdoptions = [...new Set(confirmedAdoptionTurns)].map((turn) => ({
+    turn,
+    adoptionCount: Math.max(1, adoptionTurns.filter((value) => value === turn).length)
+  }));
+  const earliestKnownAdoptionTurn = groupedAdoptions[0]?.turn ?? null;
+  const trajectoryStartTurn = formedTurn ?? sourceBlockEndTurn ?? earliestKnownAdoptionTurn ?? currentTurn;
+  const formationTurnSource = formedTurn !== null ? "formedTurn" : sourceBlockEndTurn !== null ? "sourceBlock" : null;
+  const historyComplete = adoptionReceipts.length === effectiveAdoptions && adoptionTurns.length === adoptionReceipts.length && (effectiveAdoptions === 0 || adoptionTurns.at(-1) === event.weight.lastAdoptedTurn) && adoptionTurns.every((turn) => turn >= trajectoryStartTurn) && (effectiveAdoptions > 0 || event.weight.lastAdoptedTurn === trajectoryStartTurn);
+  const adoptionHistoryComplete = adoptionReceipts.length === effectiveAdoptions && adoptionReceipts.every((receipt) => Boolean(receipt.createdAt) && Number.isFinite(Date.parse(receipt.createdAt)) && Boolean(receipt.audit?.sessionId?.trim()) && Number.isSafeInteger(receipt.audit?.turn) && receipt.audit.turn >= 0) && (formedTurn === null || adoptionReceipts.every((receipt) => receipt.audit.turn >= formedTurn));
+  const adoptionHistory = adoptionReceipts.filter((receipt) => Boolean(receipt.createdAt) && Number.isFinite(Date.parse(receipt.createdAt)) && Boolean(receipt.audit?.sessionId?.trim()) && Number.isSafeInteger(receipt.audit?.turn) && receipt.audit.turn >= 0 && (formedTurn === null || receipt.audit.turn >= formedTurn)).map((receipt) => ({
+    receiptId: receipt.id,
+    createdAt: receipt.createdAt,
+    sessionId: receipt.audit.sessionId,
+    turn: receipt.audit.turn,
+    ...formedTurn === null ? {} : { relativeTurn: receipt.audit.turn - formedTurn },
+    evidenceRefs: receipt.audit?.evidenceRefs ?? []
+  })).sort((left, right) => left.turn - right.turn || left.createdAt.localeCompare(right.createdAt));
   const canInterpolate = event.status !== "forgotten" && event.status !== "archived" && event.weight.forcedCap === null && !event.weight.pinned;
-  const points = [];
-  if (canInterpolate && effectiveAdoptions === 0) {
-    appendWeightSegment(points, event, event.weight.lastAdoptedTurn, currentTurn, 1);
-    if (points.length > 0) {
-      const first = points[0];
-      points[0] = { turn: first.turn, weight: first.weight, kind: "creation", label: "\u521B\u5EFA" };
-    }
-  } else if (canInterpolate && historyComplete && adoptionTurns.length > 0) {
-    let anchorTurn = adoptionTurns[0];
-    let mentionCount = 2;
-    points.push({ turn: anchorTurn, weight: 1, kind: "adoption", label: "\u91C7\u7528" });
-    for (const [index, turn] of adoptionTurns.slice(1).entries()) {
-      appendWeightSegment(points, event, anchorTurn, turn, mentionCount);
-      points.push({ turn, weight: 1, kind: "adoption", label: index === adoptionTurns.length - 2 ? "\u518D\u6B21\u91C7\u7528" : "\u91C7\u7528" });
+  const segments = [];
+  const originPoint = formationTurnSource ? { turn: trajectoryStartTurn, weight: 1, kind: "creation", label: formationTurnSource === "formedTurn" ? "\u5F62\u6210" : "\u6765\u6E90" } : null;
+  if (canInterpolate && historyComplete && originPoint) {
+    const lifecycle = [originPoint];
+    let anchorTurn = trajectoryStartTurn;
+    let mentionCount = 1;
+    for (const { turn, adoptionCount } of groupedAdoptions) {
+      if (turn < trajectoryStartTurn || turn > currentTurn) continue;
+      appendWeightSegment(lifecycle, event, anchorTurn, turn, mentionCount);
+      lifecycle.push({ turn, weight: 1, kind: "adoption", adoptionCount, label: adoptionCount > 1 ? `\u91C7\u7EB3 \xD7${adoptionCount}` : "\u91C7\u7EB3" });
       anchorTurn = turn;
-      mentionCount += 1;
+      mentionCount += adoptionCount;
     }
-    appendWeightSegment(points, event, anchorTurn, currentTurn, mentionCount);
+    appendWeightSegment(lifecycle, event, anchorTurn, currentTurn, mentionCount);
+    segments.push({ certainty: "known", points: lifecycle });
   } else if (canInterpolate) {
-    appendWeightSegment(points, event, event.weight.lastAdoptedTurn, currentTurn, event.weight.mentionCount);
-    if (effectiveAdoptions > 0 && points.length > 0) {
-      const first = points[0];
-      points[0] = { turn: first.turn, weight: first.weight, kind: "adoption", label: "\u6700\u8FD1\u91C7\u7528" };
-    }
+    let anchorPoint = originPoint;
+    let mentionCount = 1;
+    const visibleAdoptions = groupedAdoptions.filter(({ turn }) => turn >= trajectoryStartTurn && turn <= currentTurn);
+    for (const { turn, adoptionCount } of visibleAdoptions) {
+      if (anchorPoint && turn > anchorPoint.turn) {
+        const incomplete = [anchorPoint];
+        appendWeightSegment(incomplete, event, anchorPoint.turn, turn, mentionCount);
+        incomplete.push({ turn, weight: 1, kind: "adoption", adoptionCount, label: adoptionCount > 1 ? `\u91C7\u7EB3 \xD7${adoptionCount}` : "\u91C7\u7EB3" });
+        segments.push({ certainty: "incomplete", points: incomplete });
+      } else {
+        segments.push({ certainty: "known", points: [{ turn, weight: 1, kind: "adoption", adoptionCount, label: adoptionCount > 1 ? `\u91C7\u7EB3 \xD7${adoptionCount}` : "\u91C7\u7EB3" }] });
+      }
+      anchorPoint = { turn, weight: 1, kind: "adoption", adoptionCount, label: adoptionCount > 1 ? `\u91C7\u7EB3 \xD7${adoptionCount}` : "\u91C7\u7EB3" };
+      mentionCount += adoptionCount;
+    }
+    if (anchorPoint && anchorPoint.turn <= currentTurn) {
+      const latestIsReliable = effectiveAdoptions > 0 && anchorPoint.turn === event.weight.lastAdoptedTurn && visibleAdoptions.at(-1)?.turn === event.weight.lastAdoptedTurn;
+      const tail = [anchorPoint];
+      appendWeightSegment(tail, event, anchorPoint.turn, currentTurn, latestIsReliable ? event.weight.mentionCount : mentionCount);
+      if (tail.length > 1) segments.push({ certainty: latestIsReliable ? "known" : "incomplete", points: tail });
+    } else if (originPoint && originPoint.turn <= currentTurn) {
+      const tail = [originPoint];
+      appendWeightSegment(tail, event, originPoint.turn, currentTurn, 1);
+      if (tail.length > 1) segments.push({ certainty: historyComplete ? "known" : "incomplete", points: tail });
+      else segments.push({ certainty: "known", points: [originPoint] });
+    }
+  } else if (originPoint) {
+    segments.push({ certainty: "known", points: [originPoint] });
   }
   const currentWeight = memoryWeightAt(event, currentTurn);
-  if (points.length === 0 || points.at(-1)?.turn !== currentTurn) {
-    points.push({ turn: currentTurn, weight: currentWeight, kind: "current", label: "\u5F53\u524D" });
-  } else if (points.at(-1)?.kind === "creation" || points.at(-1)?.kind === "adoption") {
-    points[points.length - 1] = {
-      ...points[points.length - 1],
-      weight: currentWeight,
-      label: `${points[points.length - 1].label} \xB7 \u5F53\u524D`
-    };
+  const lastSegment = segments.at(-1);
+  if (!lastSegment || lastSegment.points.at(-1)?.turn !== currentTurn) {
+    segments.push({ certainty: "known", points: [{ turn: currentTurn, weight: currentWeight, kind: "current", label: "\u5F53\u524D" }] });
+  } else if (lastSegment.points.at(-1)?.kind === "sample") {
+    lastSegment.points[lastSegment.points.length - 1] = { ...lastSegment.points[lastSegment.points.length - 1], weight: currentWeight, kind: "current", label: "\u5F53\u524D" };
   } else {
-    points[points.length - 1] = { ...points[points.length - 1], weight: currentWeight, kind: "current", label: "\u5F53\u524D" };
+    segments.push({ certainty: "known", points: [{ turn: currentTurn, weight: currentWeight, kind: "current", label: "\u5F53\u524D" }] });
   }
+  const points = segments.flatMap(({ points: segmentPoints }) => segmentPoints);
   return {
     scale: "conversation_turn",
+    formedTurn,
+    trajectoryStartTurn,
+    formationTurnSource,
     currentTurn,
     currentWeight,
     effectiveAdoptions,
+    floorWeight: event.weight.floorWeight,
+    criticality: event.criticality,
     latestAdoptionTurn: effectiveAdoptions > 0 ? event.weight.lastAdoptedTurn : null,
     turnsSinceLatestAdoption: effectiveAdoptions > 0 ? Math.max(0, currentTurn - event.weight.lastAdoptedTurn) : null,
     lastRetrievedAt: event.weight.lastRetrievedAt,
     recordedAdoptionTurns: adoptionTurns,
     historyComplete,
+    adoptionHistoryComplete,
+    adoptionHistory,
+    segments,
     points,
-    note: !canInterpolate ? "\u56FA\u5B9A\u3001\u5C01\u5B58\u6216\u72B6\u6001\u4E0A\u9650\u7684\u53D8\u66F4\u8F6E\u6B21\u6CA1\u6709\u5386\u53F2\u8BB0\u5F55\uFF0C\u56E0\u6B64\u4EC5\u663E\u793A\u5F53\u524D\u771F\u5B9E\u6743\u91CD\u3002" : effectiveAdoptions > 0 && !historyComplete ? "\u90E8\u5206\u65E9\u671F\u91C7\u7528\u8BB0\u5F55\u7F3A\u5C11\u8F6E\u6B21\uFF1B\u66F2\u7EBF\u4EC5\u4ECE\u6700\u8FD1\u4E00\u6B21\u53EF\u786E\u8BA4\u7684\u5F3A\u5316\u5F00\u59CB\u3002" : effectiveAdoptions > 0 ? "\u91C7\u7528\u8F6E\u6B21\u6765\u81EA\u4F7F\u7528\u56DE\u6267\uFF1B\u521B\u5EFA\u8F6E\u6B21\u672A\u5355\u72EC\u4FDD\u5B58\uFF0C\u56E0\u6B64\u4E0D\u63A8\u6D4B\u521B\u5EFA\u8282\u70B9\u3002" : "\u5C1A\u672A\u53D1\u751F\u6709\u6548\u91C7\u7528\uFF1B\u521B\u5EFA\u951A\u70B9\u6765\u81EA Event \u5F53\u524D\u6743\u91CD\u72B6\u6001\u3002"
+    note: !canInterpolate ? "\u56FA\u5B9A\u3001\u5C01\u5B58\u6216\u72B6\u6001\u4E0A\u9650\u7684\u53D8\u66F4\u8F6E\u6B21\u6CA1\u6709\u5386\u53F2\u8BB0\u5F55\uFF0C\u56E0\u6B64\u4EC5\u663E\u793A\u5F53\u524D\u771F\u5B9E\u6743\u91CD\u3002" : !historyComplete ? "\u65E7\u7248\u672C\u672A\u8BB0\u5F55\u90E8\u5206\u91C7\u7EB3\u7684\u5177\u4F53\u8F6E\u6B21\uFF1B\u786E\u5B9A\u8282\u70B9\u4E0E\u533A\u95F4\u7167\u5E38\u663E\u793A\uFF0C\u7F3A\u5931\u533A\u95F4\u4EC5\u4F5C\u8D8B\u52BF\u8FDE\u63A5\u3002" : effectiveAdoptions > 0 ? "\u91C7\u7EB3\u8F6E\u6B21\u6765\u81EA\u771F\u5B9E\u4F7F\u7528\u56DE\u6267\u3002" : "\u5C1A\u672A\u88AB Agent \u91C7\u7EB3\u3002"
   };
 }
 function eventSummary(event, snapshot) {
   return {
     id: event.id,
+    formedTurn: event.formedTurn,
     title: event.title,
     summary: event.summary,
     narrative: event.narrative,
@@ -8509,15 +8611,32 @@ 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].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, snapshot),
-    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 === "graph") {
+  if (kind === "events") {
+    const timeline = url.searchParams.get("timeline") === "true";
+    const timeFilter = url.searchParams.get("time")?.trim() ?? "";
+    const participant = url.searchParams.get("participant")?.trim() ?? "";
+    const eventType = url.searchParams.get("eventType")?.trim() ?? "";
+    const eventStatus = url.searchParams.get("eventStatus")?.trim() ?? "";
+    const now = /* @__PURE__ */ new Date();
+    const weekAgo = now.getTime() - 7 * 864e5;
+    const occurrence = (event) => {
+      const happened = event.temporal.happenedStart ?? event.temporal.happenedEnd;
+      return { value: happened ?? event.temporal.mentionedAt ?? event.createdAt, known: Boolean(happened) };
+    };
+    values = [...snapshot.events].sort((left, right) => occurrence(right).value.localeCompare(occurrence(left).value)).filter((event) => !timeline || event.status !== "forgotten" && event.status !== "archived").filter((event) => !eventType || event.temporal.eventType === eventType).filter((event) => !eventStatus || event.temporal.status === eventStatus).filter((event) => !participant || (event.temporal.participantNodeIds ?? []).includes(participant)).filter((event) => {
+      if (!timeFilter) return true;
+      const info = occurrence(event);
+      if (timeFilter === "unknown") return !info.known;
+      const time = Date.parse(info.value);
+      if (timeFilter === "today") return Number.isFinite(time) && new Date(time).toDateString() === now.toDateString();
+      if (timeFilter === "week") return Number.isFinite(time) && time >= weekAgo;
+      return true;
+    }).map((event) => ({
+      ...eventSummary(event, snapshot),
+      relatedNodes: snapshot.graphNodes.filter(({ id }) => (event.temporal.participantNodeIds ?? []).includes(id)).map(({ id, name: name2, type, aliases }) => ({ id, name: name2, type, aliases })),
+      relatedElements: snapshot.elements.filter(({ sourceEventIds }) => sourceEventIds.includes(event.id)).map(({ id, name: name2 }) => ({ id, name: name2 }))
+    }));
+  } else if (kind === "graph") {
     const eventMap = new Map(snapshot.events.map((event) => [event.id, event]));
     return {
       namespace,
@@ -8705,6 +8824,9 @@ async function sources(runtime, url) {
   return {
     namespace,
     events: events.map((event) => eventSummary(event, eventId ? snapshot : void 0)),
+    ...eventId ? {
+      relatedNodes: snapshot.graphNodes.filter(({ id }) => events[0]?.temporal.participantNodeIds?.includes(id)).map(({ id, name: name2, type, aliases }) => ({ id, name: name2, type, aliases }))
+    } : {},
     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)
@@ -9264,7 +9386,7 @@ async function apply(ctx, config) {
     throw new Error(`StrataGate could not safely migrate legacy citation events: ${detail}`);
   }
   if (legacyMigration.migrated > 0) {
-    ctx.logger.info(`stratagate-memory prepared ${legacyMigration.migrated} legacy Session generation(s) for DSH 0.1.5`);
+    ctx.logger.info(`stratagate-memory prepared ${legacyMigration.migrated} legacy Session generation(s) for DSH ${compatibility.cliVersion}`);
   }
   await mkdir2(dirname3(resolved.database), { recursive: true });
   const models = new DshModelBridge(ctx, resolved);