stratagate-dsh 0.2.16 → 0.2.19

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 = 6;
 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) };
+  });
+}
 function normalizeSnapshot(value) {
   if (!value || typeof value !== "object") throw new TypeError("Invalid StrataGate snapshot: expected an object");
   const schemaVersion = value.schemaVersion;
@@ -383,26 +392,45 @@ 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(legacy),
+      schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
+      blockDecayLambda: BLOCK_DECAY_LAMBDA,
+      blocks: migrateLegacyBlocks(legacy.blocks)
+    };
+  } else if (schemaVersion === 5) {
+    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 === STRATAGATE_STORAGE_SCHEMA_VERSION) {
     snapshot = structuredClone(value);
@@ -415,10 +443,18 @@ 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 (snapshot.successfulModelResponses.length > 5) {
     snapshot.successfulModelResponses = snapshot.successfulModelResponses.slice(-5);
   }
@@ -592,6 +628,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,7 +650,7 @@ 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,
   PRIMARY KEY (namespace, id),
   UNIQUE (namespace, sequence),
@@ -831,7 +868,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,7 +917,7 @@ var SqliteStorage = class {
       l5Raw: messagesByBlock.get(row.id) ?? [],
       pointerCurrentLevel: row.pointer_current_level,
       pointerAnchorLevel: row.pointer_anchor_level,
-      pointerAnchorTurn: row.pointer_anchor_turn,
+      pointerAnchorBlockPosition: row.pointer_anchor_block_position,
       lastLiftedAt: row.last_lifted_at
     }));
     const sourceRows = this.database.prepare(`
@@ -1047,6 +1084,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 +1123,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,7 +1154,7 @@ 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
+        pointer_current_level, pointer_anchor_level, pointer_anchor_block_position, last_lifted_at
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT (namespace, id) DO UPDATE SET
         thread_id = excluded.thread_id,
@@ -1131,7 +1171,7 @@ 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,
+        pointer_anchor_block_position = excluded.pointer_anchor_block_position,
         last_lifted_at = excluded.last_lifted_at
     `);
     for (const block of snapshot.blocks) {
@@ -1152,7 +1192,7 @@ var SqliteStorage = class {
         block.l4Readable,
         block.pointerCurrentLevel,
         block.pointerAnchorLevel,
-        block.pointerAnchorTurn,
+        block.pointerAnchorBlockPosition,
         block.lastLiftedAt
       );
     }
@@ -1422,8 +1462,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) {
       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 +1475,26 @@ 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
+            ))
+          `);
+        }
         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 +1582,7 @@ function errorMessage(error) {
 var STRATAGATE_CONSTRUCTOR_TOKEN = /* @__PURE__ */ Symbol("StrataGate constructor");
 var StrataGate = class _StrataGate {
   blockTurnSize;
+  blockDecayLambdaValue;
   summarizer;
   extractor;
   elementProjector;
@@ -1551,6 +1608,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 +1635,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 +1654,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 +1731,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 +1785,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,13 +2086,22 @@ 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)
@@ -2012,17 +2112,24 @@ var StrataGate = class _StrataGate {
     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());
       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 +2328,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,7 +2353,7 @@ var StrataGate = class _StrataGate {
         ...deterministic,
         pointerCurrentLevel: 5,
         pointerAnchorLevel: 5,
-        pointerAnchorTurn: endTurn,
+        pointerAnchorBlockPosition: blockPosition,
         lastLiftedAt: null
       };
       const sealedIds = new Set(raw.map((message) => message.id));
@@ -2381,6 +2490,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 +3161,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 +3223,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 +3243,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;
@@ -3298,16 +3470,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 +3504,70 @@ 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 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 +3592,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 +3663,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");
 }
@@ -3787,15 +4037,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 +4056,15 @@ async function overview(runtime) {
       lastActivityAt: timestamps.at(-1) ?? null
     });
   }
-  return { readonly: true, namespaces: rows };
+  return { readonly: true, settingsWritable: true, 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) };
 }
 async function memories(runtime, url) {
   const namespace = url.searchParams.get("namespace")?.trim() ?? "";
@@ -3928,10 +4189,13 @@ 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 (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 +4238,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();