stratagate-dsh 0.2.35 → 0.2.37

package/dist/index.js

@@ -15,7 +15,8 @@ var Config = z.object({
   ingestSubagents: z.boolean().default(false),
   provider: z.string(),
   model: z.string(),
-  maxOutputTokens: z.natural().min(256).default(1e4)
+  maxOutputTokens: z.natural().min(256).default(2048),
+  structuredTaskTimeoutMs: z.natural().min(1e3).default(45e3)
 });
 function resolveConfig(config) {
   const database = config.database?.trim() ?? "";
@@ -36,7 +37,8 @@ function resolveConfig(config) {
     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))
+    maxOutputTokens: Math.max(256, Math.floor(config.maxOutputTokens ?? 2048)),
+    structuredTaskTimeoutMs: Math.max(1e3, Math.floor(config.structuredTaskTimeoutMs ?? 45e3))
   };
 }
 
@@ -45,7 +47,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { BlockAssembler, createUserMessage } from "@deepseek-ai/dsh-llm";
 import { parameterSchemaSpecToJsonSchema, validateArgs } from "@deepseek-ai/dsh-tools";
 
-// ../../src/blocks.ts
+// packages/core/src/blocks.ts
 var DEFAULT_BLOCK_TURN_SIZE = 12;
 var BLOCK_MAX_LEVEL = 5;
 var BLOCK_DECAY_LAMBDA = 0.3;
@@ -252,7 +254,7 @@ function deterministicBlockLayers(messages) {
   };
 }
 
-// ../../src/search.ts
+// packages/core/src/search.ts
 var wordSegmenter = new Intl.Segmenter(void 0, { granularity: "word" });
 function normalizeSearchText(value) {
   return value.normalize("NFKC").toLocaleLowerCase().replace(/\s+/g, " ").trim();
@@ -329,7 +331,7 @@ function rrfRank(rankings) {
   return [...fused.values()].sort((left, right) => right.score - left.score || left.bestRank - right.bestRank || left.item.id.localeCompare(right.item.id)).map(({ item, score }) => ({ item, score }));
 }
 
-// ../../src/graph.ts
+// packages/core/src/graph.ts
 var NODE_TYPES = /* @__PURE__ */ new Set(["person", "project", "organization", "tool", "place"]);
 var STATUSES = /* @__PURE__ */ new Set(["active", "superseded", "disputed", "archived"]);
 function text(value, limit = 240) {
@@ -467,7 +469,7 @@ function applyGraphProjection(options) {
   return { nodeIds: [...touchedNodes], edgeIds: [...touchedEdges] };
 }
 
-// ../../src/events.ts
+// packages/core/src/events.ts
 function normalizeStandardEventType(value) {
   const normalized = normalizeSearchText(value ?? "").replace(/[\s_-]+/g, "");
   const aliases = {
@@ -505,7 +507,7 @@ function normalizeStandardEventType(value) {
   return aliases[normalized] ?? "other";
 }
 
-// ../../src/external-memory.ts
+// packages/core/src/external-memory.ts
 var EXTERNAL_MEMORY_EXPORT_SCHEMA = "stratagate.external-memory.v2";
 var EXTERNAL_MEMORY_DECIDER_PROMPT_ZH_CN = `
 \u4F60\u662F StrataGate \u7684\u5916\u90E8\u8BB0\u5FC6\u5408\u5E76\u88C1\u51B3\u5668\u3002\u8F93\u5165\u5305\u542B\u4E00\u4E2A\u5916\u90E8 candidate Event\uFF0C\u4EE5\u53CA\u672C\u5730\u68C0\u7D22\u5F97\u5230\u7684 Top-K existing Events\u3002\u53EA\u80FD\u4F9D\u636E candidate \u548C existing Events \u5224\u65AD\uFF0C\u4E0D\u5F97\u5F15\u5165\u5217\u8868\u4E4B\u5916\u7684\u672C\u5730\u4E8B\u4EF6\uFF0C\u4E5F\u4E0D\u5F97\u51ED\u5E38\u8BC6\u8865\u5168\u65F6\u95F4\u3002
@@ -1184,7 +1186,7 @@ function parseExternalMemoryExport(text3) {
 }
 var externalMemoryJsonExtractor = async ({ text: text3 }) => parseExternalMemoryExport(text3);
 
-// ../../src/retrieval.ts
+// packages/core/src/retrieval.ts
 var RETRIEVAL_STRATEGIES = [
   "answer",
   "search_events",
@@ -1260,8 +1262,8 @@ function normalizeRetrievalAssessment(input, batchEvidenceRefs) {
   };
 }
 
-// ../../src/storage.ts
-var STRATAGATE_STORAGE_SCHEMA_VERSION = 8;
+// packages/core/src/storage.ts
+var STRATAGATE_STORAGE_SCHEMA_VERSION = 9;
 var KNOWLEDGE_GRAPH_PROJECTOR_VERSION = 1;
 var StorageConflictError = class extends Error {
   constructor(namespace, expectedRevision, actualRevision) {
@@ -1278,6 +1280,12 @@ var StorageConflictError = class extends Error {
 function cloneSnapshot(snapshot) {
   return structuredClone(snapshot);
 }
+function readyLegacyBlocks(blocks) {
+  return blocks.map((block) => ({ ...structuredClone(block), processingStatus: "ready" }));
+}
+function legacyExtractionJobs(jobs) {
+  return jobs.map((job) => ({ ...structuredClone(job), nextRetryAt: null }));
+}
 function emptyGraph() {
   return { graphNodes: [], graphEdges: [], graphProjectionJobs: [] };
 }
@@ -1285,7 +1293,7 @@ function migrateLegacyBlocks(blocks) {
   return blocks.map((block) => {
     const { pointerAnchorTurn, ...current } = block;
     const position = blocks.filter((candidate) => candidate.threadId === block.threadId && candidate.endTurn <= pointerAnchorTurn).length;
-    return { ...current, pointerAnchorBlockPosition: Math.max(1, position), lastLiftedBy: null };
+    return { ...current, processingStatus: "ready", pointerAnchorBlockPosition: Math.max(1, position), lastLiftedBy: null };
   });
 }
 function normalizeSnapshot(value) {
@@ -1299,6 +1307,8 @@ function normalizeSnapshot(value) {
       schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
       blockDecayLambda: BLOCK_DECAY_LAMBDA,
       blocks: migrateLegacyBlocks(legacy.blocks),
+      summaryJobs: [],
+      extractionJobs: legacyExtractionJobs(legacy.extractionJobs),
       elements: [],
       elementProjectionJobs: [],
       usageReceipts: Array.isArray(legacy.usageReceipts) ? legacy.usageReceipts.map((receipt) => ({ ...receipt, elementIds: [] })) : [],
@@ -1312,6 +1322,8 @@ function normalizeSnapshot(value) {
       schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
       blockDecayLambda: BLOCK_DECAY_LAMBDA,
       blocks: migrateLegacyBlocks(legacy.blocks),
+      summaryJobs: [],
+      extractionJobs: legacyExtractionJobs(legacy.extractionJobs),
       ingestionReceipts: [],
       ...emptyGraph()
     };
@@ -1322,6 +1334,8 @@ function normalizeSnapshot(value) {
       schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
       blockDecayLambda: BLOCK_DECAY_LAMBDA,
       blocks: migrateLegacyBlocks(legacy.blocks),
+      summaryJobs: [],
+      extractionJobs: legacyExtractionJobs(legacy.extractionJobs),
       ...emptyGraph()
     };
   } else if (schemaVersion === 4) {
@@ -1331,6 +1345,8 @@ function normalizeSnapshot(value) {
       schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
       blockDecayLambda: BLOCK_DECAY_LAMBDA,
       blocks: migrateLegacyBlocks(legacy.blocks),
+      summaryJobs: [],
+      extractionJobs: legacyExtractionJobs(legacy.extractionJobs),
       ...emptyGraph()
     };
   } else if (schemaVersion === 5) {
@@ -1340,6 +1356,8 @@ function normalizeSnapshot(value) {
       schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
       blockDecayLambda: BLOCK_DECAY_LAMBDA,
       blocks: migrateLegacyBlocks(legacy.blocks),
+      summaryJobs: [],
+      extractionJobs: legacyExtractionJobs(legacy.extractionJobs),
       ...emptyGraph()
     };
   } else if (schemaVersion === 6) {
@@ -1347,12 +1365,30 @@ function normalizeSnapshot(value) {
     snapshot = {
       ...structuredClone(legacy),
       schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
-      blocks: legacy.blocks.map((block) => ({ ...structuredClone(block), lastLiftedBy: null })),
+      blocks: readyLegacyBlocks(legacy.blocks.map((block) => ({ ...structuredClone(block), lastLiftedBy: null }))),
+      summaryJobs: [],
+      extractionJobs: legacyExtractionJobs(legacy.extractionJobs),
       ...emptyGraph()
     };
   } else if (schemaVersion === 7) {
     const legacy = value;
-    snapshot = { ...structuredClone(legacy), schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION, ...emptyGraph() };
+    snapshot = {
+      ...structuredClone(legacy),
+      schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
+      blocks: readyLegacyBlocks(legacy.blocks),
+      summaryJobs: [],
+      extractionJobs: legacyExtractionJobs(legacy.extractionJobs),
+      ...emptyGraph()
+    };
+  } else if (schemaVersion === 8) {
+    const legacy = value;
+    snapshot = {
+      ...structuredClone(legacy),
+      schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
+      blocks: readyLegacyBlocks(legacy.blocks),
+      summaryJobs: [],
+      extractionJobs: legacyExtractionJobs(legacy.extractionJobs)
+    };
   } else if (schemaVersion === STRATAGATE_STORAGE_SCHEMA_VERSION) {
     snapshot = structuredClone(value);
   } else {
@@ -1367,7 +1403,7 @@ function normalizeSnapshot(value) {
   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", "graphNodes", "graphEdges", "graphProjectionJobs", "elements", "extractionJobs", "elementProjectionJobs", "usageReceipts", "ingestionReceipts"]) {
+  for (const key of ["openTail", "blocks", "summaryJobs", "events", "graphNodes", "graphEdges", "graphProjectionJobs", "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 = [];
@@ -1375,6 +1411,12 @@ function normalizeSnapshot(value) {
     event.temporal = { ...event.temporal, eventType: normalizeStandardEventType(event.temporal.eventType) };
   }
   for (const block of snapshot.blocks) {
+    if (block.processingStatus !== "pending" && block.processingStatus !== "ready") {
+      throw new TypeError("Invalid StrataGate snapshot: Block processingStatus must be pending or ready");
+    }
+    if (block.processingStatus === "ready" && (!block.l0Title || !block.l1Summary || !Array.isArray(block.l0Tags) || !Array.isArray(block.l2Keypoints) || typeof block.shouldExtract !== "boolean")) {
+      throw new TypeError("Invalid StrataGate snapshot: ready Block must contain validated L0-L2 layers");
+    }
     if (!Number.isSafeInteger(block.pointerAnchorBlockPosition) || block.pointerAnchorBlockPosition < 1) {
       throw new TypeError("Invalid StrataGate snapshot: pointerAnchorBlockPosition must be a positive integer");
     }
@@ -1391,7 +1433,7 @@ function assertValidSnapshot(value) {
   normalizeSnapshot(value);
 }
 
-// ../../src/weights.ts
+// packages/core/src/weights.ts
 var BASE_DECAY = 0.15;
 var REHEARSAL_FACTOR = 1.5;
 function criticalityFloor(criticality) {
@@ -1410,7 +1452,7 @@ function memoryWeightAt(memory, currentTurn) {
   return memory.weight.pinned ? 1 : capped;
 }
 
-// ../../src/elements.ts
+// packages/core/src/elements.ts
 var ELEMENT_TYPES = /* @__PURE__ */ new Set(["person", "project", "organization", "tool", "place"]);
 var FACT_MODES = /* @__PURE__ */ new Set(["state", "set", "relation"]);
 function compactText(value, limit) {
@@ -1533,10 +1575,10 @@ function elementViewAt(element, at) {
   return view;
 }
 
-// ../../src/sqlite.ts
+// packages/core/src/sqlite.ts
 import { DatabaseSync } from "node:sqlite";
 
-// ../../src/time.ts
+// packages/core/src/time.ts
 var UTC8_OFFSET_MS = 8 * 60 * 60 * 1e3;
 function toUtc8Iso(value = /* @__PURE__ */ new Date()) {
   const date = value instanceof Date ? new Date(value.getTime()) : new Date(value);
@@ -1547,7 +1589,7 @@ function nowUtc8() {
   return toUtc8Iso(/* @__PURE__ */ new Date());
 }
 
-// ../../src/sqlite.ts
+// packages/core/src/sqlite.ts
 var SCHEMA = `
 CREATE TABLE IF NOT EXISTS memory_spaces (
   namespace TEXT PRIMARY KEY,
@@ -1580,6 +1622,7 @@ CREATE TABLE IF NOT EXISTS blocks (
   pointer_anchor_block_position INTEGER NOT NULL,
   last_lifted_at TEXT,
   last_lifted_by TEXT CHECK (last_lifted_by IS NULL OR last_lifted_by IN ('user', 'agent')),
+  processing_status TEXT NOT NULL CHECK (processing_status IN ('pending', 'ready')),
   PRIMARY KEY (namespace, id),
   UNIQUE (namespace, sequence),
   FOREIGN KEY (namespace) REFERENCES memory_spaces(namespace) ON DELETE CASCADE
@@ -1704,6 +1747,19 @@ CREATE TABLE IF NOT EXISTS extraction_jobs (
   status TEXT NOT NULL,
   attempts INTEGER NOT NULL,
   last_error TEXT,
+  next_retry_at TEXT,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (namespace, block_id),
+  FOREIGN KEY (namespace, block_id) REFERENCES blocks(namespace, id) ON DELETE CASCADE
+) STRICT;
+
+CREATE TABLE IF NOT EXISTS block_summary_jobs (
+  namespace TEXT NOT NULL,
+  block_id TEXT NOT NULL,
+  status TEXT NOT NULL,
+  attempts INTEGER NOT NULL,
+  last_error TEXT,
+  next_retry_at TEXT,
   updated_at TEXT NOT NULL,
   PRIMARY KEY (namespace, block_id),
   FOREIGN KEY (namespace, block_id) REFERENCES blocks(namespace, id) ON DELETE CASCADE
@@ -1844,11 +1900,14 @@ var SqliteStorage = class {
       startTurn: row.start_turn,
       endTurn: row.end_turn,
       createdAt: row.created_at,
-      shouldExtract: Boolean(row.should_extract),
-      l0Title: row.l0_title,
-      l0Tags: parseJson(row.l0_tags_json, "blocks.l0_tags_json"),
-      l1Summary: row.l1_summary,
-      l2Keypoints: parseJson(row.l2_keypoints_json, "blocks.l2_keypoints_json"),
+      processingStatus: row.processing_status,
+      ...row.l0_title ? {
+        shouldExtract: Boolean(row.should_extract),
+        l0Title: row.l0_title,
+        l0Tags: parseJson(row.l0_tags_json, "blocks.l0_tags_json"),
+        l1Summary: row.l1_summary,
+        l2Keypoints: parseJson(row.l2_keypoints_json, "blocks.l2_keypoints_json")
+      } : {},
       l3Condensed: row.l3_condensed,
       l4Readable: row.l4_readable,
       l5Raw: messagesByBlock.get(row.id) ?? [],
@@ -1858,6 +1917,17 @@ var SqliteStorage = class {
       lastLiftedAt: row.last_lifted_at,
       lastLiftedBy: row.last_lifted_by
     }));
+    const summaryJobs = this.database.prepare(`
+      SELECT block_id, status, attempts, last_error, next_retry_at, updated_at
+      FROM block_summary_jobs WHERE namespace = ? ORDER BY block_id
+    `).all(key).map((row) => ({
+      blockId: row.block_id,
+      status: row.status,
+      attempts: row.attempts,
+      lastError: row.last_error,
+      nextRetryAt: row.next_retry_at,
+      updatedAt: row.updated_at
+    }));
     const sourceRows = this.database.prepare(`
       SELECT event_id, message_id, position FROM event_sources
       WHERE namespace = ? ORDER BY event_id, position
@@ -1969,13 +2039,14 @@ var SqliteStorage = class {
       };
     });
     const extractionJobs = this.database.prepare(`
-      SELECT block_id, status, attempts, last_error, updated_at
+      SELECT block_id, status, attempts, last_error, next_retry_at, updated_at
       FROM extraction_jobs WHERE namespace = ? ORDER BY block_id
     `).all(key).map((row) => ({
       blockId: row.block_id,
       status: row.status,
       attempts: row.attempts,
       lastError: row.last_error,
+      nextRetryAt: row.next_retry_at,
       updatedAt: row.updated_at
     }));
     const elementProjectionJobs = this.database.prepare(`
@@ -2034,6 +2105,7 @@ var SqliteStorage = class {
       blockDecayLambda: space.block_decay_lambda,
       openTail,
       blocks,
+      summaryJobs,
       events,
       graphNodes,
       graphEdges,
@@ -2104,8 +2176,9 @@ var SqliteStorage = class {
       INSERT INTO blocks (
         namespace, id, thread_id, sequence, start_turn, end_turn, created_at, should_extract,
         l0_title, l0_tags_json, l1_summary, l2_keypoints_json, l3_condensed, l4_readable,
-        pointer_current_level, pointer_anchor_level, pointer_anchor_block_position, last_lifted_at, last_lifted_by
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        pointer_current_level, pointer_anchor_level, pointer_anchor_block_position, last_lifted_at, last_lifted_by,
+        processing_status
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT (namespace, id) DO UPDATE SET
         thread_id = excluded.thread_id,
         sequence = excluded.sequence,
@@ -2123,7 +2196,8 @@ var SqliteStorage = class {
         pointer_anchor_level = excluded.pointer_anchor_level,
         pointer_anchor_block_position = excluded.pointer_anchor_block_position,
         last_lifted_at = excluded.last_lifted_at,
-        last_lifted_by = excluded.last_lifted_by
+        last_lifted_by = excluded.last_lifted_by,
+        processing_status = excluded.processing_status
     `);
     for (const block of snapshot.blocks) {
       insertBlock.run(
@@ -2134,18 +2208,19 @@ var SqliteStorage = class {
         block.startTurn,
         block.endTurn,
         block.createdAt,
-        Number(block.shouldExtract),
-        block.l0Title,
-        JSON.stringify(block.l0Tags),
-        block.l1Summary,
-        JSON.stringify(block.l2Keypoints),
+        Number(block.shouldExtract ?? false),
+        block.l0Title ?? "",
+        JSON.stringify(block.l0Tags ?? []),
+        block.l1Summary ?? "",
+        JSON.stringify(block.l2Keypoints ?? []),
         block.l3Condensed,
         block.l4Readable,
         block.pointerCurrentLevel,
         block.pointerAnchorLevel,
         block.pointerAnchorBlockPosition,
         block.lastLiftedAt,
-        block.lastLiftedBy
+        block.lastLiftedBy,
+        block.processingStatus
       );
     }
     const insertMessage = this.database.prepare(`
@@ -2331,16 +2406,31 @@ var SqliteStorage = class {
     }
     const insertJob = this.database.prepare(`
       INSERT INTO extraction_jobs (
-        namespace, block_id, status, attempts, last_error, updated_at
-      ) VALUES (?, ?, ?, ?, ?, ?)
+        namespace, block_id, status, attempts, last_error, next_retry_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT (namespace, block_id) DO UPDATE SET
         status = excluded.status,
         attempts = excluded.attempts,
         last_error = excluded.last_error,
+        next_retry_at = excluded.next_retry_at,
         updated_at = excluded.updated_at
     `);
     for (const job of snapshot.extractionJobs) {
-      insertJob.run(namespace, job.blockId, job.status, job.attempts, job.lastError, job.updatedAt);
+      insertJob.run(namespace, job.blockId, job.status, job.attempts, job.lastError, job.nextRetryAt, job.updatedAt);
+    }
+    const insertSummaryJob = this.database.prepare(`
+      INSERT INTO block_summary_jobs (
+        namespace, block_id, status, attempts, last_error, next_retry_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT (namespace, block_id) DO UPDATE SET
+        status = excluded.status,
+        attempts = excluded.attempts,
+        last_error = excluded.last_error,
+        next_retry_at = excluded.next_retry_at,
+        updated_at = excluded.updated_at
+    `);
+    for (const job of snapshot.summaryJobs) {
+      insertSummaryJob.run(namespace, job.blockId, job.status, job.attempts, job.lastError, job.nextRetryAt, job.updatedAt);
     }
     const insertElementProjectionJob = this.database.prepare(`
       INSERT INTO element_projection_jobs (
@@ -2429,7 +2519,7 @@ var SqliteStorage = class {
         this.database.exec(THREAD_INDEXES);
         this.database.exec(`PRAGMA user_version = ${STRATAGATE_STORAGE_SCHEMA_VERSION}`);
       });
-    } else if (version === 1 || version === 2 || version === 3 || version === 4 || version === 5 || version === 6 || version === 7) {
+    } else if (version >= 1 && version < STRATAGATE_STORAGE_SCHEMA_VERSION) {
       this.immediateTransaction(() => {
         this.database.exec(SCHEMA);
         if (version === 1) {
@@ -2465,6 +2555,13 @@ var SqliteStorage = class {
         if (!blockColumns.some(({ name: name2 }) => name2 === "last_lifted_by")) {
           this.database.exec("ALTER TABLE blocks ADD COLUMN last_lifted_by TEXT CHECK (last_lifted_by IS NULL OR last_lifted_by IN ('user', 'agent'))");
         }
+        if (!blockColumns.some(({ name: name2 }) => name2 === "processing_status")) {
+          this.database.exec("ALTER TABLE blocks ADD COLUMN processing_status TEXT NOT NULL DEFAULT 'ready' CHECK (processing_status IN ('pending', 'ready'))");
+        }
+        const extractionColumns = this.database.prepare("PRAGMA table_info('extraction_jobs')").all();
+        if (!extractionColumns.some(({ name: name2 }) => name2 === "next_retry_at")) {
+          this.database.exec("ALTER TABLE extraction_jobs ADD COLUMN next_retry_at 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");
@@ -2512,7 +2609,7 @@ var SqliteStorage = class {
   }
 };
 
-// ../../src/store.ts
+// packages/core/src/store.ts
 function defaultIdFactory(prefix) {
   return `${prefix}_${crypto.randomUUID()}`;
 }
@@ -2522,21 +2619,13 @@ function defaultElementIdFactory(prefix) {
 function defaultGraphIdFactory(prefix) {
   return `${prefix}_${crypto.randomUUID()}`;
 }
-function defaultSummary(messages) {
-  const natural = messages.filter((message) => message.role === "user" || message.role === "assistant");
-  const firstUser = natural.find((message) => message.role === "user");
-  return {
-    l0Title: (firstUser?.content ?? "Conversation block").replace(/\s+/g, " ").trim().slice(0, 80),
-    l0Tags: [],
-    l1Summary: natural.slice(0, 4).map((message) => message.content.replace(/\s+/g, " ").trim()).join(" ").slice(0, 500),
-    l2Keypoints: natural.slice(0, 8).map((message) => message.content.replace(/\s+/g, " ").trim().slice(0, 160)),
-    shouldExtract: false
-  };
-}
 function renderBlock(block, level) {
+  if (block.processingStatus !== "ready" || !block.l0Title || !block.l0Tags || !block.l1Summary || !block.l2Keypoints) {
+    throw new Error(`Block ${block.id} is not ready for rendering`);
+  }
   if (level === 0) return `${block.l0Title}
 Tags: ${block.l0Tags.join(", ") || "none"}`;
-  if (level === 1) return block.l1Summary || block.l0Title;
+  if (level === 1) return block.l1Summary;
   if (level === 2) return block.l2Keypoints.map((point) => `- ${point}`).join("\n") || block.l1Summary;
   if (level === 3) return block.l3Condensed;
   if (level === 4) return block.l4Readable;
@@ -2553,8 +2642,10 @@ function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 var STRATAGATE_CONSTRUCTOR_TOKEN = /* @__PURE__ */ Symbol("StrataGate constructor");
+var DERIVATION_MAX_ATTEMPTS = 3;
+var DERIVATION_BACKOFF_MS = 1e3;
 var StrataGate = class _StrataGate {
-  blockTurnSize;
+  blockTurnSizeValue;
   blockDecayLambdaValue;
   summarizer;
   extractor;
@@ -2572,6 +2663,7 @@ var StrataGate = class _StrataGate {
   graphNodes = [];
   graphEdges = [];
   extractionJobs = /* @__PURE__ */ new Map();
+  summaryJobs = /* @__PURE__ */ new Map();
   elementProjectionJobs = /* @__PURE__ */ new Map();
   graphProjectionJobs = /* @__PURE__ */ new Map();
   usageReceipts = /* @__PURE__ */ new Map();
@@ -2586,7 +2678,7 @@ var StrataGate = class _StrataGate {
     if (token !== STRATAGATE_CONSTRUCTOR_TOKEN) {
       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));
+    this.blockTurnSizeValue = 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");
@@ -2680,6 +2772,21 @@ var StrataGate = class _StrataGate {
     if (loaded && loadedSnapshot) {
       memory.restoreSnapshot(loadedSnapshot);
       memory.revision = loadedRevision;
+      const interruptedSummaries = [...memory.summaryJobs.values()].filter((job) => job.status === "running");
+      if (interruptedSummaries.length > 0) {
+        await memory.commitMutation(() => {
+          const now = toUtc8Iso(memory.now());
+          for (const job of interruptedSummaries) {
+            memory.summaryJobs.set(job.blockId, {
+              ...job,
+              status: "failed",
+              lastError: "Block summarization was interrupted before completion.",
+              nextRetryAt: now,
+              updatedAt: now
+            });
+          }
+        });
+      }
       const interrupted = [...memory.extractionJobs.values()].filter((job) => job.status === "running");
       if (interrupted.length > 0) {
         await memory.commitMutation(() => {
@@ -2689,6 +2796,7 @@ var StrataGate = class _StrataGate {
               ...job,
               status: "failed",
               lastError: "Extraction was interrupted before completion.",
+              nextRetryAt: now,
               updatedAt: now
             });
           }
@@ -2734,6 +2842,18 @@ var StrataGate = class _StrataGate {
   get storageRevision() {
     return this.revision;
   }
+  get blockTurnSize() {
+    return this.blockTurnSizeValue;
+  }
+  async setBlockTurnSize(value) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+      throw new TypeError("blockTurnSize must be a positive integer");
+    }
+    if (value === this.blockTurnSizeValue) return;
+    await this.commitMutation(() => {
+      this.blockTurnSizeValue = value;
+    });
+  }
   get blockDecayLambda() {
     return this.blockDecayLambdaValue;
   }
@@ -2768,6 +2888,9 @@ var StrataGate = class _StrataGate {
   listExtractionJobs() {
     return [...this.extractionJobs.values()];
   }
+  listSummaryJobs() {
+    return [...this.summaryJobs.values()];
+  }
   listElementProjectionJobs() {
     return [...this.elementProjectionJobs.values()];
   }
@@ -2800,6 +2923,7 @@ var StrataGate = class _StrataGate {
       blockDecayLambda: this.blockDecayLambda,
       openTail: this.openTail,
       blocks: this.blocks,
+      summaryJobs: [...this.summaryJobs.values()],
       events: this.events,
       graphNodes: this.graphNodes,
       graphEdges: this.graphEdges,
@@ -2848,57 +2972,55 @@ var StrataGate = class _StrataGate {
       if (receiptId) this.ingestionReceipts.set(receiptId, { id: receiptId, createdAt });
       return true;
     });
-    if (!appended) return { sealedBlock: null, extractedEvents: [], projectedElements: [] };
+    if (!appended) return { sealedBlock: null, readyBlocks: [], extractedEvents: [], projectedElements: [] };
     if (options.deferProcessing === true) {
-      return { sealedBlock: null, extractedEvents: [], projectedElements: [] };
+      return { sealedBlock: null, readyBlocks: [], extractedEvents: [], projectedElements: [] };
     }
     if (this.threadOpenTail(threadId).filter((message) => message.role === "user").length < this.blockTurnSize) {
       const projectedElements2 = await this.projectEligibleElements() ?? [];
       await this.projectEligibleGraph();
-      return { sealedBlock: null, extractedEvents: [], projectedElements: projectedElements2 };
+      return { sealedBlock: null, readyBlocks: [], extractedEvents: [], projectedElements: projectedElements2 };
     }
     const sealedBlock = await this.sealOpenTail(threadId);
-    const extractedEvents = await this.extractEligibleBlock() ?? [];
+    if (options.deferDerivation === true) {
+      return { sealedBlock, readyBlocks: [], extractedEvents: [], projectedElements: [] };
+    }
+    const beforeReady = sealedBlock.processingStatus === "ready";
+    const extractedEvents = await this.processBlock(sealedBlock, { retryFailed: false });
+    const readyBlocks = !beforeReady && sealedBlock.processingStatus === "ready" ? [sealedBlock] : [];
     const projectedElements = await this.projectEligibleElements() ?? [];
     await this.projectEligibleGraph();
-    return { sealedBlock, extractedEvents, projectedElements };
+    return { sealedBlock, readyBlocks, extractedEvents, projectedElements };
   }
   async resumePendingWork(options = {}) {
     const sealedBlocks = [];
+    const readyBlocks = [];
     const extractedEvents = [];
     const projectedElements = [];
     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() ?? []);
-      await this.projectEligibleGraph();
     }
-    while (true) {
-      const extracted = await this.extractEligibleBlock();
-      if (extracted === null) break;
+    if (options.deferDerivation === true) {
+      return { sealedBlocks, readyBlocks, extractedEvents, projectedElements };
+    }
+    for (const block of this.blocks) {
+      if (options.threadId !== void 0 && block.threadId !== options.threadId) continue;
+      if (block.processingStatus === "ready") continue;
+      const extracted = await this.processBlock(block, { retryFailed: options.retryFailed === true });
       extractedEvents.push(...extracted);
+      if (this.blocks.find((candidate) => candidate.id === block.id)?.processingStatus === "ready") readyBlocks.push(block);
       projectedElements.push(...await this.projectEligibleElements() ?? []);
       await this.projectEligibleGraph();
     }
-    if (options.retrySkipped === true) {
-      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;
-        extractedEvents.push(...extracted);
-        projectedElements.push(...await this.projectEligibleElements() ?? []);
-        await this.projectEligibleGraph();
-      }
-    }
     while (true) {
       const projected = await this.projectEligibleElements();
       if (projected === null) break;
       projectedElements.push(...projected);
     }
     await this.projectEligibleGraph();
-    return { sealedBlocks, extractedEvents, projectedElements };
+    return { sealedBlocks, readyBlocks, extractedEvents, projectedElements };
   }
   async addEvent(input) {
     return this.commitMutation(() => {
@@ -3260,9 +3382,9 @@ var StrataGate = class _StrataGate {
    * StrataGate namespace (never another namespace).
    */
   getBlockContext(threadId) {
-    const blocks = threadId === void 0 ? this.blocks : this.blocks.filter((block) => block.threadId === threadId);
+    const blocks = threadId === void 0 ? this.blocks.filter((block) => block.processingStatus === "ready") : this.blocks.filter((block) => block.threadId === threadId && block.processingStatus === "ready");
     return blocks.map((block) => {
-      const threadBlocks = this.threadBlocks(block.threadId);
+      const threadBlocks = this.threadBlocks(block.threadId).filter((candidate) => candidate.processingStatus === "ready");
       const latestBlockPosition = threadBlocks.length;
       const blockPosition = threadBlocks.indexOf(block) + 1;
       const age = Math.max(0, latestBlockPosition - blockPosition);
@@ -3288,8 +3410,10 @@ 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 latestBlockPosition = this.threadBlocks(block.threadId).length;
-      const blockPosition = this.threadBlocks(block.threadId).indexOf(block) + 1;
+      if (block.processingStatus !== "ready") throw new Error(`Block ${id} is not ready for decay or expansion`);
+      const readyBlocks = this.threadBlocks(block.threadId).filter((candidate) => candidate.processingStatus === "ready");
+      const latestBlockPosition = readyBlocks.length;
+      const blockPosition = readyBlocks.indexOf(block) + 1;
       const current = getDecayedBlockLevel(
         block.pointerAnchorLevel,
         block.pointerAnchorBlockPosition,
@@ -3408,6 +3532,7 @@ var StrataGate = class _StrataGate {
       l1Summary: text3.replace(/\s+/gu, " ").trim().slice(0, 500),
       l2Keypoints: text3.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean).slice(0, 8),
       shouldExtract: false,
+      processingStatus: "ready",
       ...deterministicBlockLayers([message]),
       pointerCurrentLevel: 5,
       pointerAnchorLevel: 5,
@@ -3624,7 +3749,6 @@ var StrataGate = class _StrataGate {
     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 threadBlocks = this.threadBlocks(threadId);
@@ -3644,11 +3768,7 @@ var StrataGate = class _StrataGate {
         startTurn,
         endTurn,
         createdAt: raw.at(-1)?.createdAt ?? toUtc8Iso(this.now()),
-        l0Title: generated.l0Title,
-        l0Tags: generated.l0Tags,
-        l1Summary: generated.l1Summary,
-        l2Keypoints: generated.l2Keypoints,
-        shouldExtract: generated.shouldExtract,
+        processingStatus: "pending",
         ...deterministic,
         pointerCurrentLevel: 5,
         pointerAnchorLevel: 5,
@@ -3660,27 +3780,132 @@ var StrataGate = class _StrataGate {
       const remaining = this.openTail.filter((message) => !sealedIds.has(message.id));
       this.openTail.splice(0, this.openTail.length, ...remaining);
       this.blocks.push(block);
+      const updatedAt = toUtc8Iso(this.now());
+      this.summaryJobs.set(block.id, {
+        blockId: block.id,
+        status: "pending",
+        attempts: 0,
+        lastError: null,
+        nextRetryAt: null,
+        updatedAt
+      });
       return block;
     });
   }
+  async processBlock(block, options) {
+    if (block.processingStatus === "ready") return [];
+    const summary = this.summaryJobs.get(block.id);
+    if (!summary || summary.status !== "succeeded") {
+      if (!this.summarizer || !this.jobCanRun(summary, options.retryFailed)) return [];
+      const claimed = await this.commitMutation(() => {
+        const current = this.summaryJobs.get(block.id);
+        if (!current || !this.jobCanRun(current, options.retryFailed)) return false;
+        this.summaryJobs.set(block.id, {
+          ...current,
+          status: "running",
+          attempts: current.attempts + 1,
+          lastError: null,
+          nextRetryAt: null,
+          updatedAt: toUtc8Iso(this.now())
+        });
+        return true;
+      });
+      if (!claimed) return [];
+      try {
+        const generated = await this.summarizer(block.l5Raw);
+        if (!generated.l0Title.trim() || !generated.l1Summary.trim() || !Array.isArray(generated.l0Tags) || !Array.isArray(generated.l2Keypoints) || typeof generated.shouldExtract !== "boolean") {
+          throw new Error("Block summarizer returned invalid L0-L2 layers");
+        }
+        await this.commitMutation(() => {
+          block.l0Title = generated.l0Title;
+          block.l0Tags = [...generated.l0Tags];
+          block.l1Summary = generated.l1Summary;
+          block.l2Keypoints = [...generated.l2Keypoints];
+          block.shouldExtract = generated.shouldExtract;
+          const current = this.summaryJobs.get(block.id);
+          if (!current) throw new Error(`Missing summary job for block: ${block.id}`);
+          this.summaryJobs.set(block.id, {
+            ...current,
+            status: "succeeded",
+            lastError: null,
+            nextRetryAt: null,
+            updatedAt: toUtc8Iso(this.now())
+          });
+        });
+      } catch (error) {
+        await this.failSummary(block.id, error);
+        return [];
+      }
+    }
+    if (block.shouldExtract === false) {
+      await this.commitMutation(() => {
+        const now = toUtc8Iso(this.now());
+        this.extractionJobs.set(block.id, {
+          blockId: block.id,
+          status: "skipped",
+          attempts: this.extractionJobs.get(block.id)?.attempts ?? 0,
+          lastError: null,
+          nextRetryAt: null,
+          updatedAt: now
+        });
+        this.markBlockReady(block);
+      });
+      return [];
+    }
+    try {
+      const extracted = await this.extractEligibleBlock({ blockId: block.id, retryFailed: options.retryFailed });
+      return extracted ?? [];
+    } catch {
+      return [];
+    }
+  }
+  jobCanRun(job, force) {
+    if (!job || job.attempts >= DERIVATION_MAX_ATTEMPTS || job.status === "running" || job.status === "succeeded") return false;
+    return force || job.nextRetryAt === null || Date.parse(job.nextRetryAt) <= this.now().getTime();
+  }
+  async failSummary(blockId, error) {
+    await this.commitMutation(() => {
+      const job = this.summaryJobs.get(blockId);
+      if (!job) return;
+      this.summaryJobs.set(blockId, {
+        ...job,
+        status: "failed",
+        lastError: errorMessage(error),
+        nextRetryAt: this.retryAt(job.attempts),
+        updatedAt: toUtc8Iso(this.now())
+      });
+    });
+  }
+  retryAt(attempts) {
+    if (attempts >= DERIVATION_MAX_ATTEMPTS) return null;
+    return toUtc8Iso(new Date(this.now().getTime() + DERIVATION_BACKOFF_MS * 2 ** Math.max(0, attempts - 1)));
+  }
+  markBlockReady(block) {
+    if (!block.l0Title || !block.l0Tags || !block.l1Summary || !block.l2Keypoints || typeof block.shouldExtract !== "boolean") {
+      throw new Error(`Block ${block.id} cannot become ready without validated L0-L2 layers`);
+    }
+    const ready = this.threadBlocks(block.threadId).filter((candidate) => candidate.processingStatus === "ready");
+    block.processingStatus = "ready";
+    block.pointerCurrentLevel = 5;
+    block.pointerAnchorLevel = 5;
+    block.pointerAnchorBlockPosition = ready.length + 1;
+  }
   async extractEligibleBlock(options = {}) {
-    if (!this.extractor || this.blocks.length < 2) return null;
+    if (!this.extractor) return null;
     const target = this.blocks.find((block) => {
-      if (this.nextBlockInThread(block) === null || !block.shouldExtract) return false;
+      if (block.processingStatus === "ready" || block.shouldExtract !== true) 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";
+      const job = this.extractionJobs.get(block.id);
+      return job === void 0 || this.jobCanRun(job, options.retryFailed === true);
     });
     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 next = threadBlocks.slice(targetIndex + 1).find((block) => block.l2Keypoints !== void 0) ?? null;
     const existing = this.extractionJobs.get(target.id);
     await this.commitMutation(() => {
       const currentStatus = this.extractionJobs.get(target.id)?.status;
-      const canRetrySkipped = options.includeSkipped === true && currentStatus === "skipped";
-      if (currentStatus !== void 0 && currentStatus !== "failed" && !canRetrySkipped) {
+      if (currentStatus !== void 0 && currentStatus !== "failed") {
         throw new Error(`Extraction block ${target.id} is already ${currentStatus}`);
       }
       this.extractionJobs.set(target.id, {
@@ -3688,13 +3913,14 @@ var StrataGate = class _StrataGate {
         status: "running",
         attempts: (existing?.attempts ?? 0) + 1,
         lastError: null,
+        nextRetryAt: null,
         updatedAt: toUtc8Iso(this.now())
       });
     });
     let result;
     try {
       result = await this.extractor({
-        previous: threadBlocks[targetIndex - 1] ?? null,
+        previous: threadBlocks.slice(0, targetIndex).reverse().find((block) => block.l2Keypoints !== void 0) ?? null,
         target,
         next,
         timeline: this.events.map((event) => ({ id: event.id, title: event.title, temporal: event.temporal }))
@@ -3707,6 +3933,7 @@ var StrataGate = class _StrataGate {
           ...job,
           status: "failed",
           lastError: errorMessage(error),
+          nextRetryAt: this.retryAt(job.attempts),
           updatedAt: toUtc8Iso(this.now())
         });
       });
@@ -3721,6 +3948,7 @@ var StrataGate = class _StrataGate {
           ...job,
           status: "failed",
           lastError: reason,
+          nextRetryAt: this.retryAt(job.attempts),
           updatedAt: toUtc8Iso(this.now())
         });
       });
@@ -3739,8 +3967,10 @@ var StrataGate = class _StrataGate {
         ...job,
         status: result.shouldExtract ? "succeeded" : "skipped",
         lastError: null,
+        nextRetryAt: null,
         updatedAt: toUtc8Iso(this.now())
       });
+      this.markBlockReady(target);
       return extracted;
     });
   }
@@ -3809,6 +4039,8 @@ var StrataGate = class _StrataGate {
     this.currentTurn = copy.currentTurn;
     this.openTail.splice(0, this.openTail.length, ...copy.openTail);
     this.blocks.splice(0, this.blocks.length, ...copy.blocks);
+    this.summaryJobs.clear();
+    for (const job of copy.summaryJobs) this.summaryJobs.set(job.blockId, job);
     this.events.splice(0, this.events.length, ...copy.events);
     this.graphNodes.splice(0, this.graphNodes.length, ...copy.graphNodes);
     this.graphEdges.splice(0, this.graphEdges.length, ...copy.graphEdges);
@@ -3855,6 +4087,9 @@ var StrataGate = class _StrataGate {
     for (const job of this.extractionJobs.values()) {
       if (!blockIds.has(job.blockId)) throw new Error(`Unknown extraction job block in snapshot: ${job.blockId}`);
     }
+    for (const job of this.summaryJobs.values()) {
+      if (!blockIds.has(job.blockId)) throw new Error(`Unknown summary job block in snapshot: ${job.blockId}`);
+    }
     const elementIds = /* @__PURE__ */ new Set();
     for (const element of this.elements) {
       if (elementIds.has(element.id)) throw new Error(`Duplicate element ID in snapshot: ${element.id}`);
@@ -4083,7 +4318,7 @@ function extractorPayload(context) {
 }
 var JSON_RESPONSE_ATTEMPTS = 2;
 var JSON_RETRY_INSTRUCTION = "Your previous response did not make one valid call to the requested tool. Do not spend output on analysis or reasoning. Immediately call that tool exactly once with complete arguments. Do not return an answer as text or markdown.";
-var RETRY_MAX_TOKENS = 1e4;
+var DEFAULT_STRUCTURED_TIMEOUT_MS = 45e3;
 var STRUCTURED_FIELDS = {
   summarizer: ["l0Title", "l0Tags", "l1Summary", "l2Keypoints", "shouldExtract"],
   extractor: ["shouldExtract", "reason", "events"],
@@ -4234,11 +4469,15 @@ var DshModelBridge = class {
   constructor(ctx, config) {
     this.ctx = ctx;
     this.config = config;
+    this.ctx.on?.("llm/adapters-updated", () => {
+      this.offCapabilities.clear();
+    });
   }
   ctx;
   config;
   sessions = new AsyncLocalStorage();
   successfulResponses = [];
+  offCapabilities = /* @__PURE__ */ new Map();
   run(session, operation) {
     return this.sessions.run(session, operation);
   }
@@ -4253,7 +4492,7 @@ var DshModelBridge = class {
       { messages }
     ));
     return {
-      l0Title: text2(raw.l0Title, "Conversation block").slice(0, 120),
+      l0Title: text2(raw.l0Title).slice(0, 120),
       l0Tags: strings2(raw.l0Tags).slice(0, 12),
       l1Summary: text2(raw.l1Summary).slice(0, 2e3),
       l2Keypoints: strings2(raw.l2Keypoints).slice(0, 20),
@@ -4385,10 +4624,11 @@ var DshModelBridge = class {
   async callStructured(kind, system, payload) {
     const session = this.sessions.getStore();
     if (!session) throw new Error("StrataGate model callback ran without a DSH session");
-    const route = this.resolveRoute(session, true);
+    const baseRoute = this.resolveRoute(session);
+    const routeKey = `${baseRoute.provider}\0${baseRoute.model}`;
+    let useOff = await this.shouldUseOff(baseRoute);
     let lastError;
     let lastResponse = "";
-    let retryMaxTokens = this.config.maxOutputTokens;
     for (let attempt = 1; attempt <= JSON_RESPONSE_ATTEMPTS; attempt += 1) {
       const message = createUserMessage({
         content: [{ type: "text", text: JSON.stringify(payload) }],
@@ -4396,7 +4636,8 @@ var DshModelBridge = class {
       });
       const assembler = new BlockAssembler();
       const request = {
-        ...route,
+        ...baseRoute,
+        ...useOff ? { reasoningEffort: "off" } : {},
         messages: [message],
         system: attempt === 1 ? system : `${system}
 
@@ -4410,15 +4651,35 @@ ${JSON_RETRY_INSTRUCTION}`,
           type: "function",
           function: { name: STRUCTURED_TOOLS[kind].name }
         },
-        maxTokens: retryMaxTokens,
+        maxTokens: this.config.maxOutputTokens,
         sessionId: session.id,
         purpose: "compaction"
       };
-      for await (const chunk of this.ctx.llm.stream(request)) assembler.push(chunk);
+      try {
+        await this.consumeStructuredStream(request, assembler);
+      } catch (error) {
+        if (useOff && isOffRejection(error)) {
+          this.offCapabilities.set(routeKey, "unsupported");
+          useOff = false;
+          this.ctx.logger.warn(`stratagate-memory ${baseRoute.provider}/${baseRoute.model} rejected reasoningEffort=off; retrying once without it`);
+          attempt -= 1;
+          continue;
+        }
+        throw error;
+      }
       const finish = assembler.finish;
       if (finish.kind === "error" || finish.kind === "aborted") {
-        throw new Error(`StrataGate model call failed: ${finish.failure.message}`);
+        const failure = new Error(`StrataGate model call failed [${finish.failure.code}]: ${finish.failure.message}`);
+        if (useOff && isOffRejection(finish.failure)) {
+          this.offCapabilities.set(routeKey, "unsupported");
+          useOff = false;
+          this.ctx.logger.warn(`stratagate-memory ${baseRoute.provider}/${baseRoute.model} rejected reasoningEffort=off; retrying once without it`);
+          attempt -= 1;
+          continue;
+        }
+        throw failure;
       }
+      if (useOff) this.offCapabilities.set(routeKey, "supported");
       const blocks = assembler.blocks();
       const calls = blocks.filter((block) => block.type === "tool-call");
       const responseForError = `${renderBlocksForDiagnostics(blocks, finish.kind)}
@@ -4454,6 +4715,15 @@ ${JSON_RETRY_INSTRUCTION}`,
             { response: responseForError }
           );
         }
+        if (kind === "summarizer") {
+          const summary = object(parsed);
+          if (!text2(summary.l0Title) || !text2(summary.l1Summary)) {
+            throw new ModelJsonResponseError(
+              `StrataGate ${expectedTool} arguments were invalid: l0Title and l1Summary must not be empty`,
+              { response: responseForError }
+            );
+          }
+        }
         this.successfulResponses.push({
           id: `model_response_${crypto.randomUUID()}`,
           kind,
@@ -4468,7 +4738,6 @@ ${JSON_RETRY_INSTRUCTION}`,
           `StrataGate ${STRUCTURED_TOOLS[kind].name} call was truncated before valid arguments`,
           { cause: error, response: responseForError }
         ) : error;
-        if (finish.kind === "max-tokens") retryMaxTokens = Math.max(this.config.maxOutputTokens, RETRY_MAX_TOKENS);
         if (attempt < JSON_RESPONSE_ATTEMPTS) {
           this.ctx.logger.warn(`stratagate-memory model returned an invalid structured tool call; retrying (${attempt}/${JSON_RESPONSE_ATTEMPTS})`);
         }
@@ -4479,25 +4748,77 @@ ${JSON_RETRY_INSTRUCTION}`,
       { cause: lastError, response: lastResponse }
     );
   }
-  resolveRoute(session, structured = false) {
-    const request = session.requestHeader()?.config;
-    const requestedReasoningEffort = request?.reasoningEffort;
-    const withReasoningEffort = (route) => ({
-      ...route,
-      ...structured ? { reasoningEffort: "off" } : requestedReasoningEffort !== void 0 ? { reasoningEffort: requestedReasoningEffort } : {}
+  async shouldUseOff(route) {
+    const key = `${route.provider}\0${route.model}`;
+    const cached = this.offCapabilities.get(key);
+    if (cached) return cached === "supported";
+    if (typeof this.ctx.llm.resolveModelInfo !== "function") return true;
+    const controller = new AbortController();
+    const lookupTimeoutMs = Math.min(5e3, this.config.structuredTaskTimeoutMs ?? DEFAULT_STRUCTURED_TIMEOUT_MS);
+    let timer;
+    try {
+      const info = await Promise.race([
+        this.ctx.llm.resolveModelInfo(route.provider, route.model, controller.signal),
+        new Promise((_resolve, reject) => {
+          timer = setTimeout(() => {
+            controller.abort();
+            reject(new Error(`Model capability lookup timed out after ${lookupTimeoutMs}ms`));
+          }, lookupTimeoutMs);
+          timer.unref?.();
+        })
+      ]);
+      if (!info.reasoning) return true;
+      const supported = info.reasoning.efforts.some(({ id }) => String(id) === "off");
+      this.offCapabilities.set(key, supported ? "supported" : "unsupported");
+      return supported;
+    } catch {
+      return true;
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  async consumeStructuredStream(request, assembler) {
+    const timeoutMs = this.config.structuredTaskTimeoutMs ?? DEFAULT_STRUCTURED_TIMEOUT_MS;
+    const controller = new AbortController();
+    const timedRequest = { ...request, signal: controller.signal };
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+      timer = setTimeout(() => {
+        controller.abort(new Error(`StrataGate structured model task timed out after ${timeoutMs}ms`));
+        reject(new Error(`StrataGate structured model task timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      timer.unref?.();
     });
+    try {
+      await Promise.race([
+        (async () => {
+          for await (const chunk of this.ctx.llm.stream(timedRequest)) assembler.push(chunk);
+        })(),
+        timeout
+      ]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  resolveRoute(session) {
+    const request = session.requestHeader()?.config;
     if (this.config.provider && this.config.model) {
-      return withReasoningEffort({ provider: this.config.provider, model: this.config.model });
+      return { provider: this.config.provider, model: this.config.model };
     }
-    if (request) return withReasoningEffort({ provider: request.provider, model: request.model });
+    if (request) return { provider: request.provider, model: request.model };
     const fallback = this.ctx.agentDefaultModel.currentSelection();
-    return {
-      provider: fallback.provider,
-      model: fallback.model,
-      ...structured ? { reasoningEffort: "off" } : fallback.reasoningEffort !== void 0 ? { reasoningEffort: fallback.reasoningEffort } : {}
-    };
+    return { provider: fallback.provider, model: fallback.model };
   }
 };
+function isOffRejection(error) {
+  let detail;
+  try {
+    detail = typeof error === "string" ? error : error && typeof error === "object" ? JSON.stringify(error, Object.getOwnPropertyNames(error)) : String(error);
+  } catch {
+    detail = error instanceof Error ? error.message : String(error);
+  }
+  return /(?:reasoning[_ -]?effort|reasoning).{0,100}\boff\b|\boff\b.{0,100}(?:reasoning[_ -]?effort|reasoning)/iu.test(detail) && /(?:unsupported|not supported|invalid|not allowed|unknown|unrecognized|reject|must be|expected)/iu.test(detail);
+}
 
 // src/runtime.ts
 import { createHash } from "node:crypto";
@@ -4643,6 +4964,17 @@ var DshMetadataStore = class {
     this.database = new DatabaseSync2(filename);
     this.database.exec(METADATA_SCHEMA);
   }
+  blockTurnSize() {
+    const row = this.database.prepare("SELECT value FROM stratagate_dsh_settings WHERE key = 'blockTurnSize'").get();
+    const value = Number(row?.value);
+    return Number.isSafeInteger(value) && value >= 1 ? value : null;
+  }
+  setBlockTurnSize(value) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+      throw new TypeError("blockTurnSize must be a positive integer");
+    }
+    this.setSetting("blockTurnSize", value);
+  }
   blockDecayLambda() {
     const row = this.database.prepare("SELECT value FROM stratagate_dsh_settings WHERE key = 'blockDecayLambda'").get();
     const value = Number(row?.value);
@@ -4652,11 +4984,14 @@ var DshMetadataStore = class {
     if (!Number.isFinite(value) || value < 0) {
       throw new TypeError("blockDecayLambda must be a non-negative finite number");
     }
+    this.setSetting("blockDecayLambda", value);
+  }
+  setSetting(key, value) {
     this.database.prepare(`
       INSERT INTO stratagate_dsh_settings (key, value, updated_at)
-      VALUES ('blockDecayLambda', ?, ?)
+      VALUES (?, ?, ?)
       ON CONFLICT (key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
-    `).run(String(value), (/* @__PURE__ */ new Date()).toISOString());
+    `).run(key, String(value), (/* @__PURE__ */ new Date()).toISOString());
   }
   workspaceName(namespace) {
     const row = this.database.prepare("SELECT display_name FROM stratagate_dsh_workspaces WHERE namespace = ?").get(namespace);
@@ -4697,6 +5032,7 @@ var StrataGateRuntime = class {
     this.models = models;
     this.onIngestError = onIngestError;
     this.flushNativeSession = flushNativeSession;
+    this.blockTurnSize = config.blockTurnSize;
     this.blockDecayLambda = config.blockDecayLambda;
   }
   config;
@@ -4709,11 +5045,14 @@ var StrataGateRuntime = class {
   latestBatchIds = /* @__PURE__ */ new Map();
   workspaceNames = /* @__PURE__ */ new Map();
   migrationTimers = /* @__PURE__ */ new Map();
+  derivationTimers = /* @__PURE__ */ new Map();
+  derivationRuns = /* @__PURE__ */ new Map();
   ingestTail = Promise.resolve();
   settingsTail = Promise.resolve();
   batchSequence = 0;
   closed = false;
   ingestError;
+  blockTurnSize;
   blockDecayLambda;
   acceptEvent(session, event) {
     if (this.closed) return;
@@ -4724,15 +5063,8 @@ var StrataGateRuntime = class {
     }).then(async () => {
       const memory = await this.space(session);
       try {
-        const result = await this.models.run(session, () => memory.appendTurn(turn));
-        if (result.sealedBlock) {
-          const contexts = memory.getBlockContext(String(session.id));
-          const sealedContext = contexts.find(({ id }) => id === result.sealedBlock.id);
-          if (!sealedContext) throw new Error(`Missing context for sealed StrataGate block ${result.sealedBlock.id}`);
-          this.replaceSealedSurface(session, result.sealedBlock, sealedContext, turn.dshTurn);
-          this.syncDecayedBlockSurface(session, contexts);
-          await this.flushNativeSession(session);
-        }
+        const result = await memory.appendTurn(turn, { deferDerivation: true });
+        if (result.sealedBlock) this.scheduleBlockDerivation(session, memory);
       } finally {
         await this.persistSuccessfulResponses(memory);
       }
@@ -5046,6 +5378,8 @@ var StrataGateRuntime = class {
     this.closed = true;
     for (const timer of this.migrationTimers.values()) clearTimeout(timer);
     this.migrationTimers.clear();
+    for (const timer of this.derivationTimers.values()) clearTimeout(timer);
+    this.derivationTimers.clear();
     let flushError;
     try {
       await this.flush();
@@ -5053,6 +5387,7 @@ var StrataGateRuntime = class {
       flushError = error;
     }
     const settled = await Promise.allSettled(this.spaces.values());
+    await Promise.allSettled(this.derivationRuns.values());
     await Promise.all(settled.flatMap((result) => result.status === "fulfilled" ? [result.value.close()] : []));
     if (flushError !== void 0) throw flushError;
   }
@@ -5075,6 +5410,7 @@ var StrataGateRuntime = class {
     if (this.config.database === ":memory:" || !existsSync(this.config.database)) return;
     const metadata = new DshMetadataStore(this.config.database);
     try {
+      this.blockTurnSize = metadata.blockTurnSize() ?? this.config.blockTurnSize;
       this.blockDecayLambda = metadata.blockDecayLambda() ?? this.config.blockDecayLambda;
     } finally {
       metadata.close();
@@ -5083,10 +5419,10 @@ var StrataGateRuntime = class {
     try {
       for (const namespace of storage.listNamespaces()) {
         const loaded = await storage.load(namespace);
-        if (!loaded || loaded.snapshot.blockTurnSize === this.config.blockTurnSize && loaded.snapshot.blockDecayLambda === this.blockDecayLambda) continue;
+        if (!loaded || loaded.snapshot.blockTurnSize === this.blockTurnSize && loaded.snapshot.blockDecayLambda === this.blockDecayLambda) continue;
         await storage.save(namespace, {
           ...loaded.snapshot,
-          blockTurnSize: this.config.blockTurnSize,
+          blockTurnSize: this.blockTurnSize,
           blockDecayLambda: this.blockDecayLambda
         }, loaded.revision);
       }
@@ -5122,7 +5458,7 @@ var StrataGateRuntime = class {
       memory = await StrataGate.open({
         database: this.config.database,
         namespace: key,
-        blockTurnSize: this.config.blockTurnSize,
+        blockTurnSize: this.blockTurnSize,
         blockDecayLambda: this.blockDecayLambda,
         graphProjector: this.models.graphProjector,
         disableElementProjection: true
@@ -5167,6 +5503,18 @@ var StrataGateRuntime = class {
     await update;
     return value;
   }
+  async adminSetBlockTurnSize(value) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+      throw new TypeError("blockTurnSize must be a positive integer");
+    }
+    const update = this.settingsTail.catch(() => {
+    }).then(() => this.applyBlockTurnSize(value));
+    this.settingsTail = update.then(() => {
+    }, () => {
+    });
+    await update;
+    return value;
+  }
   async adminExpandBlock(namespace, id, target) {
     const key = namespace.trim();
     if (!key) throw new TypeError("StrataGate admin namespace must not be empty");
@@ -5181,7 +5529,7 @@ var StrataGateRuntime = class {
       const memory = await StrataGate.open({
         database: this.config.database,
         namespace: key,
-        blockTurnSize: this.config.blockTurnSize,
+        blockTurnSize: this.blockTurnSize,
         blockDecayLambda: this.blockDecayLambda,
         summarizer: this.models.summarizer,
         extractor: this.models.extractor,
@@ -5230,6 +5578,37 @@ var StrataGateRuntime = class {
       }
     }
   }
+  async applyBlockTurnSize(value) {
+    await this.flush();
+    this.blockTurnSize = value;
+    if (this.config.database !== ":memory:") {
+      const metadata = new DshMetadataStore(this.config.database);
+      try {
+        metadata.setBlockTurnSize(value);
+      } finally {
+        metadata.close();
+      }
+    }
+    const openNamespaces = /* @__PURE__ */ new Set();
+    for (const [namespace, opening] of this.spaces) {
+      const memory = await opening;
+      await memory.setBlockTurnSize(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.blockTurnSize === value) continue;
+          await storage.save(namespace, { ...loaded.snapshot, blockTurnSize: value }, loaded.revision);
+        }
+      } finally {
+        await storage.close();
+      }
+    }
+  }
   space(session) {
     const namespace = this.namespaceFor(session);
     this.rememberWorkspace(namespace, session.header.cwd);
@@ -5238,7 +5617,7 @@ var StrataGateRuntime = class {
       opening = StrataGate.open({
         database: this.config.database,
         namespace,
-        blockTurnSize: this.config.blockTurnSize,
+        blockTurnSize: this.blockTurnSize,
         blockDecayLambda: this.blockDecayLambda,
         summarizer: this.models.summarizer,
         extractor: this.models.extractor,
@@ -5247,23 +5626,14 @@ var StrataGateRuntime = class {
       }).then(async (memory) => {
         try {
           try {
-            const resumed = await this.models.run(session, () => memory.resumePendingWork({ retrySkipped: true }));
+            await memory.resumePendingWork({ deferDerivation: true, threadId: String(session.id) });
             const contexts = memory.getBlockContext(String(session.id));
-            for (const block of resumed.sealedBlocks) {
-              if (block.threadId !== String(session.id)) continue;
-              const endTurn = dshTurnAtBlockEnd(session, block);
-              const context = contexts.find(({ id }) => id === block.id);
-              if (!context) throw new Error(`Missing context for recovered StrataGate block ${block.id}`);
-              this.replaceSealedSurface(session, block, context, endTurn);
-            }
             this.syncDecayedBlockSurface(session, contexts);
-            if (resumed.sealedBlocks.some((block) => block.threadId === String(session.id))) {
-              await this.flushNativeSession(session);
-            }
           } finally {
             await this.persistSuccessfulResponses(memory);
           }
           this.scheduleGraphMigration(session, memory);
+          this.scheduleBlockDerivation(session, memory);
           return memory;
         } catch (error) {
           await memory.close().catch(() => {
@@ -5297,6 +5667,43 @@ var StrataGateRuntime = class {
       target: { eventIds: [.../* @__PURE__ */ new Set([...node.sourceEventIds, ...edges.flatMap(({ sourceEventIds }) => sourceEventIds)])], elementIds: [] }
     }], { node, edges });
   }
+  scheduleBlockDerivation(session, memory) {
+    const threadId = String(session.id);
+    const key = `${this.namespaceFor(session)}\0${threadId}`;
+    if (this.closed || this.derivationTimers.has(key) || this.derivationRuns.has(key)) return;
+    const pendingBlockIds = new Set(memory.listBlocks().filter((block) => block.threadId === threadId && block.processingStatus === "pending").map((block) => block.id));
+    if (pendingBlockIds.size === 0) return;
+    const retryTimes = [
+      ...memory.listSummaryJobs(),
+      ...memory.listExtractionJobs()
+    ].filter((job) => pendingBlockIds.has(job.blockId) && (job.status === "pending" || job.status === "failed" && job.nextRetryAt !== null)).map((job) => job.nextRetryAt ? Date.parse(job.nextRetryAt) : Date.now()).filter(Number.isFinite);
+    if (retryTimes.length === 0) return;
+    const delay = Math.max(0, Math.min(...retryTimes) - Date.now());
+    const timer = setTimeout(() => {
+      this.derivationTimers.delete(key);
+      if (this.closed) return;
+      const run = this.models.run(session, () => memory.resumePendingWork({ threadId })).then(async (resumed) => {
+        await this.persistSuccessfulResponses(memory);
+        const contexts = memory.getBlockContext(threadId);
+        for (const block of resumed.readyBlocks) {
+          if (block.threadId !== threadId) continue;
+          const context = contexts.find(({ id }) => id === block.id);
+          if (!context) throw new Error(`Missing context for ready StrataGate block ${block.id}`);
+          this.replaceSealedSurface(session, block, context, dshTurnAtBlockEnd(session, block));
+        }
+        const changed = this.syncDecayedBlockSurface(session, contexts);
+        if (resumed.readyBlocks.length > 0 || changed) await this.flushNativeSession(session);
+      }).catch((error) => {
+        this.onIngestError(error);
+      }).finally(() => {
+        this.derivationRuns.delete(key);
+        this.scheduleBlockDerivation(session, memory);
+      });
+      this.derivationRuns.set(key, run);
+    }, delay);
+    timer.unref?.();
+    this.derivationTimers.set(key, timer);
+  }
   scheduleGraphMigration(session, memory) {
     const namespace = this.namespaceFor(session);
     if (this.closed || this.migrationTimers.has(namespace)) return;
@@ -5936,7 +6343,7 @@ function clusterKnowledgeGraph(rawNodes, rawEdges) {
 }
 
 // src/web.ts
-var STRATAGATE_DSH_VERSION = "0.2.32";
+var STRATAGATE_DSH_VERSION = "0.2.36";
 var LEGACY_THREAD_ID = "__legacy__";
 var nodeRequire = createRequire(import.meta.url);
 function installedPackageVersion(names) {
@@ -5992,6 +6399,13 @@ function sourceMessages(snapshot, ids) {
   return output;
 }
 function blockLayers(block) {
+  if (block.processingStatus !== "ready" || !block.l0Title || !block.l0Tags || !block.l1Summary || !block.l2Keypoints) {
+    return [
+      { level: 3, content: block.l3Condensed },
+      { level: 4, content: block.l4Readable },
+      { level: 5, content: block.l5Raw.map((message) => `${message.role}: ${message.content}`).join("\n\n") }
+    ];
+  }
   return [
     { level: 0, content: `${block.l0Title}
 \u6807\u7B7E\uFF1A${block.l0Tags.join("\u3001") || "\u65E0"}` },
@@ -6125,12 +6539,31 @@ async function overview(runtime) {
   };
 }
 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) };
+  const rawTurnSize = url.searchParams.get("blockTurnSize")?.trim();
+  const rawLambda = url.searchParams.get("blockDecayLambda")?.trim();
+  if (rawTurnSize === void 0 && rawLambda === void 0) {
+    throw new AdminHttpError(400, "blockTurnSize or blockDecayLambda is required");
+  }
+  let turnSize;
+  let lambda;
+  if (rawTurnSize !== void 0) {
+    const value = Number(rawTurnSize);
+    if (!rawTurnSize || !Number.isSafeInteger(value) || value < 1) {
+      throw new AdminHttpError(400, "blockTurnSize must be a positive integer");
+    }
+    turnSize = value;
+  }
+  if (rawLambda !== void 0) {
+    const value = Number(rawLambda);
+    if (!rawLambda || !Number.isFinite(value) || value < 0) {
+      throw new AdminHttpError(400, "blockDecayLambda must be a non-negative finite number");
+    }
+    lambda = value;
+  }
+  const result = {};
+  if (turnSize !== void 0) result.blockTurnSize = await runtime.adminSetBlockTurnSize(turnSize);
+  if (lambda !== void 0) result.blockDecayLambda = await runtime.adminSetBlockDecayLambda(lambda);
+  return result;
 }
 async function importExternalMemory(runtime, req) {
   let suppliedBody = req.body;