stratagate-dsh 0.2.16 → 0.2.21

package/dist/index.js

@@ -11,6 +11,7 @@ var Config = z.object({
   namespacePrefix: z.string().default("dsh"),
   globalNamespace: z.string().default("global"),
   blockTurnSize: z.natural().min(1).default(6),
+  blockDecayLambda: z.number().step(0.05).min(0).default(0.3).description("Block \u8870\u51CF\u7CFB\u6570 \u03BB").comment("\u9ED8\u8BA4 0.3\uFF1B\u6570\u5B57\u8D8A\u5C0F\uFF0C\u8BB0\u5FC6\u9057\u5FD8\u8D8A\u6162\uFF0C\u6D88\u8017 token \u8D8A\u591A\uFF0C\u4E0D\u5EFA\u8BAE\u5927\u4E8E 0.4\u3002"),
   ingestSubagents: z.boolean().default(false),
   provider: z.string(),
   model: z.string(),
@@ -32,6 +33,7 @@ function resolveConfig(config) {
     namespacePrefix,
     globalNamespace,
     blockTurnSize: Math.max(1, Math.floor(config.blockTurnSize ?? 6)),
+    blockDecayLambda: Math.max(0, config.blockDecayLambda ?? 0.3),
     ingestSubagents: config.ingestSubagents ?? false,
     ...provider && model ? { provider, model } : {},
     maxOutputTokens: Math.max(256, Math.floor(config.maxOutputTokens ?? 1e4))
@@ -46,7 +48,7 @@ import { parameterSchemaSpecToJsonSchema, validateArgs } from "@deepseek-ai/dsh-
 // ../../src/blocks.ts
 var DEFAULT_BLOCK_TURN_SIZE = 12;
 var BLOCK_MAX_LEVEL = 5;
-var BLOCK_DECAY_LAMBDA = 0.05;
+var BLOCK_DECAY_LAMBDA = 0.3;
 var FILLER_ONLY = /* @__PURE__ */ new Set([
   "ok",
   "okay",
@@ -80,11 +82,11 @@ var REPEATED_PASTE_MARKER = "[repeated paste omitted; original remains in L5]";
 function asBlockLevel(value) {
   return Math.max(0, Math.min(BLOCK_MAX_LEVEL, Math.round(value)));
 }
-function getBlockWeight(anchorTurn, currentTurn) {
-  return Math.exp(-BLOCK_DECAY_LAMBDA * Math.max(0, currentTurn - anchorTurn));
+function getBlockWeight(anchorBlockPosition, latestBlockPosition, lambda = BLOCK_DECAY_LAMBDA) {
+  return Math.exp(-lambda * Math.max(0, latestBlockPosition - anchorBlockPosition));
 }
-function getDecayedBlockLevel(anchorLevel, anchorTurn, currentTurn) {
-  const weight = getBlockWeight(anchorTurn, currentTurn);
+function getDecayedBlockLevel(anchorLevel, anchorBlockPosition, latestBlockPosition, lambda = BLOCK_DECAY_LAMBDA) {
+  const weight = getBlockWeight(anchorBlockPosition, latestBlockPosition, lambda);
   const droppedLevels = weight > 0.7 ? 0 : weight > 0.5 ? 1 : weight > 0.3 ? 2 : weight > 0.15 ? 3 : weight > 0.08 ? 4 : 5;
   return asBlockLevel(anchorLevel - droppedLevels);
 }
@@ -358,7 +360,7 @@ function rrfRank(rankings) {
 }
 
 // ../../src/storage.ts
-var STRATAGATE_STORAGE_SCHEMA_VERSION = 5;
+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"}`);
@@ -374,6 +376,13 @@ var StorageConflictError = class extends Error {
 function cloneSnapshot(snapshot) {
   return structuredClone(snapshot);
 }
+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), lastLiftedBy: null };
+  });
+}
 function normalizeSnapshot(value) {
   if (!value || typeof value !== "object") throw new TypeError("Invalid StrataGate snapshot: expected an object");
   const schemaVersion = value.schemaVersion;
@@ -383,26 +392,52 @@ function normalizeSnapshot(value) {
     snapshot = {
       ...structuredClone(legacy),
       schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
+      blockDecayLambda: BLOCK_DECAY_LAMBDA,
+      blocks: migrateLegacyBlocks(legacy.blocks),
       elements: [],
       elementProjectionJobs: [],
       usageReceipts: Array.isArray(legacy.usageReceipts) ? legacy.usageReceipts.map((receipt) => ({ ...receipt, elementIds: [] })) : [],
       ingestionReceipts: []
     };
   } else if (schemaVersion === 2) {
+    const legacy = value;
     snapshot = {
-      ...structuredClone(value),
+      ...structuredClone(legacy),
       schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
+      blockDecayLambda: BLOCK_DECAY_LAMBDA,
+      blocks: migrateLegacyBlocks(legacy.blocks),
       ingestionReceipts: []
     };
   } else if (schemaVersion === 3) {
+    const legacy = value;
     snapshot = {
-      ...structuredClone(value),
-      schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION
+      ...structuredClone(legacy),
+      schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
+      blockDecayLambda: BLOCK_DECAY_LAMBDA,
+      blocks: migrateLegacyBlocks(legacy.blocks)
     };
   } else if (schemaVersion === 4) {
+    const legacy = value;
     snapshot = {
-      ...structuredClone(value),
-      schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION
+      ...structuredClone(legacy),
+      schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
+      blockDecayLambda: BLOCK_DECAY_LAMBDA,
+      blocks: migrateLegacyBlocks(legacy.blocks)
+    };
+  } else if (schemaVersion === 5) {
+    const legacy = value;
+    snapshot = {
+      ...structuredClone(legacy),
+      schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
+      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);
@@ -415,10 +450,21 @@ function normalizeSnapshot(value) {
   if (!Number.isSafeInteger(snapshot.blockTurnSize) || (snapshot.blockTurnSize ?? 0) < 1) {
     throw new TypeError("Invalid StrataGate snapshot: blockTurnSize must be a positive integer");
   }
+  if (!Number.isFinite(snapshot.blockDecayLambda) || snapshot.blockDecayLambda < 0) {
+    throw new TypeError("Invalid StrataGate snapshot: blockDecayLambda must be a non-negative finite number");
+  }
   for (const key of ["openTail", "blocks", "events", "elements", "extractionJobs", "elementProjectionJobs", "usageReceipts", "ingestionReceipts"]) {
     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 block of snapshot.blocks) {
+    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);
   }
@@ -592,6 +638,7 @@ CREATE TABLE IF NOT EXISTS memory_spaces (
   revision INTEGER NOT NULL,
   current_turn INTEGER NOT NULL,
   block_turn_size INTEGER NOT NULL,
+  block_decay_lambda REAL NOT NULL,
   created_at TEXT NOT NULL,
   updated_at TEXT NOT NULL
 ) STRICT;
@@ -613,8 +660,9 @@ CREATE TABLE IF NOT EXISTS blocks (
   l4_readable TEXT NOT NULL,
   pointer_current_level INTEGER NOT NULL,
   pointer_anchor_level INTEGER NOT NULL,
-  pointer_anchor_turn 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
@@ -831,7 +879,7 @@ var SqliteStorage = class {
     this.assertOpen();
     const key = nonEmptyNamespace(namespace);
     const space = this.database.prepare(`
-      SELECT schema_version, revision, current_turn, block_turn_size
+      SELECT schema_version, revision, current_turn, block_turn_size, block_decay_lambda
       FROM memory_spaces WHERE namespace = ?
     `).get(key);
     if (!space) return null;
@@ -880,8 +928,9 @@ var SqliteStorage = class {
       l5Raw: messagesByBlock.get(row.id) ?? [],
       pointerCurrentLevel: row.pointer_current_level,
       pointerAnchorLevel: row.pointer_anchor_level,
-      pointerAnchorTurn: row.pointer_anchor_turn,
-      lastLiftedAt: row.last_lifted_at
+      pointerAnchorBlockPosition: row.pointer_anchor_block_position,
+      lastLiftedAt: row.last_lifted_at,
+      lastLiftedBy: row.last_lifted_by
     }));
     const sourceRows = this.database.prepare(`
       SELECT event_id, message_id, position FROM event_sources
@@ -1047,6 +1096,7 @@ var SqliteStorage = class {
       schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
       currentTurn: space.current_turn,
       blockTurnSize: space.block_turn_size,
+      blockDecayLambda: space.block_decay_lambda,
       openTail,
       blocks,
       events,
@@ -1085,27 +1135,29 @@ var SqliteStorage = class {
     if (current) {
       this.database.prepare(`
         UPDATE memory_spaces
-        SET schema_version = ?, revision = ?, current_turn = ?, block_turn_size = ?, updated_at = ?
+        SET schema_version = ?, revision = ?, current_turn = ?, block_turn_size = ?, block_decay_lambda = ?, updated_at = ?
         WHERE namespace = ?
       `).run(
         snapshot.schemaVersion,
         nextRevision,
         snapshot.currentTurn,
         snapshot.blockTurnSize,
+        snapshot.blockDecayLambda,
         updatedAt,
         namespace
       );
     } else {
       this.database.prepare(`
         INSERT INTO memory_spaces (
-          namespace, schema_version, revision, current_turn, block_turn_size, created_at, updated_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?)
+          namespace, schema_version, revision, current_turn, block_turn_size, block_decay_lambda, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
       `).run(
         namespace,
         snapshot.schemaVersion,
         nextRevision,
         snapshot.currentTurn,
         snapshot.blockTurnSize,
+        snapshot.blockDecayLambda,
         updatedAt,
         updatedAt
       );
@@ -1114,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_turn, 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,
@@ -1131,8 +1183,9 @@ var SqliteStorage = class {
         l4_readable = excluded.l4_readable,
         pointer_current_level = excluded.pointer_current_level,
         pointer_anchor_level = excluded.pointer_anchor_level,
-        pointer_anchor_turn = excluded.pointer_anchor_turn,
-        last_lifted_at = excluded.last_lifted_at
+        pointer_anchor_block_position = excluded.pointer_anchor_block_position,
+        last_lifted_at = excluded.last_lifted_at,
+        last_lifted_by = excluded.last_lifted_by
     `);
     for (const block of snapshot.blocks) {
       insertBlock.run(
@@ -1152,8 +1205,9 @@ var SqliteStorage = class {
         block.l4Readable,
         block.pointerCurrentLevel,
         block.pointerAnchorLevel,
-        block.pointerAnchorTurn,
-        block.lastLiftedAt
+        block.pointerAnchorBlockPosition,
+        block.lastLiftedAt,
+        block.lastLiftedBy
       );
     }
     const insertMessage = this.database.prepare(`
@@ -1422,8 +1476,9 @@ 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) {
+    } else if (version === 1 || version === 2 || version === 3 || version === 4 || version === 5 || version === 6) {
       this.immediateTransaction(() => {
+        this.database.exec(SCHEMA);
         if (version === 1) {
           const receiptColumns2 = this.database.prepare("PRAGMA table_info('usage_receipts')").all();
           if (!receiptColumns2.some(({ name: name2 }) => name2 === "element_ids_json")) {
@@ -1434,11 +1489,29 @@ var SqliteStorage = class {
         if (!receiptColumns.some(({ name: name2 }) => name2 === "audit_json")) {
           this.database.exec("ALTER TABLE usage_receipts ADD COLUMN audit_json TEXT NOT NULL DEFAULT '{}'");
         }
-        this.database.exec(SCHEMA);
+        const spaceColumns = this.database.prepare("PRAGMA table_info('memory_spaces')").all();
+        if (!spaceColumns.some(({ name: name2 }) => name2 === "block_decay_lambda")) {
+          this.database.exec("ALTER TABLE memory_spaces ADD COLUMN block_decay_lambda REAL NOT NULL DEFAULT 0.3");
+        }
         const blockColumns = this.database.prepare("PRAGMA table_info('blocks')").all();
         if (!blockColumns.some(({ name: name2 }) => name2 === "thread_id")) {
           this.database.exec("ALTER TABLE blocks ADD COLUMN thread_id TEXT");
         }
+        if (!blockColumns.some(({ name: name2 }) => name2 === "pointer_anchor_block_position")) {
+          this.database.exec("ALTER TABLE blocks RENAME COLUMN pointer_anchor_turn TO pointer_anchor_block_position");
+          this.database.exec(`
+            UPDATE blocks AS target
+            SET pointer_anchor_block_position = MAX(1, (
+              SELECT COUNT(*) FROM blocks AS candidate
+              WHERE candidate.namespace = target.namespace
+                AND candidate.thread_id IS target.thread_id
+                AND candidate.end_turn <= target.pointer_anchor_block_position
+            ))
+          `);
+        }
+        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");
@@ -1526,6 +1599,7 @@ function errorMessage(error) {
 var STRATAGATE_CONSTRUCTOR_TOKEN = /* @__PURE__ */ Symbol("StrataGate constructor");
 var StrataGate = class _StrataGate {
   blockTurnSize;
+  blockDecayLambdaValue;
   summarizer;
   extractor;
   elementProjector;
@@ -1551,6 +1625,11 @@ var StrataGate = class _StrataGate {
       throw new TypeError("Use StrataGate.open() for SQLite or StrataGate.inMemory() for explicit ephemeral storage");
     }
     this.blockTurnSize = Math.max(1, Math.floor(options.blockTurnSize ?? DEFAULT_BLOCK_TURN_SIZE));
+    const blockDecayLambda = options.blockDecayLambda ?? BLOCK_DECAY_LAMBDA;
+    if (!Number.isFinite(blockDecayLambda) || blockDecayLambda < 0) {
+      throw new TypeError("blockDecayLambda must be a non-negative finite number");
+    }
+    this.blockDecayLambdaValue = blockDecayLambda;
     this.summarizer = options.summarizer;
     this.extractor = options.extractor;
     this.elementProjector = options.elementProjector;
@@ -1573,6 +1652,7 @@ var StrataGate = class _StrataGate {
         storage,
         namespace: options.namespace,
         ...options.blockTurnSize !== void 0 ? { blockTurnSize: options.blockTurnSize } : {},
+        ...options.blockDecayLambda !== void 0 ? { blockDecayLambda: options.blockDecayLambda } : {},
         ...options.summarizer ? { summarizer: options.summarizer } : {},
         ...options.extractor ? { extractor: options.extractor } : {},
         ...options.elementProjector ? { elementProjector: options.elementProjector } : {},
@@ -1591,17 +1671,32 @@ var StrataGate = class _StrataGate {
     const loaded = await options.storage.load(namespace);
     const loadedSnapshot = loaded ? normalizeSnapshot(loaded.snapshot) : null;
     let loadedRevision = loaded?.revision ?? 0;
-    if (loaded && options.blockTurnSize !== void 0) {
-      const requested = Math.max(1, Math.floor(options.blockTurnSize));
-      if (requested !== loadedSnapshot?.blockTurnSize) {
-        if (!loadedSnapshot) throw new Error("Loaded StrataGate state did not contain a snapshot");
-        loadedSnapshot.blockTurnSize = requested;
-        loadedRevision = await options.storage.save(namespace, loadedSnapshot, loadedRevision);
+    if (loaded && loadedSnapshot) {
+      let settingsChanged = false;
+      if (options.blockTurnSize !== void 0) {
+        const requested = Math.max(1, Math.floor(options.blockTurnSize));
+        if (requested !== loadedSnapshot.blockTurnSize) {
+          loadedSnapshot.blockTurnSize = requested;
+          settingsChanged = true;
+        }
+      }
+      if (options.blockDecayLambda !== void 0) {
+        const requested = options.blockDecayLambda;
+        if (!Number.isFinite(requested) || requested < 0) {
+          throw new TypeError("blockDecayLambda must be a non-negative finite number");
+        }
+        if (requested !== loadedSnapshot.blockDecayLambda) {
+          loadedSnapshot.blockDecayLambda = requested;
+          settingsChanged = true;
+        }
       }
+      if (settingsChanged) loadedRevision = await options.storage.save(namespace, loadedSnapshot, loadedRevision);
     }
     const memoryOptions = {};
     if (loadedSnapshot) memoryOptions.blockTurnSize = loadedSnapshot.blockTurnSize;
     else if (options.blockTurnSize !== void 0) memoryOptions.blockTurnSize = options.blockTurnSize;
+    if (loadedSnapshot) memoryOptions.blockDecayLambda = loadedSnapshot.blockDecayLambda;
+    else if (options.blockDecayLambda !== void 0) memoryOptions.blockDecayLambda = options.blockDecayLambda;
     if (options.summarizer) memoryOptions.summarizer = options.summarizer;
     if (options.extractor) memoryOptions.extractor = options.extractor;
     if (options.elementProjector) memoryOptions.elementProjector = options.elementProjector;
@@ -1653,6 +1748,18 @@ var StrataGate = class _StrataGate {
   get storageRevision() {
     return this.revision;
   }
+  get blockDecayLambda() {
+    return this.blockDecayLambdaValue;
+  }
+  async setBlockDecayLambda(value) {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new TypeError("blockDecayLambda must be a non-negative finite number");
+    }
+    if (value === this.blockDecayLambdaValue) return;
+    await this.commitMutation(() => {
+      this.blockDecayLambdaValue = value;
+    });
+  }
   listBlocks() {
     return this.blocks;
   }
@@ -1695,6 +1802,7 @@ var StrataGate = class _StrataGate {
       schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
       currentTurn: this.currentTurn,
       blockTurnSize: this.blockTurnSize,
+      blockDecayLambda: this.blockDecayLambda,
       openTail: this.openTail,
       blocks: this.blocks,
       events: this.events,
@@ -1995,34 +2103,51 @@ var StrataGate = class _StrataGate {
   getBlockContext(threadId) {
     const blocks = threadId === void 0 ? this.blocks : this.blocks.filter((block) => block.threadId === threadId);
     return blocks.map((block) => {
-      const currentTurn = block.threadId === void 0 ? this.currentTurn : this.threadTurn(block.threadId);
-      const level = getDecayedBlockLevel(block.pointerAnchorLevel, block.pointerAnchorTurn, currentTurn);
+      const threadBlocks = this.threadBlocks(block.threadId);
+      const latestBlockPosition = threadBlocks.length;
+      const blockPosition = threadBlocks.indexOf(block) + 1;
+      const age = Math.max(0, latestBlockPosition - blockPosition);
+      const level = getDecayedBlockLevel(
+        block.pointerAnchorLevel,
+        block.pointerAnchorBlockPosition,
+        latestBlockPosition,
+        this.blockDecayLambda
+      );
       block.pointerCurrentLevel = level;
       return {
         id: block.id,
         ...block.threadId ? { threadId: block.threadId } : {},
         turnRange: [block.startTurn, block.endTurn],
+        age,
         level,
         label: blockLevelLabel(level),
         content: renderBlock(block, level)
       };
     });
   }
-  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}`);
-      const currentTurn = block.threadId === void 0 ? this.currentTurn : this.threadTurn(block.threadId);
-      const current = getDecayedBlockLevel(block.pointerAnchorLevel, block.pointerAnchorTurn, currentTurn);
+      const latestBlockPosition = this.threadBlocks(block.threadId).length;
+      const blockPosition = this.threadBlocks(block.threadId).indexOf(block) + 1;
+      const current = getDecayedBlockLevel(
+        block.pointerAnchorLevel,
+        block.pointerAnchorBlockPosition,
+        latestBlockPosition,
+        this.blockDecayLambda
+      );
       const level = normalizeBlockLevel(target, current);
       block.pointerCurrentLevel = level;
       block.pointerAnchorLevel = level;
-      block.pointerAnchorTurn = currentTurn;
+      block.pointerAnchorBlockPosition = latestBlockPosition;
       block.lastLiftedAt = toUtc8Iso(this.now());
+      block.lastLiftedBy = source;
       return {
         id: block.id,
         ...block.threadId ? { threadId: block.threadId } : {},
         turnRange: [block.startTurn, block.endTurn],
+        age: Math.max(0, latestBlockPosition - blockPosition),
         level,
         label: blockLevelLabel(level),
         content: renderBlock(block, level)
@@ -2221,7 +2346,9 @@ var StrataGate = class _StrataGate {
     const generated = this.summarizer ? await this.summarizer(raw) : defaultSummary(raw);
     const deterministic = deterministicBlockLayers(raw);
     const sequence = this.blocks.length + 1;
-    const previous = this.threadBlocks(threadId).at(-1);
+    const threadBlocks = this.threadBlocks(threadId);
+    const previous = threadBlocks.at(-1);
+    const blockPosition = threadBlocks.length + 1;
     const startTurn = previous ? previous.endTurn + 1 : 1;
     const endTurn = startTurn + this.blockTurnSize - 1;
     return this.commitMutation(() => {
@@ -2244,8 +2371,9 @@ var StrataGate = class _StrataGate {
         ...deterministic,
         pointerCurrentLevel: 5,
         pointerAnchorLevel: 5,
-        pointerAnchorTurn: endTurn,
-        lastLiftedAt: null
+        pointerAnchorBlockPosition: blockPosition,
+        lastLiftedAt: null,
+        lastLiftedBy: null
       };
       const sealedIds = new Set(raw.map((message) => message.id));
       const remaining = this.openTail.filter((message) => !sealedIds.has(message.id));
@@ -2381,6 +2509,7 @@ var StrataGate = class _StrataGate {
       throw new Error(`Snapshot blockTurnSize ${normalized.blockTurnSize} does not match ${this.blockTurnSize}`);
     }
     const copy = cloneSnapshot(normalized);
+    this.blockDecayLambdaValue = copy.blockDecayLambda;
     this.currentTurn = copy.currentTurn;
     this.openTail.splice(0, this.openTail.length, ...copy.openTail);
     this.blocks.splice(0, this.blocks.length, ...copy.blocks);
@@ -3051,6 +3180,60 @@ var TurnFolder = class {
   }
 };
 
+// src/metadata.ts
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+var METADATA_SCHEMA = `
+CREATE TABLE IF NOT EXISTS stratagate_dsh_settings (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+) STRICT;
+
+CREATE TABLE IF NOT EXISTS stratagate_dsh_workspaces (
+  namespace TEXT PRIMARY KEY,
+  display_name TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+) STRICT;
+`;
+var DshMetadataStore = class {
+  database;
+  constructor(filename) {
+    this.database = new DatabaseSync2(filename);
+    this.database.exec(METADATA_SCHEMA);
+  }
+  blockDecayLambda() {
+    const row = this.database.prepare("SELECT value FROM stratagate_dsh_settings WHERE key = 'blockDecayLambda'").get();
+    const value = Number(row?.value);
+    return Number.isFinite(value) && value >= 0 ? value : null;
+  }
+  setBlockDecayLambda(value) {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new TypeError("blockDecayLambda must be a non-negative finite number");
+    }
+    this.database.prepare(`
+      INSERT INTO stratagate_dsh_settings (key, value, updated_at)
+      VALUES ('blockDecayLambda', ?, ?)
+      ON CONFLICT (key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
+    `).run(String(value), (/* @__PURE__ */ new Date()).toISOString());
+  }
+  workspaceName(namespace) {
+    const row = this.database.prepare("SELECT display_name FROM stratagate_dsh_workspaces WHERE namespace = ?").get(namespace);
+    return row?.display_name ?? null;
+  }
+  rememberWorkspace(namespace, displayName) {
+    const name2 = displayName.trim();
+    if (!namespace.trim() || !name2) return;
+    this.database.prepare(`
+      INSERT INTO stratagate_dsh_workspaces (namespace, display_name, updated_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT (namespace) DO UPDATE SET display_name = excluded.display_name, updated_at = excluded.updated_at
+    `).run(namespace, name2, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  close() {
+    this.database.close();
+  }
+};
+
 // src/runtime.ts
 var AUTO_EVENT_LIMIT = 4;
 var AUTO_ELEMENT_LIMIT = 4;
@@ -3059,12 +3242,17 @@ function projectKey(cwd) {
   const canonical = resolve(cwd ?? process.cwd()).replaceAll("\\", "/").toLowerCase();
   return createHash("sha256").update(canonical).digest("hex").slice(0, 20);
 }
+function workspaceDisplayName(cwd) {
+  const canonical = (cwd ?? process.cwd()).replace(/[\\/]+$/, "");
+  return canonical.split(/[\\/]/).at(-1) || "\u5F53\u524D\u5DE5\u4F5C\u533A";
+}
 var StrataGateRuntime = class {
   constructor(config, models, onIngestError = () => {
   }) {
     this.config = config;
     this.models = models;
     this.onIngestError = onIngestError;
+    this.blockDecayLambda = config.blockDecayLambda;
   }
   config;
   models;
@@ -3074,10 +3262,13 @@ var StrataGateRuntime = class {
   batches = /* @__PURE__ */ new Map();
   adopted = /* @__PURE__ */ new Map();
   pendingUse = /* @__PURE__ */ new Set();
+  workspaceNames = /* @__PURE__ */ new Map();
   ingestTail = Promise.resolve();
+  settingsTail = Promise.resolve();
   batchSequence = 0;
   closed = false;
   ingestError;
+  blockDecayLambda;
   acceptEvent(session, event) {
     if (this.closed) return;
     if (!this.config.ingestSubagents && session.header.origin === "subagent") return;
@@ -3130,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: [] }
@@ -3298,16 +3489,23 @@ var StrataGateRuntime = class {
       await storage.close();
     }
   }
-  async syncConfiguredBlockTurnSize() {
+  async syncConfiguredSettings() {
     if (this.config.database === ":memory:" || !existsSync(this.config.database)) return;
+    const metadata = new DshMetadataStore(this.config.database);
+    try {
+      this.blockDecayLambda = metadata.blockDecayLambda() ?? this.config.blockDecayLambda;
+    } finally {
+      metadata.close();
+    }
     const storage = new SqliteStorage({ filename: this.config.database });
     try {
       for (const namespace of storage.listNamespaces()) {
         const loaded = await storage.load(namespace);
-        if (!loaded || loaded.snapshot.blockTurnSize === this.config.blockTurnSize) continue;
+        if (!loaded || loaded.snapshot.blockTurnSize === this.config.blockTurnSize && loaded.snapshot.blockDecayLambda === this.blockDecayLambda) continue;
         await storage.save(namespace, {
           ...loaded.snapshot,
-          blockTurnSize: this.config.blockTurnSize
+          blockTurnSize: this.config.blockTurnSize,
+          blockDecayLambda: this.blockDecayLambda
         }, loaded.revision);
       }
     } finally {
@@ -3325,14 +3523,101 @@ var StrataGateRuntime = class {
       await storage.close();
     }
   }
+  adminWorkspaceName(namespace) {
+    const remembered = this.workspaceNames.get(namespace);
+    if (remembered) return remembered;
+    if (this.config.database === ":memory:" || !existsSync(this.config.database)) return null;
+    const metadata = new DshMetadataStore(this.config.database);
+    try {
+      return metadata.workspaceName(namespace);
+    } finally {
+      metadata.close();
+    }
+  }
+  async adminSetBlockDecayLambda(value) {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new TypeError("blockDecayLambda must be a non-negative finite number");
+    }
+    const update = this.settingsTail.catch(() => {
+    }).then(() => this.applyBlockDecayLambda(value));
+    this.settingsTail = update.then(() => {
+    }, () => {
+    });
+    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;
+    if (this.config.database !== ":memory:") {
+      const metadata = new DshMetadataStore(this.config.database);
+      try {
+        metadata.setBlockDecayLambda(value);
+      } finally {
+        metadata.close();
+      }
+    }
+    const openNamespaces = /* @__PURE__ */ new Set();
+    for (const [namespace, opening] of this.spaces) {
+      const memory = await opening;
+      await memory.setBlockDecayLambda(value);
+      openNamespaces.add(namespace);
+    }
+    if (this.config.database !== ":memory:" && existsSync(this.config.database)) {
+      const storage = new SqliteStorage({ filename: this.config.database });
+      try {
+        for (const namespace of storage.listNamespaces()) {
+          if (openNamespaces.has(namespace)) continue;
+          const loaded = await storage.load(namespace);
+          if (!loaded || loaded.snapshot.blockDecayLambda === value) continue;
+          await storage.save(namespace, { ...loaded.snapshot, blockDecayLambda: value }, loaded.revision);
+        }
+      } finally {
+        await storage.close();
+      }
+    }
+  }
   space(session) {
     const namespace = this.namespaceFor(session);
+    this.rememberWorkspace(namespace, session.header.cwd);
     let opening = this.spaces.get(namespace);
     if (!opening) {
       opening = StrataGate.open({
         database: this.config.database,
         namespace,
         blockTurnSize: this.config.blockTurnSize,
+        blockDecayLambda: this.blockDecayLambda,
         summarizer: this.models.summarizer,
         extractor: this.models.extractor,
         elementProjector: this.models.projector
@@ -3357,6 +3642,21 @@ var StrataGateRuntime = class {
     }
     return opening;
   }
+  rememberWorkspace(namespace, cwd) {
+    const name2 = workspaceDisplayName(cwd);
+    this.workspaceNames.set(namespace, name2);
+    if (this.config.database === ":memory:") return;
+    try {
+      const metadata = new DshMetadataStore(this.config.database);
+      try {
+        metadata.rememberWorkspace(namespace, name2);
+      } finally {
+        metadata.close();
+      }
+    } catch (error) {
+      this.onIngestError(error);
+    }
+  }
   async persistSuccessfulResponses(memory) {
     if (typeof this.models.takeSuccessfulResponses !== "function") return;
     const responses = this.models.takeSuccessfulResponses();
@@ -3413,7 +3713,7 @@ function renderMessages(messages) {
 function renderBlocks2(blocks) {
   if (blocks.length === 0) return "(no sealed blocks)";
   return blocks.map((block) => [
-    `block ${block.id} | turns ${block.turnRange[0]}-${block.turnRange[1]} | L${block.level}`,
+    `block ${block.id} | turns ${block.turnRange[0]}-${block.turnRange[1]} | age ${block.age} | L${block.level}`,
     block.content
   ].join("\n")).join("\n\n");
 }
@@ -3661,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");
@@ -3703,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,
@@ -3787,15 +4112,18 @@ async function overview(runtime) {
     ].sort();
     rows.push({
       namespace,
+      workspaceName: runtime.adminWorkspaceName(namespace) ?? "\u5F53\u524D\u5DE5\u4F5C\u533A",
       schemaVersion: snapshot.schemaVersion,
       currentTurn: snapshot.currentTurn,
       blockTurnSize: snapshot.blockTurnSize,
+      blockDecayLambda: snapshot.blockDecayLambda,
       blocks: snapshot.blocks.length,
       openTailMessages: snapshot.openTail.length,
       events: snapshot.events.length,
       activeEvents: snapshot.events.filter(({ status }) => status === "active").length,
       elements: snapshot.elements.length,
       usageReceipts: snapshot.usageReceipts.length,
+      memoryUseCount: snapshot.usageReceipts.filter((receipt) => receipt.eventIds.length > 0 || receipt.elementIds.length > 0).length,
       failedJobs,
       processingJobs,
       failedJobDetails,
@@ -3803,7 +4131,141 @@ async function overview(runtime) {
       lastActivityAt: timestamps.at(-1) ?? null
     });
   }
-  return { readonly: 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() ?? "";
+  const value = Number(raw);
+  if (!raw || !Number.isFinite(value) || value < 0) {
+    throw new AdminHttpError(400, "blockDecayLambda must be a non-negative finite number");
+  }
+  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() ?? "";
@@ -3819,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) };
 }
@@ -3882,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");
   }
@@ -3898,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));
@@ -3928,10 +4451,16 @@ async function audit(runtime, url) {
 }
 async function handleAdminRequest(runtime, req, res) {
   try {
-    if (req.method !== "GET") throw new AdminHttpError(405, "StrataGate Memory UI is read-only");
     const url = new URL(req.url ?? "/", "http://localhost");
     const path = url.pathname.replace(/\/$/, "");
-    if (path === "/api/stratagate/overview") sendJson(res, 200, await overview(runtime));
+    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));
     else if (path === "/api/stratagate/sources") sendJson(res, 200, await sources(runtime, url));
     else if (path === "/api/stratagate/audit") sendJson(res, 200, await audit(runtime, url));
@@ -3974,7 +4503,7 @@ async function apply(ctx, config) {
   const runtime = new StrataGateRuntime(resolved, models, (error) => {
     ctx.logger.error(`stratagate-memory ingestion failed: ${renderError(error)}`);
   });
-  await runtime.syncConfiguredBlockTurnSize();
+  await runtime.syncConfiguredSettings();
   ctx.systemPrompt.section({ name: "tool:stratagate-memory", order: 113, text: MEMORY_PROTOCOL });
   ctx.on("system-prompt/assemble", async (_assembly, context, next) => {
     const assembled = await next();