stratagate-dsh 0.2.58 → 0.2.61

package/dist/index.d.ts

@@ -2,6 +2,7 @@ import { Context } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
 
 type NamespaceMode = 'project' | 'session' | 'global';
+type StructuredReasoningEffortMode = 'auto' | 'force-off';
 interface Config {
     database?: string;
     namespaceMode?: NamespaceMode;
@@ -14,12 +15,14 @@ interface Config {
     model?: string;
     maxOutputTokens?: number;
     structuredTaskTimeoutMs?: number;
+    structuredReasoningEffort?: StructuredReasoningEffortMode;
 }
 declare const Config: z<Config>;
 
 declare const name = "stratagate-memory";
 declare const inject: string[];
+declare const STRATAGATE_SETTINGS_NAMESPACE = "stratagate-memory";
 
 declare function apply(ctx: Context, config: Config): Promise<() => Promise<void>>;
 
-export { Config, Config as PluginConfig, apply, inject, name };
+export { Config, Config as PluginConfig, STRATAGATE_SETTINGS_NAMESPACE, apply, inject, name };

package/dist/index.js

@@ -5,6 +5,9 @@ import { createUserMessage as createUserMessage3 } from "@deepseek-ai/dsh-llm";
 
 // src/config.ts
 import z from "@deepseek-ai/schemastery";
+var StructuredReasoningEffortSettings = z.object({
+  structuredReasoningEffort: z.union(["auto", "force-off"]).default("auto").description("\u8BB0\u5FC6\u5904\u7406\u7ED3\u6784\u5316\u8C03\u7528\u7684\u63A8\u7406\u6863\u4F4D\u7B56\u7565").comment("auto\uFF1A\u4EC5\u5728\u6A21\u578B\u660E\u786E\u652F\u6301 off \u65F6\u4F7F\u7528\uFF1Bforce-off\uFF1A\u4F18\u5148\u4F7F\u7528 off\uFF0C\u4E0D\u652F\u6301\u6216\u80FD\u529B\u68C0\u67E5\u5931\u8D25\u65F6\u5B89\u5168\u964D\u7EA7\uFF0C\u5E76\u5BF9\u540C\u4E00\u6A21\u578B\u53EA\u544A\u8B66\u4E00\u6B21\u3002")
+});
 var Config = z.object({
   database: z.string().required(),
   namespaceMode: z.union(["project", "session", "global"]).default("project"),
@@ -16,7 +19,8 @@ var Config = z.object({
   provider: z.string(),
   model: z.string(),
   maxOutputTokens: z.natural().min(256).default(2048),
-  structuredTaskTimeoutMs: z.natural().min(1e3).default(45e3)
+  structuredTaskTimeoutMs: z.natural().min(1e3).default(45e3),
+  structuredReasoningEffort: z.union(["auto", "force-off"]).default("auto")
 });
 function resolveConfig(config) {
   const database = config.database?.trim() ?? "";
@@ -38,7 +42,8 @@ function resolveConfig(config) {
     ingestSubagents: config.ingestSubagents ?? false,
     ...provider && model ? { provider, model } : {},
     maxOutputTokens: Math.max(256, Math.floor(config.maxOutputTokens ?? 2048)),
-    structuredTaskTimeoutMs: Math.max(1e3, Math.floor(config.structuredTaskTimeoutMs ?? 45e3))
+    structuredTaskTimeoutMs: Math.max(1e3, Math.floor(config.structuredTaskTimeoutMs ?? 45e3)),
+    structuredReasoningEffort: config.structuredReasoningEffort ?? "auto"
   };
 }
 
@@ -2986,35 +2991,6 @@ var StrataGate = class _StrataGate {
   listSummaryJobs() {
     return [...this.summaryJobs.values()];
   }
-  /** Give one terminally failed Block Summary job a fresh, user-requested retry budget. */
-  async retryBlockSummary(id) {
-    const blockId = id.trim();
-    if (!blockId) throw new TypeError("Block id must not be empty");
-    const block = this.blocks.find((candidate) => candidate.id === blockId);
-    if (!block) throw new Error(`Unknown block: ${blockId}`);
-    if (block.processingStatus !== "pending") throw new Error(`Block ${blockId} is already ready`);
-    await this.commitMutation(() => {
-      const job = this.summaryJobs.get(blockId);
-      if (!job) throw new Error(`Missing summary job for block: ${blockId}`);
-      if (job.status !== "failed" || job.nextRetryAt !== null) {
-        throw new Error(`Block ${blockId} Summary has not exhausted automatic retries`);
-      }
-      this.summaryJobs.set(blockId, {
-        ...job,
-        status: "pending",
-        attempts: 0,
-        lastError: null,
-        nextRetryAt: null,
-        updatedAt: toUtc8Iso(this.now())
-      });
-    });
-    const extractedEvents = await this.processBlock(block, { retryFailed: false });
-    const processed = this.blocks.find((candidate) => candidate.id === blockId);
-    const readyBlocks = processed?.processingStatus === "ready" ? [processed] : [];
-    const projectedElements = await this.projectEligibleElements() ?? [];
-    await this.projectEligibleGraph();
-    return { sealedBlocks: [], readyBlocks, extractedEvents, projectedElements };
-  }
   listElementProjectionJobs() {
     return [...this.elementProjectionJobs.values()];
   }
@@ -4918,6 +4894,7 @@ var DshModelBridge = class {
   constructor(ctx, config) {
     this.ctx = ctx;
     this.config = config;
+    this.structuredReasoningEffort = config.structuredReasoningEffort ?? "auto";
     this.ctx.on?.("llm/adapters-updated", () => {
       this.offCapabilities.clear();
     });
@@ -4927,6 +4904,11 @@ var DshModelBridge = class {
   sessions = new AsyncLocalStorage();
   successfulResponses = [];
   offCapabilities = /* @__PURE__ */ new Map();
+  warnedOffFallbackRoutes = /* @__PURE__ */ new Set();
+  structuredReasoningEffort;
+  setStructuredReasoningEffort(mode) {
+    this.structuredReasoningEffort = mode;
+  }
   run(session, operation) {
     return this.sessions.run({ session, sessionId: session.id }, operation);
   }
@@ -5146,7 +5128,7 @@ ${JSON_RETRY_INSTRUCTION}`,
         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`);
+          this.warnOffFallbackOnce(routeKey, `${baseRoute.provider}/${baseRoute.model} rejected reasoningEffort=off; retrying once without it`);
           attempt -= 1;
           continue;
         }
@@ -5158,7 +5140,7 @@ ${JSON_RETRY_INSTRUCTION}`,
         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`);
+          this.warnOffFallbackOnce(routeKey, `${baseRoute.provider}/${baseRoute.model} rejected reasoningEffort=off; retrying once without it`);
           attempt -= 1;
           continue;
         }
@@ -5236,8 +5218,19 @@ ${JSON_RETRY_INSTRUCTION}`,
   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;
+    if (cached) {
+      if (cached === "unsupported" && this.structuredReasoningEffort === "force-off") {
+        this.warnOffFallbackOnce(key, `${route.provider}/${route.model} does not support reasoningEffort=off; using the model default`);
+      }
+      return cached === "supported";
+    }
+    if (typeof this.ctx.llm.resolveModelInfo !== "function") {
+      this.offCapabilities.set(key, "unsupported");
+      if (this.structuredReasoningEffort === "force-off") {
+        this.warnOffFallbackOnce(key, `${route.provider}/${route.model} capabilities are unavailable; using the model default`);
+      }
+      return false;
+    }
     const controller = new AbortController();
     const lookupTimeoutMs = Math.min(5e3, this.config.structuredTaskTimeoutMs ?? DEFAULT_STRUCTURED_TIMEOUT_MS);
     let timer;
@@ -5252,16 +5245,28 @@ ${JSON_RETRY_INSTRUCTION}`,
           timer.unref?.();
         })
       ]);
-      if (!info.reasoning) return true;
+      if (!info.reasoning) return this.structuredReasoningEffort === "force-off";
       const supported = info.reasoning.efforts.some(({ id }) => String(id) === "off");
       this.offCapabilities.set(key, supported ? "supported" : "unsupported");
+      if (!supported && this.structuredReasoningEffort === "force-off") {
+        this.warnOffFallbackOnce(key, `${route.provider}/${route.model} does not support reasoningEffort=off; using the model default`);
+      }
       return supported;
     } catch {
-      return true;
+      this.offCapabilities.set(key, "unsupported");
+      if (this.structuredReasoningEffort === "force-off") {
+        this.warnOffFallbackOnce(key, `${route.provider}/${route.model} capability lookup failed; using the model default`);
+      }
+      return false;
     } finally {
       if (timer) clearTimeout(timer);
     }
   }
+  warnOffFallbackOnce(routeKey, message) {
+    if (this.warnedOffFallbackRoutes.has(routeKey)) return;
+    this.warnedOffFallbackRoutes.add(routeKey);
+    this.ctx.logger.warn(`stratagate-memory ${message}`);
+  }
   async consumeStructuredStream(request, assembler) {
     const timeoutMs = this.config.structuredTaskTimeoutMs ?? DEFAULT_STRUCTURED_TIMEOUT_MS;
     const controller = new AbortController();
@@ -5529,6 +5534,10 @@ var DshMetadataStore = class {
 };
 
 // src/runtime.ts
+var DRAIN_THRESHOLD = 3;
+var DRAIN_EAGER_MS = 150;
+var DRAIN_BASE_BACKOFF_MS = 2e3;
+var DRAIN_MAX_BACKOFF_MS = 6e4;
 var AUTO_EVENT_LIMIT = 4;
 var AUTO_ELEMENT_LIMIT = 4;
 var AUTO_MEMORY_TOKEN_BUDGET = 900;
@@ -5595,17 +5604,19 @@ var StrataGateRuntime = class {
   migrationTimers = /* @__PURE__ */ new Map();
   derivationTimers = /* @__PURE__ */ new Map();
   derivationRuns = /* @__PURE__ */ new Map();
-  knownSessions = /* @__PURE__ */ new Map();
-  pendingSurfaceSync = /* @__PURE__ */ new Map();
   adminSnapshotCache = /* @__PURE__ */ new Map();
   externalImportRuns = /* @__PURE__ */ new Map();
   feedbackDrafts = /* @__PURE__ */ new Map();
   pendingFeedbackSuggestionSessions = /* @__PURE__ */ new Set();
-  ingestTail = Promise.resolve();
+  pendingTurns = /* @__PURE__ */ new Map();
+  drainTimers = /* @__PURE__ */ new Map();
+  drainBackoffMs = /* @__PURE__ */ new Map();
+  drainTails = /* @__PURE__ */ new Map();
+  drainErrors = /* @__PURE__ */ new Map();
+  sessionsById = /* @__PURE__ */ new Map();
   settingsTail = Promise.resolve();
   batchSequence = 0;
   closed = false;
-  ingestError;
   blockTurnSize;
   blockDecayLambda;
   transientLastFeedbackPromptAt = null;
@@ -5614,20 +5625,86 @@ var StrataGateRuntime = class {
     if (!this.config.ingestSubagents && session.header.origin === "subagent") return;
     const turn = this.folder.accept(session, event);
     if (!turn) return;
-    this.ingestTail = this.ingestTail.catch(() => {
-    }).then(async () => {
-      const memory = await this.space(session);
-      try {
-        const result = await memory.appendTurn(turn, { deferDerivation: true });
-        if (result.sealedBlock) this.scheduleBlockDerivation(session, memory);
-      } finally {
-        await this.persistSuccessfulResponses(memory);
-      }
-    }).catch((error) => {
-      this.ingestError = error;
+    const key = String(session.id);
+    this.sessionsById.set(key, session);
+    const queued = this.pendingTurns.get(key) ?? [];
+    queued.push(turn);
+    this.pendingTurns.set(key, queued);
+    this.scheduleDrain(session);
+  }
+  /** Serialize drains per session while allowing unrelated sessions to settle independently. */
+  enqueueDrain(session) {
+    const key = String(session.id);
+    const prior = this.drainTails.get(key) ?? Promise.resolve();
+    const next = prior.catch(() => {
+    }).then(() => this.drain(session));
+    this.drainTails.set(key, next);
+    void next.then(() => {
+      if ((this.pendingTurns.get(key)?.length ?? 0) === 0) this.drainErrors.delete(key);
+    }, (error) => {
+      this.drainErrors.set(key, error);
       this.notePluginError(session, error);
       this.onIngestError(error);
     });
+    return next;
+  }
+  /** Batch short bursts and retry failed drains with bounded exponential backoff. */
+  scheduleDrain(session, overrideDelayMs) {
+    const key = String(session.id);
+    if (this.closed) return;
+    const queued = this.pendingTurns.get(key)?.length ?? 0;
+    if (queued === 0) return;
+    const delay = overrideDelayMs ?? (queued >= DRAIN_THRESHOLD ? DRAIN_EAGER_MS : Math.min(this.drainBackoffMs.get(key) ?? DRAIN_BASE_BACKOFF_MS, DRAIN_MAX_BACKOFF_MS));
+    const pending = this.drainTimers.get(key);
+    if (pending) {
+      if (delay >= DRAIN_BASE_BACKOFF_MS) return;
+      clearTimeout(pending);
+      this.drainTimers.delete(key);
+    }
+    const timer = setTimeout(() => {
+      this.drainTimers.delete(key);
+      if (this.closed) return;
+      void this.enqueueDrain(session).then(() => {
+        this.drainBackoffMs.delete(key);
+        if ((this.pendingTurns.get(key)?.length ?? 0) > 0) {
+          this.scheduleDrain(session, DRAIN_BASE_BACKOFF_MS);
+        }
+      }, () => {
+        const backoff = this.drainBackoffMs.get(key) ?? DRAIN_BASE_BACKOFF_MS;
+        this.drainBackoffMs.set(key, Math.min(backoff * 2, DRAIN_MAX_BACKOFF_MS));
+        const pendingRetry = this.drainTimers.get(key);
+        if (pendingRetry) clearTimeout(pendingRetry);
+        this.drainTimers.delete(key);
+        this.scheduleDrain(session);
+      });
+    }, delay);
+    timer.unref?.();
+    this.drainTimers.set(key, timer);
+  }
+  /** Restore failed and unvisited turns ahead of turns that arrived during the drain. */
+  async drain(session) {
+    const key = String(session.id);
+    const turns = this.pendingTurns.get(key);
+    if (!turns || turns.length === 0) return;
+    this.pendingTurns.delete(key);
+    let completed = 0;
+    let memory;
+    try {
+      memory = await this.space(session);
+      for (const turn of turns) {
+        const result = await memory.appendTurn(turn, { deferDerivation: true });
+        completed += 1;
+        if (result.sealedBlock) this.scheduleBlockDerivation(session, memory);
+      }
+    } catch (error) {
+      const remaining = turns.slice(completed);
+      if (remaining.length > 0) {
+        this.pendingTurns.set(key, [...remaining, ...this.pendingTurns.get(key) ?? []]);
+      }
+      throw error;
+    } finally {
+      if (memory) await this.persistSuccessfulResponses(memory);
+    }
   }
   async searchEvents(session, query, options = {}) {
     await this.flush();
@@ -5967,38 +6044,20 @@ var StrataGateRuntime = class {
     }
     return changed;
   }
-  /** Finish native-surface replacement when an admin retry ran without the target session loaded. */
-  async syncPendingRetrySurface(session, memory) {
-    const namespace = this.namespaceFor(session);
-    const threadId = String(session.id);
-    const pending = [...this.pendingSurfaceSync.entries()].filter(([, item]) => item.namespace === namespace);
-    if (pending.length === 0) return;
-    const contexts = new Map(memory.getBlockContext(threadId).map((context) => [context.id, context]));
-    const existing = currentBlockSurfaceMessages(session);
-    let changed = false;
-    for (const [key, { blockId }] of pending) {
-      if (existing.has(blockId)) {
-        this.pendingSurfaceSync.delete(key);
-        continue;
-      }
-      const block = memory.listBlocks().find((candidate) => candidate.id === blockId && candidate.threadId === threadId);
-      const context = contexts.get(blockId);
-      if (!block || block.processingStatus !== "ready" || !context) continue;
-      try {
-        this.replaceSealedSurface(session, block, context, dshTurnAtBlockEnd(session, block));
-        this.pendingSurfaceSync.delete(key);
-        changed = true;
-      } catch (error) {
-        this.onIngestError(error);
-      }
-    }
-    if (changed) await this.flushNativeSession(session);
-  }
   // Keep the ingestion error for callers that explicitly require a flushed run.
   async settleIngestion() {
-    await this.ingestTail;
-    const error = this.ingestError;
-    this.ingestError = void 0;
+    do {
+      for (const [key, session] of this.sessionsById) {
+        if ((this.pendingTurns.get(key)?.length ?? 0) === 0) continue;
+        const timer = this.drainTimers.get(key);
+        if (timer) clearTimeout(timer);
+        this.drainTimers.delete(key);
+        this.enqueueDrain(session);
+      }
+      await Promise.allSettled(this.drainTails.values());
+    } while (this.drainErrors.size === 0 && [...this.pendingTurns.values()].some((turns) => turns.length > 0));
+    const error = this.drainErrors.values().next().value;
+    this.drainErrors.clear();
     return error;
   }
   async close() {
@@ -6006,6 +6065,8 @@ var StrataGateRuntime = class {
     this.closed = true;
     for (const timer of this.migrationTimers.values()) clearTimeout(timer);
     this.migrationTimers.clear();
+    for (const timer of this.drainTimers.values()) clearTimeout(timer);
+    this.drainTimers.clear();
     for (const timer of this.derivationTimers.values()) clearTimeout(timer);
     this.derivationTimers.clear();
     let flushError;
@@ -6018,6 +6079,7 @@ var StrataGateRuntime = class {
     await Promise.allSettled(this.derivationRuns.values());
     await Promise.allSettled(this.externalImportRuns.values());
     await Promise.all(settled.flatMap((result) => result.status === "fulfilled" ? [result.value.close()] : []));
+    this.sessionsById.clear();
     if (flushError !== void 0) throw flushError;
   }
   namespaceFor(session) {
@@ -6513,44 +6575,6 @@ var StrataGateRuntime = class {
     });
     return update;
   }
-  async adminRetryBlockSummary(namespace, id) {
-    const key = namespace.trim();
-    const blockId = id.trim();
-    if (!key) throw new TypeError("StrataGate admin namespace must not be empty");
-    if (!blockId) throw new TypeError("Block id must not be empty");
-    const update = this.settingsTail.catch(() => {
-    }).then(async () => {
-      await this.flush();
-      const { memory, owned } = await this.openAdminMemory(key, { derivation: true });
-      try {
-        await this.refreshExternalImportMemory(key, memory);
-        const block = memory.listBlocks().find((candidate) => candidate.id === blockId);
-        if (!block) throw new Error(`Unknown block: ${blockId}`);
-        const threadId = block.threadId ?? `admin-summary-retry:${blockId}`;
-        const session = block.threadId ? this.knownSessions.get(block.threadId)?.deref() : void 0;
-        const resumed = session && this.namespaceFor(session) === key ? await this.models.run(session, () => memory.retryBlockSummary(blockId)) : await this.models.runDetached(threadId, () => memory.retryBlockSummary(blockId));
-        await this.persistSuccessfulResponses(memory);
-        if (resumed.readyBlocks.some(({ id: readyId }) => readyId === blockId) && block.threadId) {
-          this.pendingSurfaceSync.set(`${key}\0${blockId}`, { namespace: key, blockId });
-          if (session && this.namespaceFor(session) === key) await this.syncPendingRetrySurface(session, memory);
-        }
-        const summaryJob = memory.listSummaryJobs().find(({ blockId: candidateId }) => candidateId === blockId);
-        return {
-          blockId,
-          processingStatus: block.processingStatus,
-          ready: block.processingStatus === "ready",
-          summaryJob: summaryJob ?? null,
-          surfaceUpdated: !this.pendingSurfaceSync.has(`${key}\0${blockId}`)
-        };
-      } finally {
-        if (owned) await memory.close();
-      }
-    });
-    this.settingsTail = update.then(() => {
-    }, () => {
-    });
-    return update;
-  }
   async applyBlockDecayLambda(value) {
     await this.flush();
     this.blockDecayLambda = value;
@@ -6613,9 +6637,8 @@ var StrataGateRuntime = class {
       }
     }
   }
-  async space(session) {
+  space(session) {
     const namespace = this.namespaceFor(session);
-    this.knownSessions.set(String(session.id), new WeakRef(session));
     this.rememberWorkspace(namespace, session.header.cwd);
     let opening = this.spaces.get(namespace);
     if (!opening) {
@@ -6628,20 +6651,20 @@ var StrataGateRuntime = class {
         extractor: this.models.extractor,
         graphProjector: this.models.graphProjector,
         disableElementProjection: true
-      }).then(async (memory2) => {
+      }).then(async (memory) => {
         try {
           try {
-            await memory2.resumePendingWork({ deferDerivation: true, threadId: String(session.id) });
-            const contexts = memory2.getBlockContext(String(session.id));
+            await memory.resumePendingWork({ deferDerivation: true, threadId: String(session.id) });
+            const contexts = memory.getBlockContext(String(session.id));
             this.syncDecayedBlockSurface(session, contexts);
           } finally {
-            await this.persistSuccessfulResponses(memory2);
+            await this.persistSuccessfulResponses(memory);
           }
-          this.scheduleGraphMigration(session, memory2);
-          this.scheduleBlockDerivation(session, memory2);
-          return memory2;
+          this.scheduleGraphMigration(session, memory);
+          this.scheduleBlockDerivation(session, memory);
+          return memory;
         } catch (error) {
-          await memory2.close().catch(() => {
+          await memory.close().catch(() => {
           });
           throw error;
         }
@@ -6651,9 +6674,7 @@ var StrataGateRuntime = class {
         if (this.spaces.get(namespace) === opening) this.spaces.delete(namespace);
       });
     }
-    const memory = await opening;
-    await this.syncPendingRetrySurface(session, memory);
-    return memory;
+    return opening;
   }
   async searchGraph(session, query, limit = 8) {
     await this.flush();
@@ -6757,7 +6778,7 @@ var StrataGateRuntime = class {
   noteNewCoreJobFailures(session, before, memory) {
     if ([...this.failedCoreJobs(memory)].some((failure) => !before.has(failure))) this.notePluginError(session);
   }
-  async openAdminMemory(namespace, options = {}) {
+  async openAdminMemory(namespace) {
     const active = this.spaces.get(namespace);
     if (active) return { memory: await active, owned: false };
     if (this.config.database === ":memory:" || !existsSync(this.config.database)) {
@@ -6769,10 +6790,6 @@ var StrataGateRuntime = class {
         namespace,
         blockTurnSize: this.blockTurnSize,
         blockDecayLambda: this.blockDecayLambda,
-        ...options.derivation ? {
-          summarizer: this.models.summarizer,
-          extractor: this.models.extractor
-        } : {},
         graphProjector: this.models.graphProjector,
         disableElementProjection: true
       }),
@@ -6890,8 +6907,9 @@ function renderMessages(messages) {
 }
 function dshTurnAtBlockEnd(session, block) {
   const blockEnd = Date.parse(block.createdAt);
-  for (let index = session.events.length - 1; index >= 0; index -= 1) {
-    const event = session.events[index];
+  const events = session.snapshotEvents();
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const event = events[index];
     if (event?.type === "turn/end" && event.time === blockEnd) return event.data.turn;
   }
   throw new Error(`Cannot match StrataGate block ${block.id} to its completed DSH turn`);
@@ -6901,13 +6919,14 @@ function sealedSurfaceSeqs(session, endTurn, turnCount) {
   const currentSet = new Set(currentSurface);
   const completed = [];
   let open;
-  for (const event of session.events) {
+  const events = session.snapshotEvents();
+  for (const event of events) {
     if (event.type === "turn/start") {
       open = { turn: event.data.turn, start: event.seq };
       continue;
     }
     if (event.type !== "turn/end" || !open || event.data.turn !== open.turn) continue;
-    const turnEvents = session.events.slice(open.start + 1, event.seq);
+    const turnEvents = events.slice(open.start + 1, event.seq);
     const hasHumanMessage = turnEvents.some((candidate) => candidate.type === "user/message" && candidate.data.source.kind === "user");
     if (hasHumanMessage && event.data.turn <= endTurn) {
       completed.push({
@@ -7026,7 +7045,7 @@ function currentBlockSurfaceMessages(session) {
   const blocks = /* @__PURE__ */ new Map();
   if (!session.surface?.nodes) return blocks;
   for (const seq of session.surface.nodes) {
-    const event = session.events[seq];
+    const event = session.eventAt(seq);
     if (event?.type !== "user/message" || event.data.source.kind !== "plugin" || event.data.source.plugin !== COMPACTION_SOURCE_PLUGIN) continue;
     const text3 = event.data.content.flatMap((block) => block.type === "text" ? [block.text] : []).join("\n");
     const blockId = text3.match(/^\[StrataGate conversation block\]\nBlock: ([^\n]+)/u)?.[1] ?? text3.match(/^\[StrataGate compressed conversation\]\nBlock ([^;\n]+);/u)?.[1];
@@ -7126,8 +7145,9 @@ KnowledgeGraph:
   return lines.join("\n");
 }
 function activeTurn(session) {
-  for (let index = session.events.length - 1; index >= 0; index -= 1) {
-    const event = session.events[index];
+  const events = session.snapshotEvents();
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const event = events[index];
     if (event?.type === "turn/start") return event.data.turn;
   }
   return void 0;
@@ -7418,7 +7438,7 @@ function clusterKnowledgeGraph(rawNodes, rawEdges) {
 }
 
 // src/web.ts
-var STRATAGATE_DSH_VERSION = "0.2.57";
+var STRATAGATE_DSH_VERSION = "0.2.52";
 var LEGACY_THREAD_ID = "__legacy__";
 var nodeRequire = createRequire(import.meta.url);
 function installedPackageVersion(names) {
@@ -7561,24 +7581,9 @@ async function overview(runtime, cachedEntries) {
   const rows = [];
   for (const { namespace, snapshot } of entries) {
     if (!snapshot) continue;
-    const failedJobs = snapshot.summaryJobs.filter(({ status }) => status === "failed").length + snapshot.extractionJobs.filter(({ status }) => status === "failed").length + snapshot.graphProjectionJobs.filter(({ status }) => status === "failed").length;
+    const failedJobs = snapshot.extractionJobs.filter(({ status }) => status === "failed").length + snapshot.graphProjectionJobs.filter(({ status }) => status === "failed").length;
     const processingJobs = snapshot.summaryJobs.filter(({ status, nextRetryAt }) => status === "pending" || status === "running" || status === "failed" && nextRetryAt !== null).length + snapshot.extractionJobs.filter(({ status, nextRetryAt }) => status === "running" || status === "failed" && nextRetryAt !== null).length + snapshot.graphProjectionJobs.filter(({ status }) => status === "pending" || status === "running").length;
     const failedJobDetails = [
-      ...snapshot.summaryJobs.filter(({ status }) => status === "failed").map((job) => {
-        const block = snapshot.blocks.find(({ id }) => id === job.blockId);
-        return {
-          id: job.blockId,
-          kind: "block-summary",
-          attempts: job.attempts,
-          nextRetryAt: job.nextRetryAt,
-          lastError: job.lastError?.slice(0, 500) ?? null,
-          lastErrorFull: job.lastError,
-          updatedAt: job.updatedAt,
-          threadId: block?.threadId ?? null,
-          sequence: block?.sequence ?? null,
-          turnRange: block ? [block.startTurn, block.endTurn] : null
-        };
-      }),
       ...snapshot.extractionJobs.filter(({ status }) => status === "failed").map((job) => ({
         id: job.blockId,
         kind: "event-extraction",
@@ -7973,7 +7978,7 @@ async function memories(runtime, url) {
       const failedProjection = projections.find(({ status: status2 }) => status2 === "failed");
       const pendingProjection = projections.some(({ status: status2 }) => status2 === "pending" || status2 === "running");
       const needsExtraction = source.shouldExtract === true;
-      const status = summary?.status === "failed" ? "failed" : summary?.status === "pending" || summary?.status === "running" || !summary && source.processingStatus === "pending" ? "processing" : extraction?.status === "failed" || failedProjection ? "failed" : extraction?.status === "succeeded" || extraction?.status === "skipped" ? pendingProjection ? "processing" : "organized" : needsExtraction ? "waiting" : "organized";
+      const status = extraction?.status === "failed" || failedProjection ? "failed" : extraction?.status === "succeeded" || extraction?.status === "skipped" ? pendingProjection ? "processing" : "organized" : needsExtraction ? "waiting" : "organized";
       const blockPosition = scopedBlocks.findIndex(({ id }) => id === block.id) + 1;
       const latestBlockPosition = scopedBlocks.length;
       const currentLevel = getDecayedBlockLevel(
@@ -8131,20 +8136,6 @@ async function expandBlock(runtime, url) {
   if (!/^L?[0-5]$/i.test(target)) throw new AdminHttpError(400, "level must be L0 through L5");
   return runtime.adminExpandBlock(namespace, blockId, target);
 }
-async function retryBlockSummary(runtime, url) {
-  const namespace = url.searchParams.get("namespace")?.trim() ?? "";
-  const blockId = url.searchParams.get("blockId")?.trim() ?? "";
-  if (!namespace) throw new AdminHttpError(400, "namespace is required");
-  if (!blockId) throw new AdminHttpError(400, "blockId is required");
-  if (blockId.startsWith("virtual:")) throw new AdminHttpError(409, "Recovered legacy fragments cannot be retried");
-  const snapshot = await requiredSnapshot(runtime, namespace);
-  const job = snapshot.summaryJobs.find(({ blockId: candidateId }) => candidateId === blockId);
-  if (!job) throw new AdminHttpError(404, `Unknown Block Summary job: ${blockId}`);
-  if (job.status !== "failed" || job.nextRetryAt !== null) {
-    throw new AdminHttpError(409, "Block Summary is not in a terminal failed state");
-  }
-  return runtime.adminRetryBlockSummary(namespace, blockId);
-}
 function receiptSources(snapshot, receipt) {
   const events = snapshot.events.filter(({ id }) => receipt.eventIds.includes(id));
   const elements = snapshot.elements.filter(({ id }) => receipt.elementIds.includes(id));
@@ -8257,9 +8248,6 @@ async function handleAdminRequest(runtime, req, res) {
     } else if (path === "/api/stratagate/blocks/expand") {
       if (req.method !== "PATCH") throw new AdminHttpError(405, "StrataGate Block expansion requires PATCH");
       sendJson(res, 200, await expandBlock(runtime, url));
-    } else if (path === "/api/stratagate/blocks/retry-summary") {
-      if (req.method !== "POST") throw new AdminHttpError(405, "StrataGate Block Summary retry requires POST");
-      sendJson(res, 200, await retryBlockSummary(runtime, url));
     } else if (path === "/api/stratagate/import") {
       if (req.method === "GET") {
         const operation = url.searchParams.get("operation");
@@ -8299,6 +8287,7 @@ function registerAdminRoutes(ctx, runtime) {
 // src/index.ts
 var name = "stratagate-memory";
 var inject = ["tools", "systemPrompt", "llm", "agentDefaultModel"];
+var STRATAGATE_SETTINGS_NAMESPACE = "stratagate-memory";
 var MEMORY_PROTOCOL = `[StrataGate memory protocol]
 StrataGate provides durable, evidence-gated memory through memory_* tools.
 
@@ -8336,6 +8325,24 @@ async function apply(ctx, config) {
     await ctx.sessions.flush(session);
   }, () => feedbackWebOrigin(ctx));
   await runtime.syncConfiguredSettings();
+  const effortEntry = {
+    structuredReasoningEffort: resolved.structuredReasoningEffort ?? "auto"
+  };
+  let effortSource = () => effortEntry;
+  ctx.inject(["settings"], (settingsCtx) => {
+    settingsCtx.settings.installSection(
+      ctx,
+      STRATAGATE_SETTINGS_NAMESPACE,
+      StructuredReasoningEffortSettings,
+      effortEntry,
+      {
+        setSource: (current) => {
+          effortSource = current;
+        },
+        onChange: () => models.setStructuredReasoningEffort(effortSource().structuredReasoningEffort)
+      }
+    );
+  });
   ctx.systemPrompt.section({ name: "tool:stratagate-memory", order: 113, text: MEMORY_PROTOCOL });
   ctx.systemPrompt.section({ name: "tool:stratagate-feedback", order: 114, text: FEEDBACK_PROTOCOL });
   ctx.on("system-prompt/assemble", async (_assembly, context, next) => {
@@ -8381,6 +8388,7 @@ async function apply(ctx, config) {
 }
 export {
   Config,
+  STRATAGATE_SETTINGS_NAMESPACE,
   apply,
   inject,
   name