stratagate-dsh 0.2.15 → 0.2.16

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.2.16 - 2026-08-21
+
+- Isolate open tails, Block sealing, decay, and automatic Block context by DSH session while keeping Events and Elements project-scoped for cross-session recall.
+- Migrate SQLite storage to schema v5 with optional thread ownership on raw messages and Blocks; pre-v5 Blocks remain unowned archival provenance instead of being injected into new sessions.
+
 ## 0.2.15 - 2026-08-21
 
 - Disable reasoning for internal structured memory workers because the current DSH adapters do not map `tool_choice` to the provider request.

package/README.md

@@ -1,6 +1,6 @@
 # StrataGate for DeepSeek Harness
 
-[English](README.md) · [简体中文](README.zh-CN.md)
+[English](README.md) · [简体中文](docs/README.zh-CN.md)
 
 Automatic, local-first cross-session memory for DeepSeek Harness. StrataGate remembers user preferences, project decisions, completed conversations, and tool results, then checks recalled evidence and can expand it back to the original messages before the agent answers. No separate memory server is required.
 
@@ -70,9 +70,9 @@ Removing the plugin does not delete that database.
 - Subagent turns are not ingested by default; subagents in the same project can still read project memory.
 - Each DSH turn has a durable ingestion receipt, so replay or retry cannot store it twice.
 - StrataGate performs the existing Block summarization, Event extraction, Element projection, search, Evidence Gate, and use-only reinforcement.
-- Before every main-model call, the plugin injects the complete open tail, each sealed Block at its current decay-pointer level, and up to four activated Events plus four active Element facts.
+- Before every main-model call, the plugin injects only the current session's open tail and sealed Blocks, plus up to four project-scoped activated Events and four active Element facts. Blocks remain persisted as source evidence, but they are never automatically carried into another session.
 
-Activated memory uses the current human message plus the latest two open-tail turns as its query. Existing BM25 search remains the lexical relevance gate; pinned and safety memory are the only exceptions. Existing memory weights provide a second ranking, and RRF fuses the relevance and weight rankings. The activated section has a fixed budget of about 900 tokens, so it does not grow with the database.
+Activated memory uses the current human message plus the latest two open-tail turns from the current session as its query. Existing BM25 search remains the lexical relevance gate; pinned and safety memory are the only exceptions. Existing memory weights provide a second ranking, and RRF fuses the relevance and weight rankings. The activated section has a fixed budget of about 900 tokens, so it does not grow with the database.
 
 Automatic context contains only compact Event and fact fields and is explicitly marked as historical background rather than instructions. Building it never calls `recordMemoryUse`, increments `mentionCount`, or changes `lastAdoptedTurn`. The existing `memory_*` tools remain available for deeper, evidence-gated retrieval and are the only path to adoption reinforcement.
 

package/dist/index.js

@@ -358,7 +358,7 @@ function rrfRank(rankings) {
 }
 
 // ../../src/storage.ts
-var STRATAGATE_STORAGE_SCHEMA_VERSION = 4;
+var STRATAGATE_STORAGE_SCHEMA_VERSION = 5;
 var StorageConflictError = class extends Error {
   constructor(namespace, expectedRevision, actualRevision) {
     super(`Storage revision conflict for ${namespace}: expected ${expectedRevision}, found ${actualRevision ?? "missing"}`);
@@ -399,6 +399,11 @@ function normalizeSnapshot(value) {
       ...structuredClone(value),
       schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION
     };
+  } else if (schemaVersion === 4) {
+    snapshot = {
+      ...structuredClone(value),
+      schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION
+    };
   } else if (schemaVersion === STRATAGATE_STORAGE_SCHEMA_VERSION) {
     snapshot = structuredClone(value);
   } else {
@@ -594,6 +599,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,
@@ -618,6 +624,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 +788,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);
@@ -828,7 +839,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 +850,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 +865,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,
@@ -1099,11 +1112,12 @@ var SqliteStorage = class {
     }
     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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ) 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,
@@ -1124,6 +1138,7 @@ var SqliteStorage = class {
       insertBlock.run(
         namespace,
         block.id,
+        block.threadId ?? null,
         block.sequence,
         block.startTurn,
         block.endTurn,
@@ -1143,10 +1158,11 @@ var SqliteStorage = class {
     }
     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 +1175,7 @@ var SqliteStorage = class {
           namespace,
           message.id,
           blockId,
+          message.threadId ?? null,
           position,
           message.role,
           message.content,
@@ -1402,9 +1419,10 @@ 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) {
       this.immediateTransaction(() => {
         if (version === 1) {
           const receiptColumns2 = this.database.prepare("PRAGMA table_info('usage_receipts')").all();
@@ -1417,11 +1435,21 @@ var SqliteStorage = class {
           this.database.exec("ALTER TABLE usage_receipts ADD COLUMN audit_json TEXT NOT NULL DEFAULT '{}'");
         }
         this.database.exec(SCHEMA);
+        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");
+        }
+        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();
   }
@@ -1634,8 +1662,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()];
@@ -1685,12 +1714,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 +1732,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 +1746,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 +1759,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 +1773,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,12 +1992,15 @@ 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 currentTurn = block.threadId === void 0 ? this.currentTurn : this.threadTurn(block.threadId);
+      const level = getDecayedBlockLevel(block.pointerAnchorLevel, block.pointerAnchorTurn, currentTurn);
       block.pointerCurrentLevel = level;
       return {
         id: block.id,
+        ...block.threadId ? { threadId: block.threadId } : {},
         turnRange: [block.startTurn, block.endTurn],
         level,
         label: blockLevelLabel(level),
@@ -1972,14 +2012,16 @@ 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 currentTurn = block.threadId === void 0 ? this.currentTurn : this.threadTurn(block.threadId);
+      const current = getDecayedBlockLevel(block.pointerAnchorLevel, block.pointerAnchorTurn, currentTurn);
       const level = normalizeBlockLevel(target, current);
       block.pointerCurrentLevel = level;
       block.pointerAnchorLevel = level;
-      block.pointerAnchorTurn = this.currentTurn;
+      block.pointerAnchorTurn = currentTurn;
       block.lastLiftedAt = toUtc8Iso(this.now());
       return {
         id: block.id,
+        ...block.threadId ? { threadId: block.threadId } : {},
         turnRange: [block.startTurn, block.endTurn],
         level,
         label: blockLevelLabel(level),
@@ -2129,36 +2171,67 @@ 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 previous = this.threadBlocks(threadId).at(-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,
@@ -2174,23 +2247,26 @@ var StrataGate = class _StrataGate {
         pointerAnchorTurn: endTurn,
         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 +2285,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 }))
@@ -2950,6 +3026,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}`
@@ -3045,7 +3122,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 +3244,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 +3258,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");