stratagate-dsh 0.2.19 → 0.2.21

package/dist/index.js

@@ -360,7 +360,7 @@ function rrfRank(rankings) {
 }
 
 // ../../src/storage.ts
-var STRATAGATE_STORAGE_SCHEMA_VERSION = 6;
+var STRATAGATE_STORAGE_SCHEMA_VERSION = 7;
 var StorageConflictError = class extends Error {
   constructor(namespace, expectedRevision, actualRevision) {
     super(`Storage revision conflict for ${namespace}: expected ${expectedRevision}, found ${actualRevision ?? "missing"}`);
@@ -380,7 +380,7 @@ function migrateLegacyBlocks(blocks) {
   return blocks.map((block) => {
     const { pointerAnchorTurn, ...current } = block;
     const position = blocks.filter((candidate) => candidate.threadId === block.threadId && candidate.endTurn <= pointerAnchorTurn).length;
-    return { ...current, pointerAnchorBlockPosition: Math.max(1, position) };
+    return { ...current, pointerAnchorBlockPosition: Math.max(1, position), lastLiftedBy: null };
   });
 }
 function normalizeSnapshot(value) {
@@ -432,6 +432,13 @@ function normalizeSnapshot(value) {
       blockDecayLambda: BLOCK_DECAY_LAMBDA,
       blocks: migrateLegacyBlocks(legacy.blocks)
     };
+  } else if (schemaVersion === 6) {
+    const legacy = value;
+    snapshot = {
+      ...structuredClone(legacy),
+      schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
+      blocks: legacy.blocks.map((block) => ({ ...structuredClone(block), lastLiftedBy: null }))
+    };
   } else if (schemaVersion === STRATAGATE_STORAGE_SCHEMA_VERSION) {
     snapshot = structuredClone(value);
   } else {
@@ -454,6 +461,9 @@ function normalizeSnapshot(value) {
     if (!Number.isSafeInteger(block.pointerAnchorBlockPosition) || block.pointerAnchorBlockPosition < 1) {
       throw new TypeError("Invalid StrataGate snapshot: pointerAnchorBlockPosition must be a positive integer");
     }
+    if (block.lastLiftedBy !== null && block.lastLiftedBy !== "user" && block.lastLiftedBy !== "agent") {
+      throw new TypeError("Invalid StrataGate snapshot: lastLiftedBy must be user, agent, or null");
+    }
   }
   if (snapshot.successfulModelResponses.length > 5) {
     snapshot.successfulModelResponses = snapshot.successfulModelResponses.slice(-5);
@@ -652,6 +662,7 @@ CREATE TABLE IF NOT EXISTS blocks (
   pointer_anchor_level INTEGER NOT NULL,
   pointer_anchor_block_position INTEGER NOT NULL,
   last_lifted_at TEXT,
+  last_lifted_by TEXT CHECK (last_lifted_by IS NULL OR last_lifted_by IN ('user', 'agent')),
   PRIMARY KEY (namespace, id),
   UNIQUE (namespace, sequence),
   FOREIGN KEY (namespace) REFERENCES memory_spaces(namespace) ON DELETE CASCADE
@@ -918,7 +929,8 @@ var SqliteStorage = class {
       pointerCurrentLevel: row.pointer_current_level,
       pointerAnchorLevel: row.pointer_anchor_level,
       pointerAnchorBlockPosition: row.pointer_anchor_block_position,
-      lastLiftedAt: row.last_lifted_at
+      lastLiftedAt: row.last_lifted_at,
+      lastLiftedBy: row.last_lifted_by
     }));
     const sourceRows = this.database.prepare(`
       SELECT event_id, message_id, position FROM event_sources
@@ -1154,8 +1166,8 @@ var SqliteStorage = class {
       INSERT INTO blocks (
         namespace, id, thread_id, sequence, start_turn, end_turn, created_at, should_extract,
         l0_title, l0_tags_json, l1_summary, l2_keypoints_json, l3_condensed, l4_readable,
-        pointer_current_level, pointer_anchor_level, pointer_anchor_block_position, last_lifted_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        pointer_current_level, pointer_anchor_level, pointer_anchor_block_position, last_lifted_at, last_lifted_by
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT (namespace, id) DO UPDATE SET
         thread_id = excluded.thread_id,
         sequence = excluded.sequence,
@@ -1172,7 +1184,8 @@ var SqliteStorage = class {
         pointer_current_level = excluded.pointer_current_level,
         pointer_anchor_level = excluded.pointer_anchor_level,
         pointer_anchor_block_position = excluded.pointer_anchor_block_position,
-        last_lifted_at = excluded.last_lifted_at
+        last_lifted_at = excluded.last_lifted_at,
+        last_lifted_by = excluded.last_lifted_by
     `);
     for (const block of snapshot.blocks) {
       insertBlock.run(
@@ -1193,7 +1206,8 @@ var SqliteStorage = class {
         block.pointerCurrentLevel,
         block.pointerAnchorLevel,
         block.pointerAnchorBlockPosition,
-        block.lastLiftedAt
+        block.lastLiftedAt,
+        block.lastLiftedBy
       );
     }
     const insertMessage = this.database.prepare(`
@@ -1462,7 +1476,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) {
+    } else if (version === 1 || version === 2 || version === 3 || version === 4 || version === 5 || version === 6) {
       this.immediateTransaction(() => {
         this.database.exec(SCHEMA);
         if (version === 1) {
@@ -1495,6 +1509,9 @@ var SqliteStorage = class {
             ))
           `);
         }
+        if (!blockColumns.some(({ name: name2 }) => name2 === "last_lifted_by")) {
+          this.database.exec("ALTER TABLE blocks ADD COLUMN last_lifted_by TEXT CHECK (last_lifted_by IS NULL OR last_lifted_by IN ('user', 'agent'))");
+        }
         const messageColumns = this.database.prepare("PRAGMA table_info('messages')").all();
         if (!messageColumns.some(({ name: name2 }) => name2 === "thread_id")) {
           this.database.exec("ALTER TABLE messages ADD COLUMN thread_id TEXT");
@@ -2108,7 +2125,7 @@ var StrataGate = class _StrataGate {
       };
     });
   }
-  async expandBlock(id, target = "next") {
+  async expandBlock(id, target = "next", source = "agent") {
     return this.commitMutation(() => {
       const block = this.blocks.find((candidate) => candidate.id === id);
       if (!block) throw new Error(`Unknown block: ${id}`);
@@ -2125,6 +2142,7 @@ var StrataGate = class _StrataGate {
       block.pointerAnchorLevel = level;
       block.pointerAnchorBlockPosition = latestBlockPosition;
       block.lastLiftedAt = toUtc8Iso(this.now());
+      block.lastLiftedBy = source;
       return {
         id: block.id,
         ...block.threadId ? { threadId: block.threadId } : {},
@@ -2354,7 +2372,8 @@ var StrataGate = class _StrataGate {
         pointerCurrentLevel: 5,
         pointerAnchorLevel: 5,
         pointerAnchorBlockPosition: blockPosition,
-        lastLiftedAt: null
+        lastLiftedAt: null,
+        lastLiftedBy: null
       };
       const sealedIds = new Set(raw.map((message) => message.id));
       const remaining = this.openTail.filter((message) => !sealedIds.has(message.id));
@@ -3302,7 +3321,7 @@ var StrataGateRuntime = class {
   }
   async expandBlock(session, id, target) {
     await this.flush();
-    const result = await (await this.space(session)).expandBlock(id, target);
+    const result = await (await this.space(session)).expandBlock(id, target, "agent");
     return this.batch(session, [{
       ref: `block:${result.id}:level:${result.level}`,
       target: { eventIds: [], elementIds: [] }
@@ -3527,6 +3546,37 @@ var StrataGateRuntime = class {
     await update;
     return value;
   }
+  async adminExpandBlock(namespace, id, target) {
+    const key = namespace.trim();
+    if (!key) throw new TypeError("StrataGate admin namespace must not be empty");
+    const update = this.settingsTail.catch(() => {
+    }).then(async () => {
+      await this.flush();
+      const active = this.spaces.get(key);
+      if (active) return (await active).expandBlock(id, target, "user");
+      if (this.config.database === ":memory:" || !existsSync(this.config.database)) {
+        throw new Error(`Unknown StrataGate namespace: ${key}`);
+      }
+      const memory = await StrataGate.open({
+        database: this.config.database,
+        namespace: key,
+        blockTurnSize: this.config.blockTurnSize,
+        blockDecayLambda: this.blockDecayLambda,
+        summarizer: this.models.summarizer,
+        extractor: this.models.extractor,
+        elementProjector: this.models.projector
+      });
+      try {
+        return await memory.expandBlock(id, target, "user");
+      } finally {
+        await memory.close();
+      }
+    });
+    this.settingsTail = update.then(() => {
+    }, () => {
+    });
+    return update;
+  }
   async applyBlockDecayLambda(value) {
     await this.flush();
     this.blockDecayLambda = value;
@@ -3911,6 +3961,20 @@ function registerMemoryTools(ctx, runtime) {
 }
 
 // src/web.ts
+import { createRequire } from "node:module";
+var STRATAGATE_DSH_VERSION = "0.2.21";
+var LEGACY_THREAD_ID = "__legacy__";
+var nodeRequire = createRequire(import.meta.url);
+function installedPackageVersion(names) {
+  for (const name2 of names) {
+    try {
+      const value = nodeRequire(`${name2}/package.json`);
+      if (typeof value.version === "string" && value.version.trim()) return value.version;
+    } catch {
+    }
+  }
+  return "unknown";
+}
 function sendJson(res, status, body) {
   res.statusCode = status;
   res.setHeader("Content-Type", "application/json; charset=utf-8");
@@ -3953,6 +4017,17 @@ function sourceMessages(snapshot, ids) {
   }
   return output;
 }
+function blockLayers(block) {
+  return [
+    { level: 0, content: `${block.l0Title}
+\u6807\u7B7E\uFF1A${block.l0Tags.join("\u3001") || "\u65E0"}` },
+    { level: 1, content: block.l1Summary || block.l0Title },
+    { level: 2, content: block.l2Keypoints.map((point) => `\u2022 ${point}`).join("\n") || block.l1Summary || block.l0Title },
+    { level: 3, content: block.l3Condensed || block.l2Keypoints.join("\n") || block.l1Summary },
+    { level: 4, content: block.l4Readable || block.l3Condensed },
+    { level: 5, content: block.l5Raw.map((message) => `${message.role}: ${message.content}`).join("\n\n") }
+  ];
+}
 function eventSummary(event) {
   return {
     id: event.id,
@@ -4056,7 +4131,13 @@ async function overview(runtime) {
       lastActivityAt: timestamps.at(-1) ?? null
     });
   }
-  return { readonly: true, settingsWritable: true, namespaces: rows };
+  return {
+    readonly: true,
+    settingsWritable: true,
+    pluginVersion: STRATAGATE_DSH_VERSION,
+    harnessVersion: installedPackageVersion(["@deepseek-ai/dsh", "@deepseek-ai/dsh-session"]),
+    namespaces: rows
+  };
 }
 async function updateSettings(runtime, url) {
   const raw = url.searchParams.get("blockDecayLambda")?.trim() ?? "";
@@ -4066,6 +4147,126 @@ async function updateSettings(runtime, url) {
   }
   return { blockDecayLambda: await runtime.adminSetBlockDecayLambda(value) };
 }
+function receiptThreadId(id) {
+  const match = /^dsh:(.+):turn:\d+$/.exec(id);
+  return match?.[1]?.trim() || null;
+}
+function timestampKey(value) {
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? String(parsed) : value;
+}
+function recoverSnapshotView(snapshot) {
+  const receiptThreads = /* @__PURE__ */ new Map();
+  const receiptActivity = /* @__PURE__ */ new Map();
+  const receiptCandidates = /* @__PURE__ */ new Map();
+  for (const receipt of snapshot.ingestionReceipts) {
+    const threadId = receiptThreadId(receipt.id);
+    if (!threadId) continue;
+    receiptThreads.set(receipt.id, threadId);
+    const currentActivity = receiptActivity.get(threadId);
+    if (!currentActivity || receipt.createdAt > currentActivity) receiptActivity.set(threadId, receipt.createdAt);
+    const key = timestampKey(receipt.createdAt);
+    const candidates = receiptCandidates.get(key) ?? /* @__PURE__ */ new Set();
+    candidates.add(threadId);
+    receiptCandidates.set(key, candidates);
+  }
+  const exactThreadAt = new Map([...receiptCandidates].filter(([, ids]) => ids.size === 1).map(([createdAt, ids]) => [createdAt, [...ids][0]]));
+  const recoverMessages = (messages) => {
+    let precedingThreadId = null;
+    return messages.map((message) => {
+      const explicit = message.threadId?.trim();
+      const exact = exactThreadAt.get(timestampKey(message.createdAt));
+      const recovered = explicit || exact || (message.role === "assistant" ? precedingThreadId : null);
+      const threadId = recovered || LEGACY_THREAD_ID;
+      if (message.role === "user" || explicit || exact) precedingThreadId = threadId;
+      return { message, threadId };
+    });
+  };
+  const blocks = [];
+  for (const source of snapshot.blocks) {
+    const recovered = recoverMessages(source.l5Raw);
+    const groups = /* @__PURE__ */ new Map();
+    for (const item of recovered) {
+      const messages = groups.get(item.threadId) ?? [];
+      messages.push(item.message);
+      groups.set(item.threadId, messages);
+    }
+    const entries = [...groups];
+    for (const [threadId, messages] of entries) {
+      const virtual = !source.threadId && (entries.length > 1 || threadId !== LEGACY_THREAD_ID);
+      blocks.push({
+        id: entries.length > 1 ? `virtual:${source.id}:${encodeURIComponent(threadId)}` : source.id,
+        source,
+        threadId,
+        messages,
+        virtual,
+        turnRange: [0, 0]
+      });
+    }
+  }
+  const turnCounters = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    if (block.source.threadId) {
+      block.turnRange = [block.source.startTurn, block.source.endTurn];
+      turnCounters.set(block.threadId, Math.max(turnCounters.get(block.threadId) ?? 0, block.source.endTurn));
+      continue;
+    }
+    const turns = Math.max(1, block.messages.filter(({ role }) => role === "user").length);
+    const start = (turnCounters.get(block.threadId) ?? 0) + 1;
+    block.turnRange = [start, start + turns - 1];
+    turnCounters.set(block.threadId, start + turns - 1);
+  }
+  return {
+    blocks,
+    openMessages: recoverMessages(snapshot.openTail),
+    receiptThreads,
+    receiptActivity
+  };
+}
+function virtualBlockLayers(block) {
+  if (!block.virtual || block.messages.length === block.source.l5Raw.length) return blockLayers(block.source);
+  const deterministic = deterministicBlockLayers(block.messages);
+  const natural = block.messages.filter(({ role }) => role === "user" || role === "assistant");
+  const firstUser = natural.find(({ role, content }) => role === "user" && content.trim());
+  const title = firstUser?.content.replace(/\s+/g, " ").trim().slice(0, 80) || "\u65E7\u4F1A\u8BDD\u7247\u6BB5";
+  const summary = natural.map(({ content }) => content.replace(/\s+/g, " ").trim()).filter(Boolean).join(" ").slice(0, 500);
+  const keypoints = natural.filter(({ role }) => role === "user").map(({ content }) => content.replace(/\s+/g, " ").trim().slice(0, 160));
+  return [
+    { level: 0, content: title },
+    { level: 1, content: summary || title },
+    { level: 2, content: keypoints.map((point) => `\u2022 ${point}`).join("\n") || summary || title },
+    { level: 3, content: deterministic.l3Condensed },
+    { level: 4, content: deterministic.l4Readable },
+    { level: 5, content: block.messages.map((message) => `${message.role}: ${message.content}`).join("\n\n") }
+  ];
+}
+function conversationRows(snapshot, view = recoverSnapshotView(snapshot)) {
+  const ids = /* @__PURE__ */ new Set([
+    ...view.blocks.map((block) => block.threadId),
+    ...view.openMessages.map(({ threadId }) => threadId),
+    ...view.receiptThreads.values()
+  ]);
+  return [...ids].map((id) => {
+    const blocks = view.blocks.filter((block) => block.threadId === id);
+    const messages = [
+      ...blocks.flatMap((block) => block.messages),
+      ...view.openMessages.filter((message) => message.threadId === id).map(({ message }) => message)
+    ];
+    const firstUser = messages.find(({ role, content }) => role === "user" && content.trim());
+    const title = firstUser?.content.replace(/\s+/g, " ").trim().slice(0, 28);
+    const timestamps = [
+      ...blocks.map(({ source }) => source.createdAt),
+      ...messages.map(({ createdAt }) => createdAt),
+      ...view.receiptActivity.get(id) ? [view.receiptActivity.get(id)] : []
+    ].sort();
+    return {
+      id,
+      label: id === LEGACY_THREAD_ID ? "\u5386\u53F2\u5BF9\u8BDD" : title || `\u5BF9\u8BDD ${id.slice(0, 8)}`,
+      blocks: blocks.length,
+      lastActivityAt: timestamps.at(-1) ?? null
+    };
+  }).sort((left, right) => String(right.lastActivityAt).localeCompare(String(left.lastActivityAt)));
+}
 async function memories(runtime, url) {
   const namespace = url.searchParams.get("namespace")?.trim() ?? "";
   if (!namespace) throw new AdminHttpError(400, "namespace is required");
@@ -4080,44 +4281,85 @@ async function memories(runtime, url) {
     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 === "blocks") values = snapshot.blocks.map((block) => {
-    const extraction = snapshot.extractionJobs.find(({ blockId }) => blockId === block.id);
-    const relatedEvents = snapshot.events.filter(({ sourceBlockId }) => sourceBlockId === block.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 failedProjection = projections.find(({ status: status2 }) => status2 === "failed");
-    const pendingProjection = projections.some(({ status: status2 }) => status2 === "pending" || status2 === "running");
-    const needsExtraction = block.shouldExtract === true;
-    const status = extraction?.status === "failed" || failedProjection ? "failed" : extraction?.status === "succeeded" || extraction?.status === "skipped" ? pendingProjection ? "processing" : "organized" : needsExtraction ? "waiting" : "organized";
+  else if (kind === "blocks") {
+    const recovered = recoverSnapshotView(snapshot);
+    const conversations = conversationRows(snapshot, recovered);
+    const requestedThreadId = url.searchParams.get("threadId")?.trim() ?? "";
+    const activeThreadId = requestedThreadId || conversations[0]?.id || null;
+    const scopedBlocks = activeThreadId ? recovered.blocks.filter((block) => block.threadId === activeThreadId) : [];
+    values = scopedBlocks.map((block) => {
+      const source = block.source;
+      const extraction = snapshot.extractionJobs.find(({ blockId }) => blockId === source.id);
+      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 failedProjection = projections.find(({ status: status2 }) => status2 === "failed");
+      const pendingProjection = projections.some(({ status: status2 }) => status2 === "pending" || status2 === "running");
+      const needsExtraction = source.shouldExtract === true;
+      const status = extraction?.status === "failed" || failedProjection ? "failed" : extraction?.status === "succeeded" || extraction?.status === "skipped" ? pendingProjection ? "processing" : "organized" : needsExtraction ? "waiting" : "organized";
+      const blockPosition = scopedBlocks.findIndex(({ id }) => id === block.id) + 1;
+      const latestBlockPosition = scopedBlocks.length;
+      const currentLevel = getDecayedBlockLevel(
+        source.pointerAnchorLevel,
+        source.threadId ? source.pointerAnchorBlockPosition : Math.min(source.pointerAnchorBlockPosition, blockPosition),
+        latestBlockPosition,
+        snapshot.blockDecayLambda
+      );
+      return {
+        id: block.id,
+        sourceBlockId: source.id,
+        threadId: block.threadId,
+        sequence: source.sequence,
+        turnRange: block.turnRange,
+        title: block.virtual && block.messages.length !== source.l5Raw.length ? block.messages.find(({ role }) => role === "user")?.content.replace(/\s+/g, " ").trim().slice(0, 80) || "\u65E7\u4F1A\u8BDD\u7247\u6BB5" : source.l0Title,
+        tags: source.l0Tags,
+        summary: source.l1Summary,
+        keypoints: source.l2Keypoints,
+        currentLevel,
+        distanceFromLatest: Math.max(0, latestBlockPosition - blockPosition),
+        expansionSource: source.lastLiftedAt ? source.lastLiftedBy ?? "legacy" : null,
+        lastLiftedAt: source.lastLiftedAt,
+        sourceMessages: block.messages.length,
+        createdAt: source.createdAt,
+        virtual: block.virtual,
+        status,
+        eventExtraction: extraction ? {
+          status: extraction.status,
+          attempts: extraction.attempts,
+          updatedAt: extraction.updatedAt,
+          lastError: extraction.lastError
+        } : null,
+        elementProjection: projections.length ? {
+          status: failedProjection ? "failed" : pendingProjection ? "processing" : "completed",
+          jobs: projections.length,
+          lastError: failedProjection?.lastError ?? null
+        } : null,
+        relatedEvents: relatedEvents.map(eventSummary),
+        relatedElements
+      };
+    });
+    const filtered2 = values.filter((value) => matchesQuery(value, query));
+    const latestSealedTurn = scopedBlocks.reduce((latest, block) => Math.max(latest, block.turnRange[1]), 0);
+    const openMessages = activeThreadId ? recovered.openMessages.filter((message) => message.threadId === activeThreadId).map(({ message }) => message) : [];
+    const openTurns = openMessages.filter(({ role }) => role === "user").length;
     return {
-      id: block.id,
-      sequence: block.sequence,
-      turnRange: [block.startTurn, block.endTurn],
-      title: block.l0Title,
-      tags: block.l0Tags,
-      summary: block.l1Summary,
-      keypoints: block.l2Keypoints,
-      currentLevel: block.pointerCurrentLevel,
-      sourceMessages: block.l5Raw.length,
-      createdAt: block.createdAt,
-      status,
-      eventExtraction: extraction ? {
-        status: extraction.status,
-        attempts: extraction.attempts,
-        updatedAt: extraction.updatedAt,
-        lastError: extraction.lastError
-      } : null,
-      elementProjection: projections.length ? {
-        status: failedProjection ? "failed" : pendingProjection ? "processing" : "completed",
-        jobs: projections.length,
-        lastError: failedProjection?.lastError ?? null
-      } : null,
-      relatedEvents: relatedEvents.map(eventSummary),
-      relatedElements
+      namespace,
+      kind,
+      total: filtered2.length,
+      offset,
+      limit,
+      items: filtered2.slice(offset, offset + limit),
+      openBlock: {
+        turnRange: openTurns > 0 ? [latestSealedTurn + 1, latestSealedTurn + openTurns] : null,
+        messages: openMessages.length,
+        status: "open"
+      },
+      conversations,
+      activeThreadId
     };
-  });
-  else throw new AdminHttpError(400, `Unsupported memory kind: ${kind}`);
+  } else throw new AdminHttpError(400, `Unsupported memory kind: ${kind}`);
   const filtered = values.filter((value) => matchesQuery(value, query));
   return { namespace, kind, total: filtered.length, offset, limit, items: filtered.slice(offset, offset + limit) };
 }
@@ -4143,12 +4385,22 @@ async function sources(runtime, url) {
     events = snapshot.events.filter(({ id }) => element.sourceEventIds.includes(id));
     ids = new Set(events.flatMap(({ sourceMessageIds }) => sourceMessageIds));
   } else if (blockId) {
-    const block = snapshot.blocks.find(({ id }) => id === blockId);
+    const displayBlock = recoverSnapshotView(snapshot).blocks.find(({ id }) => id === blockId);
+    const block = displayBlock?.source ?? snapshot.blocks.find(({ id }) => id === blockId);
     if (!block) throw new AdminHttpError(404, `Unknown block: ${blockId}`);
-    ids = new Set(block.l5Raw.map(({ id }) => id));
-    events = snapshot.events.filter(({ sourceBlockId }) => sourceBlockId === blockId);
+    const messages = displayBlock?.messages ?? block.l5Raw;
+    ids = new Set(messages.map(({ id }) => id));
+    events = snapshot.events.filter((event) => event.sourceBlockId === block.id && (!displayBlock?.virtual || event.sourceMessageIds.some((id) => ids.has(id))));
     const eventIds = new Set(events.map(({ id }) => id));
     elements = snapshot.elements.filter(({ sourceEventIds }) => sourceEventIds.some((id) => eventIds.has(id)));
+    return {
+      namespace,
+      events: events.map(eventSummary),
+      elements: elements.map(elementSummary),
+      messages: sourceMessages(snapshot, ids),
+      layers: displayBlock ? virtualBlockLayers(displayBlock) : blockLayers(block),
+      virtual: displayBlock?.virtual ?? false
+    };
   } else {
     throw new AdminHttpError(400, "eventId, elementId, or blockId is required");
   }
@@ -4159,6 +4411,16 @@ async function sources(runtime, url) {
     messages: sourceMessages(snapshot, ids)
   };
 }
+async function expandBlock(runtime, url) {
+  const namespace = url.searchParams.get("namespace")?.trim() ?? "";
+  const blockId = url.searchParams.get("blockId")?.trim() ?? "";
+  const target = url.searchParams.get("level")?.trim() ?? "";
+  if (!namespace) throw new AdminHttpError(400, "namespace is required");
+  if (!blockId) throw new AdminHttpError(400, "blockId is required");
+  if (blockId.startsWith("virtual:")) throw new AdminHttpError(409, "Recovered legacy fragments are read-only display data");
+  if (!/^L?[0-5]$/i.test(target)) throw new AdminHttpError(400, "level must be L0 through L5");
+  return runtime.adminExpandBlock(namespace, blockId, target);
+}
 function receiptSources(snapshot, receipt) {
   const events = snapshot.events.filter(({ id }) => receipt.eventIds.includes(id));
   const elements = snapshot.elements.filter(({ id }) => receipt.elementIds.includes(id));
@@ -4194,6 +4456,9 @@ async function handleAdminRequest(runtime, req, res) {
     if (path === "/api/stratagate/settings") {
       if (req.method !== "PATCH") throw new AdminHttpError(405, "StrataGate settings require PATCH");
       sendJson(res, 200, await updateSettings(runtime, url));
+    } else if (path === "/api/stratagate/blocks/expand") {
+      if (req.method !== "PATCH") throw new AdminHttpError(405, "StrataGate Block expansion requires PATCH");
+      sendJson(res, 200, await expandBlock(runtime, url));
     } else if (req.method !== "GET") throw new AdminHttpError(405, "StrataGate memory data is read-only");
     else if (path === "/api/stratagate/overview") sendJson(res, 200, await overview(runtime));
     else if (path === "/api/stratagate/memories") sendJson(res, 200, await memories(runtime, url));