stratagate-dsh 0.2.70 → 0.2.71

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),
@@ -7983,7 +8019,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 +8028,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,
@@ -8514,7 +8602,7 @@ async function memories(runtime, url) {
     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 })),
+    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") {
@@ -8705,6 +8793,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)