stratagate-dsh 0.2.15 → 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 = 4;
+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,21 +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(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);
@@ -410,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);
   }
@@ -587,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;
@@ -594,6 +636,7 @@ CREATE TABLE IF NOT EXISTS memory_spaces (
 CREATE TABLE IF NOT EXISTS blocks (
   namespace TEXT NOT NULL,
   id TEXT NOT NULL,
+  thread_id TEXT,
   sequence INTEGER NOT NULL,
   start_turn INTEGER NOT NULL,
   end_turn INTEGER NOT NULL,
@@ -607,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),
@@ -618,6 +661,7 @@ CREATE TABLE IF NOT EXISTS messages (
   namespace TEXT NOT NULL,
   id TEXT NOT NULL,
   block_id TEXT,
+  thread_id TEXT,
   position INTEGER NOT NULL,
   role TEXT NOT NULL,
   content TEXT NOT NULL,
@@ -781,6 +825,10 @@ CREATE TABLE IF NOT EXISTS ingestion_receipts (
   FOREIGN KEY (namespace) REFERENCES memory_spaces(namespace) ON DELETE CASCADE
 ) STRICT;
 `;
+var THREAD_INDEXES = `
+CREATE INDEX IF NOT EXISTS messages_thread_idx ON messages(namespace, thread_id, position);
+CREATE INDEX IF NOT EXISTS blocks_thread_idx ON blocks(namespace, thread_id, sequence);
+`;
 function parseJson(value, label) {
   try {
     return JSON.parse(value);
@@ -820,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;
@@ -828,7 +876,7 @@ var SqliteStorage = class {
       throw new Error(`Unsupported stored StrataGate schema: ${space.schema_version}`);
     }
     const messageRows = this.database.prepare(`
-      SELECT id, block_id, position, role, content, created_at, tool_calls_json
+      SELECT id, block_id, thread_id, position, role, content, created_at, tool_calls_json
       FROM messages WHERE namespace = ? ORDER BY block_id, position
     `).all(key);
     const openTail = [];
@@ -839,6 +887,7 @@ var SqliteStorage = class {
         role: row.role,
         content: row.content,
         createdAt: row.created_at,
+        ...row.thread_id ? { threadId: row.thread_id } : {},
         ...row.tool_calls_json ? { toolCalls: parseJson(row.tool_calls_json, "messages.tool_calls_json") } : {}
       };
       if (row.block_id === null) openTail.push(message);
@@ -853,6 +902,7 @@ var SqliteStorage = class {
     `).all(key);
     const blocks = blockRows.map((row) => ({
       id: row.id,
+      ...row.thread_id ? { threadId: row.thread_id } : {},
       sequence: row.sequence,
       startTurn: row.start_turn,
       endTurn: row.end_turn,
@@ -867,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(`
@@ -1034,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,
@@ -1072,38 +1123,41 @@ 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
       );
     }
     const insertBlock = this.database.prepare(`
       INSERT INTO blocks (
-        namespace, id, sequence, start_turn, end_turn, created_at, should_extract,
+        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
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT (namespace, id) DO UPDATE SET
+        thread_id = excluded.thread_id,
         sequence = excluded.sequence,
         start_turn = excluded.start_turn,
         end_turn = excluded.end_turn,
@@ -1117,13 +1171,14 @@ 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) {
       insertBlock.run(
         namespace,
         block.id,
+        block.threadId ?? null,
         block.sequence,
         block.startTurn,
         block.endTurn,
@@ -1137,16 +1192,17 @@ var SqliteStorage = class {
         block.l4Readable,
         block.pointerCurrentLevel,
         block.pointerAnchorLevel,
-        block.pointerAnchorTurn,
+        block.pointerAnchorBlockPosition,
         block.lastLiftedAt
       );
     }
     const insertMessage = this.database.prepare(`
       INSERT INTO messages (
-        namespace, id, block_id, position, role, content, created_at, tool_calls_json
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        namespace, id, block_id, thread_id, position, role, content, created_at, tool_calls_json
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT (namespace, id) DO UPDATE SET
         block_id = excluded.block_id,
+        thread_id = excluded.thread_id,
         position = excluded.position,
         role = excluded.role,
         content = excluded.content,
@@ -1159,6 +1215,7 @@ var SqliteStorage = class {
           namespace,
           message.id,
           blockId,
+          message.threadId ?? null,
           position,
           message.role,
           message.content,
@@ -1402,10 +1459,12 @@ var SqliteStorage = class {
     if (version === 0) {
       this.immediateTransaction(() => {
         this.database.exec(SCHEMA);
+        this.database.exec(THREAD_INDEXES);
         this.database.exec(`PRAGMA user_version = ${STRATAGATE_STORAGE_SCHEMA_VERSION}`);
       });
-    } else if (version === 1 || version === 2 || version === 3) {
+    } 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")) {
@@ -1416,12 +1475,37 @@ 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");
+        }
+        this.database.exec(THREAD_INDEXES);
         this.database.prepare("UPDATE memory_spaces SET schema_version = ? WHERE schema_version < ?").run(STRATAGATE_STORAGE_SCHEMA_VERSION, STRATAGATE_STORAGE_SCHEMA_VERSION);
         this.database.exec(`PRAGMA user_version = ${STRATAGATE_STORAGE_SCHEMA_VERSION}`);
       });
     } else if (version === STRATAGATE_STORAGE_SCHEMA_VERSION) {
       this.database.exec(SCHEMA);
+      this.database.exec(THREAD_INDEXES);
     }
     this.assertSchemaVersion();
   }
@@ -1498,6 +1582,7 @@ function errorMessage(error) {
 var STRATAGATE_CONSTRUCTOR_TOKEN = /* @__PURE__ */ Symbol("StrataGate constructor");
 var StrataGate = class _StrataGate {
   blockTurnSize;
+  blockDecayLambdaValue;
   summarizer;
   extractor;
   elementProjector;
@@ -1523,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;
@@ -1545,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 } : {},
@@ -1563,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;
@@ -1625,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;
   }
@@ -1634,8 +1752,9 @@ var StrataGate = class _StrataGate {
   listElements() {
     return this.elements;
   }
-  listOpenTail() {
-    return this.openTail;
+  listOpenTail(threadId) {
+    if (threadId === void 0) return this.openTail;
+    return this.openTail.filter((message) => message.threadId === threadId);
   }
   listExtractionJobs() {
     return [...this.extractionJobs.values()];
@@ -1666,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,
@@ -1685,12 +1805,17 @@ var StrataGate = class _StrataGate {
     if (input.receiptId !== void 0 && !receiptId) {
       throw new TypeError("Turn receiptId must not be empty");
     }
+    const threadId = input.threadId?.trim();
+    if (input.threadId !== void 0 && !threadId) {
+      throw new TypeError("Turn threadId must not be empty");
+    }
     const createdAt = toUtc8Iso(input.createdAt ?? this.now());
     const userMessage = {
       id: this.idFactory("msg"),
       role: "user",
       content: input.user,
       createdAt,
+      ...threadId ? { threadId } : {},
       ...input.userToolCalls ? { toolCalls: input.userToolCalls } : {}
     };
     const assistantMessage = {
@@ -1698,6 +1823,7 @@ var StrataGate = class _StrataGate {
       role: "assistant",
       content: input.assistant,
       createdAt,
+      ...threadId ? { threadId } : {},
       ...input.assistantToolCalls ? { toolCalls: input.assistantToolCalls } : {}
     };
     const appended = await this.commitMutation(() => {
@@ -1711,11 +1837,11 @@ var StrataGate = class _StrataGate {
     if (options.deferProcessing === true) {
       return { sealedBlock: null, extractedEvents: [], projectedElements: [] };
     }
-    if (this.openTail.filter((message) => message.role === "user").length < this.blockTurnSize) {
+    if (this.threadOpenTail(threadId).filter((message) => message.role === "user").length < this.blockTurnSize) {
       const projectedElements2 = await this.projectEligibleElements() ?? [];
       return { sealedBlock: null, extractedEvents: [], projectedElements: projectedElements2 };
     }
-    const sealedBlock = await this.sealOpenTail();
+    const sealedBlock = await this.sealOpenTail(threadId);
     const extractedEvents = await this.extractEligibleBlock() ?? [];
     const projectedElements = await this.projectEligibleElements() ?? [];
     return { sealedBlock, extractedEvents, projectedElements };
@@ -1724,8 +1850,10 @@ var StrataGate = class _StrataGate {
     const sealedBlocks = [];
     const extractedEvents = [];
     const projectedElements = [];
-    while (this.openTail.filter((message) => message.role === "user").length >= this.blockTurnSize) {
-      sealedBlocks.push(await this.sealOpenTail());
+    while (true) {
+      const sealable = this.nextSealableThread();
+      if (sealable === null) break;
+      sealedBlocks.push(await this.sealOpenTail(sealable.threadId));
       extractedEvents.push(...await this.extractEligibleBlock() ?? []);
       projectedElements.push(...await this.projectEligibleElements() ?? []);
     }
@@ -1736,7 +1864,7 @@ var StrataGate = class _StrataGate {
       projectedElements.push(...await this.projectEligibleElements() ?? []);
     }
     if (options.retrySkipped === true) {
-      const skippedBlockIds = this.blocks.filter((block, index) => index < this.blocks.length - 1 && block.shouldExtract && this.extractionJobs.get(block.id)?.status === "skipped").map((block) => block.id);
+      const skippedBlockIds = this.blocks.filter((block) => this.nextBlockInThread(block) !== null && block.shouldExtract && this.extractionJobs.get(block.id)?.status === "skipped").map((block) => block.id);
       for (const blockId of skippedBlockIds) {
         const extracted = await this.extractEligibleBlock({ blockId, includeSkipped: true });
         if (extracted === null) continue;
@@ -1955,13 +2083,25 @@ var StrataGate = class _StrataGate {
     }
     return hits;
   }
-  getBlockContext() {
-    return this.blocks.map((block) => {
-      const level = getDecayedBlockLevel(block.pointerAnchorLevel, block.pointerAnchorTurn, this.currentTurn);
+  getBlockContext(threadId) {
+    const blocks = threadId === void 0 ? this.blocks : this.blocks.filter((block) => block.threadId === threadId);
+    return blocks.map((block) => {
+      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)
@@ -1972,15 +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 current = getDecayedBlockLevel(block.pointerAnchorLevel, block.pointerAnchorTurn, this.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 = this.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)
@@ -2129,36 +2278,69 @@ var StrataGate = class _StrataGate {
     this.elementProjectionJobs.set(job.id, job);
     return job;
   }
-  pendingBlockMessages() {
+  threadOpenTail(threadId) {
+    return this.openTail.filter((message) => message.threadId === threadId);
+  }
+  threadBlocks(threadId) {
+    return this.blocks.filter((block) => block.threadId === threadId);
+  }
+  threadTurn(threadId) {
+    const sealedTurns = this.threadBlocks(threadId).reduce((total, block) => total + block.l5Raw.filter((message) => message.role === "user").length, 0);
+    return sealedTurns + this.threadOpenTail(threadId).filter((message) => message.role === "user").length;
+  }
+  nextSealableThread() {
+    const counts = [];
+    for (const message of this.openTail) {
+      if (message.role !== "user") continue;
+      let entry = counts.find((candidate) => candidate.threadId === message.threadId);
+      if (!entry) {
+        entry = { threadId: message.threadId, users: 0 };
+        counts.push(entry);
+      }
+      entry.users += 1;
+      if (entry.users >= this.blockTurnSize) return { threadId: entry.threadId };
+    }
+    return null;
+  }
+  nextBlockInThread(block) {
+    const index = this.blocks.indexOf(block);
+    return this.blocks.slice(index + 1).find((candidate) => candidate.threadId === block.threadId) ?? null;
+  }
+  pendingBlockMessages(threadId) {
+    const messages = this.threadOpenTail(threadId);
     let users = 0;
-    let end = this.openTail.length;
-    for (const [index, message] of this.openTail.entries()) {
+    let end = messages.length;
+    for (const [index, message] of messages.entries()) {
       if (message.role !== "user") continue;
       users += 1;
       if (users !== this.blockTurnSize) continue;
-      const nextUserOffset = this.openTail.slice(index + 1).findIndex((candidate) => candidate.role === "user");
-      end = nextUserOffset === -1 ? this.openTail.length : index + 1 + nextUserOffset;
+      const nextUserOffset = messages.slice(index + 1).findIndex((candidate) => candidate.role === "user");
+      end = nextUserOffset === -1 ? messages.length : index + 1 + nextUserOffset;
       break;
     }
-    return this.openTail.slice(0, end);
+    return messages.slice(0, end);
   }
-  async sealOpenTail() {
-    const raw = this.pendingBlockMessages();
+  async sealOpenTail(threadId) {
+    const raw = this.pendingBlockMessages(threadId);
     if (raw.filter((message) => message.role === "user").length < this.blockTurnSize) {
       throw new Error("Open tail does not contain enough turns to seal a block");
     }
     const generated = this.summarizer ? await this.summarizer(raw) : defaultSummary(raw);
     const deterministic = deterministicBlockLayers(raw);
     const sequence = this.blocks.length + 1;
-    const startTurn = this.blocks.at(-1)?.endTurn !== void 0 ? (this.blocks.at(-1)?.endTurn ?? 0) + 1 : 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(() => {
-      const currentRaw = this.pendingBlockMessages();
+      const currentRaw = this.pendingBlockMessages(threadId);
       if (!sameIds(currentRaw.map((message) => message.id), raw.map((message) => message.id))) {
         throw new Error("Open tail changed while the block summary was being prepared");
       }
       const block = {
         id: this.idFactory("blk"),
+        ...threadId ? { threadId } : {},
         sequence,
         startTurn,
         endTurn,
@@ -2171,26 +2353,29 @@ var StrataGate = class _StrataGate {
         ...deterministic,
         pointerCurrentLevel: 5,
         pointerAnchorLevel: 5,
-        pointerAnchorTurn: endTurn,
+        pointerAnchorBlockPosition: blockPosition,
         lastLiftedAt: null
       };
-      this.openTail.splice(0, raw.length);
+      const sealedIds = new Set(raw.map((message) => message.id));
+      const remaining = this.openTail.filter((message) => !sealedIds.has(message.id));
+      this.openTail.splice(0, this.openTail.length, ...remaining);
       this.blocks.push(block);
       return block;
     });
   }
   async extractEligibleBlock(options = {}) {
     if (!this.extractor || this.blocks.length < 2) return null;
-    const targetIndex = this.blocks.findIndex((block, index) => {
-      if (index >= this.blocks.length - 1 || !block.shouldExtract) return false;
+    const target = this.blocks.find((block) => {
+      if (this.nextBlockInThread(block) === null || !block.shouldExtract) return false;
       if (options.blockId !== void 0 && block.id !== options.blockId) return false;
       const status = this.extractionJobs.get(block.id)?.status;
       return status === void 0 || status === "failed" || options.includeSkipped === true && status === "skipped";
     });
-    if (targetIndex < 0) return null;
-    const target = this.blocks[targetIndex];
-    const next = this.blocks[targetIndex + 1];
-    if (!target || !next) return null;
+    if (!target) return null;
+    const threadBlocks = this.threadBlocks(target.threadId);
+    const targetIndex = threadBlocks.indexOf(target);
+    const next = threadBlocks[targetIndex + 1];
+    if (!next) return null;
     const existing = this.extractionJobs.get(target.id);
     await this.commitMutation(() => {
       const currentStatus = this.extractionJobs.get(target.id)?.status;
@@ -2209,7 +2394,7 @@ var StrataGate = class _StrataGate {
     let result;
     try {
       result = await this.extractor({
-        previous: this.blocks[targetIndex - 1] ?? null,
+        previous: threadBlocks[targetIndex - 1] ?? null,
         target,
         next,
         timeline: this.events.map((event) => ({ id: event.id, title: event.title, temporal: event.temporal }))
@@ -2305,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);
@@ -2950,6 +3136,7 @@ var TurnFolder = class {
         return {
           user: pending.user.join("\n\n"),
           assistant: pending.assistant.join("\n\n") || reasonLabel(event.data.reason),
+          threadId: sessionId,
           assistantToolCalls: [...pending.tools.values()],
           createdAt: toUtc8Iso(event.time),
           receiptId: `dsh:${sessionId}:turn:${event.data.turn}`
@@ -2974,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;
@@ -2982,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;
@@ -2997,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;
@@ -3045,7 +3294,7 @@ var StrataGateRuntime = class {
   }
   async blocks(session) {
     await this.flush();
-    const results = (await this.space(session)).getBlockContext();
+    const results = (await this.space(session)).getBlockContext(String(session.id));
     return this.batch(session, results.map((result) => ({
       ref: `block:${result.id}:level:${result.level}`,
       target: { eventIds: [], elementIds: [] }
@@ -3167,7 +3416,8 @@ var StrataGateRuntime = class {
   async buildAutoContext(session) {
     await this.flush();
     const memory = await this.space(session);
-    const openTail = memory.listOpenTail();
+    const threadId = String(session.id);
+    const openTail = memory.listOpenTail(threadId);
     const activationQuery = [currentUserMessage(session), renderMessages(recentTurns(openTail, 2))].filter(Boolean).join("\n\n");
     const [eventHits, elementHits] = activationQuery ? await Promise.all([
       memory.searchEvents(activationQuery, { limit: 20 }),
@@ -3180,7 +3430,7 @@ var StrataGateRuntime = class {
       openTail.length > 0 ? renderMessages(openTail) : "(open tail is empty)",
       "",
       "[Decayed memory blocks]",
-      renderBlocks2(memory.getBlockContext()),
+      renderBlocks2(memory.getBlockContext(threadId)),
       "",
       renderActivatedMemory(events, elements)
     ].join("\n");
@@ -3220,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 {
@@ -3247,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
@@ -3279,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();
@@ -3335,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");
 }
@@ -3709,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,
@@ -3725,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() ?? "";
@@ -3850,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));
@@ -3896,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();