stratagate-dsh 0.2.69 → 0.2.71

package/dist/plugin.js

@@ -1314,8 +1314,9 @@ 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 {
   constructor(namespace, expectedRevision, actualRevision) {
     super(`Storage revision conflict for ${namespace}: expected ${expectedRevision}, found ${actualRevision ?? "missing"}`);
@@ -1448,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 {
@@ -1467,8 +1473,19 @@ function normalizeSnapshot(value) {
     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 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") {
@@ -1715,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,
@@ -2020,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) };
@@ -2192,8 +2211,7 @@ var SqliteStorage = class {
       externalMemoryImportJobs,
       successfulModelResponses
     };
-    assertValidSnapshot(snapshot);
-    return { snapshot: cloneSnapshot(snapshot), revision: space.revision };
+    return { snapshot: cloneSnapshot(normalizeSnapshot(snapshot)), revision: space.revision };
   }
   async save(namespace, snapshot, expectedRevision) {
     this.assertOpen();
@@ -2331,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,
@@ -2343,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,
@@ -2373,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,
@@ -2641,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");
@@ -2734,7 +2771,6 @@ var EXTERNAL_MEMORY_AUTO_APPLY_CONFIDENCE = 0.85;
 function externalMemoryFingerprint(value) {
   return `${normalizeSearchText(value.title)}\0${normalizeSearchText(value.summary)}`;
 }
-var DERIVATION_MAX_ATTEMPTS = 3;
 var DERIVATION_BACKOFF_MS = 1e3;
 var StrataGate = class _StrataGate {
   blockTurnSizeValue;
@@ -2919,6 +2955,7 @@ var StrataGate = class _StrataGate {
               ...job,
               status: "failed",
               lastError: "Graph projection was interrupted before completion.",
+              nextRetryAt: memory.retryAt(job.attempts),
               updatedAt: now
             });
           }
@@ -3077,6 +3114,7 @@ var StrataGate = class _StrataGate {
         job.status = "pending";
         job.attempts = 0;
         job.lastError = null;
+        job.nextRetryAt = null;
         job.updatedAt = toUtc8Iso(this.now());
       });
       const batch = await this.claimGraphProjection(jobId);
@@ -3675,7 +3713,7 @@ var StrataGate = class _StrataGate {
   }
   async claimNextElementProjection() {
     return this.commitMutation(() => {
-      const job = [...this.elementProjectionJobs.values()].find((candidate) => candidate.status === "pending" || candidate.status === "failed");
+      const job = [...this.elementProjectionJobs.values()].filter((candidate) => candidate.attempts < DERIVATION_MAX_ATTEMPTS && (candidate.status === "pending" || candidate.status === "failed")).sort((left, right) => Number(left.status !== "pending") - Number(right.status !== "pending") || 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) {
@@ -3729,7 +3767,8 @@ var StrataGate = class _StrataGate {
   }
   async claimGraphProjection(jobId) {
     return this.commitMutation(() => {
-      const job = [...this.graphProjectionJobs.values()].filter((candidate) => (jobId === void 0 || candidate.id === jobId) && (candidate.status === "pending" || candidate.status === "failed")).sort((left, right) => right.priority - left.priority || left.createdAt.localeCompare(right.createdAt))[0];
+      const now = this.now().getTime();
+      const job = [...this.graphProjectionJobs.values()].filter((candidate) => (jobId === void 0 || candidate.id === jobId) && candidate.attempts < DERIVATION_MAX_ATTEMPTS && (candidate.status === "pending" || candidate.status === "failed" && candidate.nextRetryAt !== null && Date.parse(candidate.nextRetryAt) <= now)).sort((left, right) => Number(left.status !== "pending") - Number(right.status !== "pending") || 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`);
@@ -3744,14 +3783,14 @@ var StrataGate = class _StrataGate {
         (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 existingNodes = [...new Map(relevantNodes.map((node) => [node.id, node])).values()].slice(0, 32);
       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))
+        existingEdges: structuredClone(this.graphEdges.filter(({ fromNodeId, toNodeId }) => nodeIds.has(fromNodeId) && nodeIds.has(toNodeId)).slice(-60))
       };
     });
   }
@@ -3777,6 +3816,7 @@ var StrataGate = class _StrataGate {
       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.nextRetryAt = null;
       job.updatedAt = toUtc8Iso(this.now());
       return touched;
     });
@@ -3787,6 +3827,7 @@ var StrataGate = class _StrataGate {
       if (job.status === "completed") return;
       job.status = "failed";
       job.lastError = errorMessage(error);
+      job.nextRetryAt = this.retryAt(job.attempts);
       job.updatedAt = toUtc8Iso(this.now());
     });
   }
@@ -4052,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(),
@@ -4072,7 +4115,7 @@ var StrataGate = class _StrataGate {
       supersededBy: null,
       weight: {
         mentionCount: 1,
-        lastAdoptedTurn: this.currentTurn,
+        lastAdoptedTurn: formedTurn,
         lastRetrievedAt: null,
         pinned: false,
         floorWeight: criticalityFloor(criticality),
@@ -4169,6 +4212,7 @@ var StrataGate = class _StrataGate {
       edgeIds: [],
       reason: null,
       lastError: null,
+      nextRetryAt: null,
       createdAt: now,
       updatedAt: now
     };
@@ -4991,6 +5035,48 @@ function renderBlocksForDiagnostics(blocks, finish) {
   const rendered = blocks.map(renderBlockForDiagnostics).join("\n\n");
   return rendered || `[no model blocks; finish=${finish}]`;
 }
+function compactGraphProjectionContext(context) {
+  const compactValue = (value) => Array.isArray(value) ? value.slice(0, 12).map((entry) => entry.slice(0, 160)) : value.slice(0, 400);
+  return {
+    jobId: context.jobId,
+    projectorVersion: context.projectorVersion,
+    events: context.events.map((event) => ({
+      id: event.id,
+      title: event.title,
+      summary: event.summary,
+      narrative: event.narrative,
+      tags: event.tags,
+      quotes: event.quotes,
+      temporal: event.temporal,
+      scope: event.scope,
+      criticality: event.criticality,
+      status: event.status
+    })),
+    existingNodes: context.existingNodes.slice(0, 32).map((node) => ({
+      id: node.id,
+      name: node.name,
+      type: node.type,
+      aliases: node.aliases.slice(0, 12),
+      tags: node.tags?.slice(0, 12),
+      currentState: node.currentState.slice(0, 600),
+      facts: node.facts.filter(({ status }) => status === "active" || status === "disputed").slice(-12).map((fact) => ({
+        key: fact.key,
+        value: compactValue(fact.value),
+        status: fact.status,
+        sourceEventIds: fact.sourceEventIds.slice(-16)
+      })),
+      status: node.status,
+      sourceEventIds: node.sourceEventIds.slice(-16)
+    })),
+    existingEdges: context.existingEdges.slice(-60).map((edge) => ({
+      fromNodeId: edge.fromNodeId,
+      toNodeId: edge.toNodeId,
+      relation: edge.relation,
+      status: edge.status,
+      sourceEventIds: edge.sourceEventIds.slice(-16)
+    }))
+  };
+}
 var DshModelBridge = class {
   constructor(ctx, config) {
     this.ctx = ctx;
@@ -5104,8 +5190,8 @@ var DshModelBridge = class {
     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. Give every returned node 1-6 concise semantic role tags such as benchmark, evaluation, memory-plugin, parser, or development-tool; tags describe the node's specific role and never replace its person/project/organization/tool/place type. Reuse stable tag wording when possible. 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
+      `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 only nodes and edges touched by the supplied Events; never echo unchanged historical graph records. Return at most 24 nodes and 32 edges. Use stable entity nodes for people, projects, organizations, tools, and places. Use aliases to merge spelling/case/separator variants. Give every returned node 1-6 concise semantic role tags such as benchmark, evaluation, memory-plugin, parser, or development-tool; tags describe the node's specific role and never replace its person/project/organization/tool/place type. Reuse stable tag wording when possible. 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.`,
+      compactGraphProjectionContext(context)
     ));
     const nodes = (Array.isArray(raw.nodes) ? raw.nodes : []).flatMap((candidate) => {
       const item = object(candidate);
@@ -5134,7 +5220,7 @@ var DshModelBridge = class {
         ...typeof item.confidence === "number" ? { confidence: item.confidence } : {},
         sourceEventIds
       }];
-    });
+    }).slice(0, 24);
     const refs = new Set(nodes.map(({ ref }) => ref));
     const edges = (Array.isArray(raw.edges) ? raw.edges : []).flatMap((candidate) => {
       const item = object(candidate);
@@ -5153,7 +5239,7 @@ var DshModelBridge = class {
         ...typeof item.confidence === "number" ? { confidence: item.confidence } : {},
         sourceEventIds
       }];
-    });
+    }).slice(0, 32);
     return { reason: text2(raw.reason, "Projected Event evidence into the Knowledge Graph."), nodes, edges };
   };
   externalMemoryDecider = async (context) => {
@@ -5197,7 +5283,9 @@ var DshModelBridge = class {
     let useOff = await this.shouldUseOff(baseRoute);
     let lastError;
     let lastResponse = "";
+    let attemptsUsed = 0;
     for (let attempt = 1; attempt <= JSON_RESPONSE_ATTEMPTS; attempt += 1) {
+      attemptsUsed = attempt;
       const message = createUserMessage({
         content: [{ type: "text", text: JSON.stringify(payload) }],
         source: { kind: "plugin", plugin: "stratagate-memory" }
@@ -5306,13 +5394,14 @@ ${JSON_RETRY_INSTRUCTION}`,
           `StrataGate ${STRUCTURED_TOOLS[kind].name} call was truncated before valid arguments`,
           { cause: error, response: responseForError }
         ) : error;
+        if (kind === "graphProjector" && finish.kind === "max-tokens") break;
         if (attempt < JSON_RESPONSE_ATTEMPTS) {
           this.ctx.logger.warn(`stratagate-memory model returned an invalid structured tool call; retrying (${attempt}/${JSON_RESPONSE_ATTEMPTS})`);
         }
       }
     }
     throw new ModelJsonResponseError(
-      `StrataGate model did not produce a valid ${STRUCTURED_TOOLS[kind].name} call after ${JSON_RESPONSE_ATTEMPTS} attempts`,
+      `StrataGate model did not produce a valid ${STRUCTURED_TOOLS[kind].name} call after ${attemptsUsed} attempt${attemptsUsed === 1 ? "" : "s"}`,
       { cause: lastError, response: lastResponse }
     );
   }
@@ -5715,6 +5804,9 @@ var DRAIN_BASE_BACKOFF_MS = 2e3;
 var DRAIN_MAX_BACKOFF_MS = 6e4;
 var BACKGROUND_WORKER_INITIAL_DELAY_MS = 250;
 var BACKGROUND_WORKER_INTERVAL_MS = 3e3;
+function graphProjectionCanRun(job, now = Date.now()) {
+  return job.attempts < DERIVATION_MAX_ATTEMPTS && (job.status === "pending" || job.status === "failed" && job.nextRetryAt != null && Date.parse(job.nextRetryAt) <= now);
+}
 var AUTO_EVENT_LIMIT = 4;
 var AUTO_ELEMENT_LIMIT = 4;
 var AUTO_MEMORY_TOKEN_BUDGET = 900;
@@ -5849,7 +5941,7 @@ var StrataGateRuntime = class {
         const runnable = [
           ...memory.listSummaryJobs(),
           ...memory.listExtractionJobs()
-        ].some((job) => job.status === "pending" || job.status === "failed" && job.nextRetryAt !== null && Date.parse(job.nextRetryAt) <= Date.now()) || memory.listGraphProjectionJobs().some(({ status }) => status === "pending");
+        ].some((job) => job.status === "pending" || job.status === "failed" && job.nextRetryAt !== null && Date.parse(job.nextRetryAt) <= Date.now()) || memory.listGraphProjectionJobs().some((job) => graphProjectionCanRun(job));
         if (!runnable) return;
         const hasActiveSessionWork = [
           ...this.derivationTimers.keys(),
@@ -7127,7 +7219,7 @@ var StrataGateRuntime = class {
     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");
+    const pending = memory.listGraphProjectionJobs().some((job) => graphProjectionCanRun(job));
     if (!pending) return;
     const timer = setTimeout(() => {
       this.migrationTimers.delete(namespace);
@@ -7833,6 +7925,10 @@ function currentPluginVersion() {
   return "unknown";
 }
 var STRATAGATE_DSH_VERSION = currentPluginVersion();
+function graphProjectionIsProcessing(job) {
+  if (job.status === "running") return true;
+  return job.attempts < DERIVATION_MAX_ATTEMPTS && (job.status === "pending" || job.status === "failed" && job.nextRetryAt !== null);
+}
 function installedPackageVersion(names) {
   for (const name2 of names) {
     try {
@@ -7923,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" });
   }
@@ -7931,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,
@@ -8100,7 +8248,7 @@ async function overview(runtime, cachedEntries) {
         kind: "graph-projection",
         status: job.status,
         attempts: job.attempts,
-        nextRetryAt: null,
+        nextRetryAt: job.nextRetryAt,
         lastError: job.lastError?.slice(0, 500) ?? null,
         lastErrorFull: job.lastError,
         updatedAt: job.updatedAt,
@@ -8112,7 +8260,7 @@ async function overview(runtime, cachedEntries) {
       };
     };
     const failedJobs = snapshot.summaryJobs.filter(({ status }) => status === "failed").length + snapshot.extractionJobs.filter(({ status }) => status === "failed").length + snapshot.graphProjectionJobs.filter(({ status }) => status === "failed").length;
-    const processingJobs = snapshot.summaryJobs.filter(({ status, nextRetryAt }) => status === "pending" || status === "running" || status === "failed" && nextRetryAt !== null).length + snapshot.extractionJobs.filter(({ status, nextRetryAt }) => status === "running" || status === "failed" && nextRetryAt !== null).length + snapshot.graphProjectionJobs.filter(({ status }) => status === "pending" || status === "running").length;
+    const processingJobs = snapshot.summaryJobs.filter(({ status, nextRetryAt }) => status === "pending" || status === "running" || status === "failed" && nextRetryAt !== null).length + snapshot.extractionJobs.filter(({ status, nextRetryAt }) => status === "running" || status === "failed" && nextRetryAt !== null).length + snapshot.graphProjectionJobs.filter(graphProjectionIsProcessing).length;
     const failedJobDetails = [
       ...snapshot.summaryJobs.filter(({ status }) => status === "failed").map((job) => describeBlockJob("block-summary", job)),
       ...snapshot.extractionJobs.filter(({ status }) => status === "failed").map((job) => describeBlockJob("event-extraction", job)),
@@ -8121,7 +8269,7 @@ async function overview(runtime, cachedEntries) {
     const processingJobDetails = [
       ...snapshot.summaryJobs.filter(({ status, nextRetryAt }) => status === "pending" || status === "running" || status === "failed" && nextRetryAt !== null).map((job) => describeBlockJob("block-summary", job)),
       ...snapshot.extractionJobs.filter(({ status, nextRetryAt }) => status === "running" || status === "failed" && nextRetryAt !== null).map((job) => describeBlockJob("event-extraction", job)),
-      ...snapshot.graphProjectionJobs.filter(({ status }) => status === "pending" || status === "running").map(describeGraphJob)
+      ...snapshot.graphProjectionJobs.filter(graphProjectionIsProcessing).map(describeGraphJob)
     ];
     const timestamps = [
       ...snapshot.blocks.map(({ createdAt }) => createdAt),
@@ -8454,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") {
@@ -8645,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)