stratagate-dsh 0.2.55 → 0.2.57

package/dist/index.js

@@ -2986,6 +2986,35 @@ 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()];
   }
@@ -5566,6 +5595,8 @@ 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();
@@ -5936,6 +5967,33 @@ 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;
@@ -6455,6 +6513,44 @@ 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;
@@ -6517,8 +6613,9 @@ var StrataGateRuntime = class {
       }
     }
   }
-  space(session) {
+  async 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) {
@@ -6531,20 +6628,20 @@ var StrataGateRuntime = class {
         extractor: this.models.extractor,
         graphProjector: this.models.graphProjector,
         disableElementProjection: true
-      }).then(async (memory) => {
+      }).then(async (memory2) => {
         try {
           try {
-            await memory.resumePendingWork({ deferDerivation: true, threadId: String(session.id) });
-            const contexts = memory.getBlockContext(String(session.id));
+            await memory2.resumePendingWork({ deferDerivation: true, threadId: String(session.id) });
+            const contexts = memory2.getBlockContext(String(session.id));
             this.syncDecayedBlockSurface(session, contexts);
           } finally {
-            await this.persistSuccessfulResponses(memory);
+            await this.persistSuccessfulResponses(memory2);
           }
-          this.scheduleGraphMigration(session, memory);
-          this.scheduleBlockDerivation(session, memory);
-          return memory;
+          this.scheduleGraphMigration(session, memory2);
+          this.scheduleBlockDerivation(session, memory2);
+          return memory2;
         } catch (error) {
-          await memory.close().catch(() => {
+          await memory2.close().catch(() => {
           });
           throw error;
         }
@@ -6554,7 +6651,9 @@ var StrataGateRuntime = class {
         if (this.spaces.get(namespace) === opening) this.spaces.delete(namespace);
       });
     }
-    return opening;
+    const memory = await opening;
+    await this.syncPendingRetrySurface(session, memory);
+    return memory;
   }
   async searchGraph(session, query, limit = 8) {
     await this.flush();
@@ -6658,7 +6757,7 @@ var StrataGateRuntime = class {
   noteNewCoreJobFailures(session, before, memory) {
     if ([...this.failedCoreJobs(memory)].some((failure) => !before.has(failure))) this.notePluginError(session);
   }
-  async openAdminMemory(namespace) {
+  async openAdminMemory(namespace, options = {}) {
     const active = this.spaces.get(namespace);
     if (active) return { memory: await active, owned: false };
     if (this.config.database === ":memory:" || !existsSync(this.config.database)) {
@@ -6670,6 +6769,10 @@ 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
       }),
@@ -7315,7 +7418,7 @@ function clusterKnowledgeGraph(rawNodes, rawEdges) {
 }
 
 // src/web.ts
-var STRATAGATE_DSH_VERSION = "0.2.52";
+var STRATAGATE_DSH_VERSION = "0.2.57";
 var LEGACY_THREAD_ID = "__legacy__";
 var nodeRequire = createRequire(import.meta.url);
 function installedPackageVersion(names) {
@@ -7458,9 +7561,24 @@ async function overview(runtime, cachedEntries) {
   const rows = [];
   for (const { namespace, snapshot } of entries) {
     if (!snapshot) continue;
-    const failedJobs = snapshot.extractionJobs.filter(({ status }) => status === "failed").length + snapshot.graphProjectionJobs.filter(({ status }) => status === "failed").length;
+    const failedJobs = snapshot.summaryJobs.filter(({ status }) => status === "failed").length + 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",
@@ -7855,7 +7973,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 = extraction?.status === "failed" || failedProjection ? "failed" : extraction?.status === "succeeded" || extraction?.status === "skipped" ? pendingProjection ? "processing" : "organized" : needsExtraction ? "waiting" : "organized";
+      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 blockPosition = scopedBlocks.findIndex(({ id }) => id === block.id) + 1;
       const latestBlockPosition = scopedBlocks.length;
       const currentLevel = getDecayedBlockLevel(
@@ -8013,6 +8131,20 @@ 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));
@@ -8125,6 +8257,9 @@ 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");