stratagate-dsh 0.2.77 → 0.2.79

package/dist/plugin.js

@@ -98,6 +98,11 @@ var FILLER_ONLY = /* @__PURE__ */ new Set([
 ]);
 var REPEATED_PASTE_MIN_CHARS = 80;
 var REPEATED_PASTE_MARKER = "[repeated paste omitted; original remains in L5]";
+var DERIVATION_SOURCE_FIELD_MIN_CHARS = 240;
+var DERIVATION_ARGUMENT_MAX_CHARS = 1200;
+var DERIVATION_RESULT_MAX_CHARS = 2400;
+var DERIVATION_TOOL_MESSAGE_MAX_CHARS = 2400;
+var DERIVATION_SOURCE_FIELD = /^(?:code|command|program|script|source|sourcecode)$/u;
 function asBlockLevel(value) {
   return Math.max(0, Math.min(BLOCK_MAX_LEVEL, Math.round(value)));
 }
@@ -161,6 +166,73 @@ function resultSummary(value) {
   if (record2.ok === false) return "not completed";
   return "structured result returned";
 }
+function serializedValue(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function sourceFieldName(value) {
+  return DERIVATION_SOURCE_FIELD.test(value.replace(/[\s_-]+/gu, "").toLocaleLowerCase());
+}
+function omitLargeSourceFields(value, key = "", seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof value === "string") {
+    if (!sourceFieldName(key) || value.length <= DERIVATION_SOURCE_FIELD_MIN_CHARS) return value;
+    return `[${key || "source"} omitted: ${value.length} chars; full value remains in L5]`;
+  }
+  if (!value || typeof value !== "object") return value;
+  if (seen.has(value)) return "[circular value omitted; full value remains in L5]";
+  seen.add(value);
+  if (Array.isArray(value)) return value.map((item) => omitLargeSourceFields(item, key, seen));
+  return Object.fromEntries(Object.entries(value).map(([nestedKey, nestedValue]) => [nestedKey, omitLargeSourceFields(nestedValue, nestedKey, seen)]));
+}
+function compactDerivationValue(value, maxChars, label) {
+  const rendered = serializedValue(value);
+  if (rendered.length <= maxChars) return value;
+  const summary = resultSummary(value);
+  const headChars = Math.max(160, Math.floor(maxChars * 0.48));
+  const tailChars = Math.max(80, Math.floor(maxChars * 0.2));
+  const omittedChars = Math.max(0, rendered.length - headChars - tailChars);
+  return {
+    _stratagate: `${label} compacted; full value remains in L5`,
+    originalChars: rendered.length,
+    ...summary ? { summary } : {},
+    head: rendered.slice(0, headChars),
+    tail: rendered.slice(-tailChars),
+    omittedChars
+  };
+}
+function compactDerivationText(value, maxChars, label) {
+  if (value.length <= maxChars) return value;
+  const headChars = Math.max(160, Math.floor(maxChars * 0.6));
+  const tailChars = Math.max(80, Math.floor(maxChars * 0.2));
+  const omittedChars = Math.max(0, value.length - headChars - tailChars);
+  return `${value.slice(0, headChars)}
+[${label} compacted: ${omittedChars} chars omitted; full value remains in L5]
+${value.slice(-tailChars)}`;
+}
+function buildMemoryDerivationMessages(messages) {
+  return messages.map((message) => ({
+    ...message,
+    content: message.role === "tool" ? compactDerivationText(message.content, DERIVATION_TOOL_MESSAGE_MAX_CHARS, "tool message content") : message.content,
+    ...message.toolCalls ? {
+      toolCalls: message.toolCalls.map((trace) => {
+        const argumentsValue = trace.arguments === void 0 ? void 0 : compactDerivationValue(
+          omitLargeSourceFields(trace.arguments),
+          DERIVATION_ARGUMENT_MAX_CHARS,
+          "tool arguments"
+        );
+        return {
+          name: trace.name,
+          ...argumentsValue === void 0 ? {} : { arguments: argumentsValue },
+          ...trace.result === void 0 ? {} : { result: compactDerivationValue(trace.result, DERIVATION_RESULT_MAX_CHARS, "tool result") }
+        };
+      })
+    } : {}
+  }));
+}
 function summarizeToolTrace(trace) {
   const summary = resultSummary(trace.result);
   return `Tool call: ${trace.name}${summary ? ` (${summary})` : ""}`;
@@ -5426,7 +5498,14 @@ function l2Neighbor(block) {
 }
 function extractorPayload(context) {
   return {
-    target: context.target,
+    target: {
+      blockId: context.target.id,
+      sequence: context.target.sequence,
+      startTurn: context.target.startTurn,
+      endTurn: context.target.endTurn,
+      createdAt: context.target.createdAt,
+      messages: buildMemoryDerivationMessages(context.target.l5Raw)
+    },
     neighbors: {
       previous: l2Neighbor(context.previous),
       next: l2Neighbor(context.next)
@@ -5672,6 +5751,7 @@ var DshModelBridge = class {
     this.structuredReasoningEffort = config.structuredReasoningEffort ?? "auto";
     this.ctx.on?.("llm/adapters-updated", () => {
       this.offCapabilities.clear();
+      for (const listener of this.adaptersUpdatedListeners) listener();
     });
   }
   ctx;
@@ -5680,7 +5760,24 @@ var DshModelBridge = class {
   successfulResponses = [];
   offCapabilities = /* @__PURE__ */ new Map();
   warnedOffFallbackRoutes = /* @__PURE__ */ new Set();
+  adaptersUpdatedListeners = /* @__PURE__ */ new Set();
   structuredReasoningEffort;
+  /** True only when the exact provider route has a registered DSH adapter. */
+  isReady(session) {
+    try {
+      const { provider } = this.resolveRoute(session);
+      return this.ctx.llm.listProviders().some(({ id }) => id === provider);
+    } catch {
+      return false;
+    }
+  }
+  /** Wake durable workers when DSH changes the adapter registry. */
+  onAdaptersUpdated(listener) {
+    this.adaptersUpdatedListeners.add(listener);
+    return () => {
+      this.adaptersUpdatedListeners.delete(listener);
+    };
+  }
   setStructuredReasoningEffort(mode) {
     this.structuredReasoningEffort = mode;
   }
@@ -5697,8 +5794,8 @@ var DshModelBridge = class {
   summarizer = async (messages) => {
     const raw = object(await this.callStructured(
       "summarizer",
-      `You compress agent conversations into durable memory blocks. Read the supplied messages and call ${STRUCTURED_TOOLS.summarizer.name} exactly once with l0Title, l0Tags, l1Summary, l2Keypoints, and shouldExtract. Preserve decisions, constraints, preferences, outcomes, and unresolved work. shouldExtract is true only when durable events or facts exist. Do not return the summary as text.`,
-      { messages }
+      `You compress agent conversations into durable memory blocks. Read the supplied provenance-preserving derivation messages and call ${STRUCTURED_TOOLS.summarizer.name} exactly once with l0Title, l0Tags, l1Summary, l2Keypoints, and shouldExtract. Preserve decisions, constraints, preferences, outcomes, and unresolved work. Tool code and oversized tool payloads may be marked compacted; use the retained tool names, evidence summaries, and excerpts without inventing omitted details. shouldExtract is true only when durable events or facts exist. Do not return the summary as text.`,
+      { messages: buildMemoryDerivationMessages(messages) }
     ));
     return {
       l0Title: text2(raw.l0Title).slice(0, 120),
@@ -5712,7 +5809,7 @@ var DshModelBridge = class {
     const validMessageIds = new Set(context.target.l5Raw.map((message) => message.id));
     const raw = object(await this.callStructured(
       "extractor",
-      `Extract only durable, evidence-backed events from target.l5Raw, then call ${STRUCTURED_TOOLS.extractor.name} exactly once. The target block is the only legal source of new facts, quotations, and sourceMessageIds. neighbors.previous and neighbors.next are context-only L2 summaries; never extract from them. Every sourceMessageIds entry must exactly match allowedSourceMessageIds. If a fact appears only in a neighbor, do not extract it in this call. Events must be understandable later without the original chat. Use project scope for repository decisions, user scope for stable preferences/identity, and session scope for temporary task state. temporal.eventType must use exactly one stable value: decision, release, task_completed, plan, change, cancellation, incident, meeting, collaboration, migration, or other. temporal.participants contains canonical entity names. Use ISO-8601 timestamps with the explicit +08:00 offset in temporal fields. Keep happened time separate from mentionedAt; when happened time is unknown omit it and set precision/basis to unknown. Do not turn an assistant statement that merely recalls older memory into a new event; require new human input or a new observable task/tool outcome from target.l5Raw. Do not return the result as text.`,
+      `Extract only durable, evidence-backed events from target.messages, then call ${STRUCTURED_TOOLS.extractor.name} exactly once. target.messages is a provenance-preserving derivation view of the target block: message ids and conversational text are retained, while tool code and oversized tool payloads may be marked compacted. Use the retained tool names, evidence summaries, and excerpts without inventing omitted details. The target block is the only legal source of new facts, quotations, and sourceMessageIds. neighbors.previous and neighbors.next are context-only L2 summaries; never extract from them. Every sourceMessageIds entry must exactly match allowedSourceMessageIds. If a fact appears only in a neighbor, do not extract it in this call. Events must be understandable later without the original chat. Use project scope for repository decisions, user scope for stable preferences/identity, and session scope for temporary task state. temporal.eventType must use exactly one stable value: decision, release, task_completed, plan, change, cancellation, incident, meeting, collaboration, migration, or other. temporal.participants contains canonical entity names. Use ISO-8601 timestamps with the explicit +08:00 offset in temporal fields. Keep happened time separate from mentionedAt; when happened time is unknown omit it and set precision/basis to unknown. Do not turn an assistant statement that merely recalls older memory into a new event; require new human input or a new observable task/tool outcome from target.messages. Do not return the result as text.`,
       extractorPayload(context)
     ));
     const events = (Array.isArray(raw.events) ? raw.events : []).map((candidate) => {
@@ -5891,6 +5988,7 @@ var DshModelBridge = class {
     let lastError;
     let lastResponse = "";
     let attemptsUsed = 0;
+    let noAdapterRetried = false;
     for (let attempt = 1; attempt <= JSON_RESPONSE_ATTEMPTS; attempt += 1) {
       attemptsUsed = attempt;
       const message = createUserMessage({
@@ -5921,6 +6019,11 @@ ${JSON_RETRY_INSTRUCTION}`,
       try {
         await this.consumeStructuredStream(request, assembler);
       } catch (error) {
+        if (!noAdapterRetried && isNoAdapter(error)) {
+          noAdapterRetried = true;
+          attempt -= 1;
+          continue;
+        }
         if (useOff && isOffRejection(error)) {
           this.offCapabilities.set(routeKey, "unsupported");
           useOff = false;
@@ -5933,6 +6036,11 @@ ${JSON_RETRY_INSTRUCTION}`,
       const finish = assembler.finish;
       if (finish.kind === "error" || finish.kind === "aborted") {
         const failure = new Error(`StrataGate model call failed [${finish.failure.code}]: ${finish.failure.message}`);
+        if (!noAdapterRetried && isNoAdapter(finish.failure)) {
+          noAdapterRetried = true;
+          attempt -= 1;
+          continue;
+        }
         if (useOff && isOffRejection(finish.failure)) {
           this.offCapabilities.set(routeKey, "unsupported");
           useOff = false;
@@ -6098,6 +6206,17 @@ ${JSON_RETRY_INSTRUCTION}`,
     return { provider: fallback.provider, model: fallback.model };
   }
 };
+function isNoAdapter(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current && typeof current === "object" && !seen.has(current)) {
+    seen.add(current);
+    const candidate = current;
+    if (candidate.code === "NO_ADAPTER") return true;
+    current = candidate.cause;
+  }
+  return false;
+}
 function isOffRejection(error) {
   let detail;
   try {
@@ -6539,6 +6658,7 @@ var StrataGateRuntime = class {
     this.openPath = openPath;
     this.blockTurnSize = config.blockTurnSize;
     this.blockDecayLambda = config.blockDecayLambda;
+    this.disposeAdaptersUpdated = this.models.onAdaptersUpdated(() => this.wakeModelWorkers());
     this.scheduleBackgroundWorker(BACKGROUND_WORKER_INITIAL_DELAY_MS);
   }
   config;
@@ -6553,6 +6673,7 @@ var StrataGateRuntime = class {
   latestBatchIds = /* @__PURE__ */ new Map();
   workspaceNames = /* @__PURE__ */ new Map();
   migrationTimers = /* @__PURE__ */ new Map();
+  migrationRuns = /* @__PURE__ */ new Map();
   derivationTimers = /* @__PURE__ */ new Map();
   derivationRuns = /* @__PURE__ */ new Map();
   knownSessions = /* @__PURE__ */ new Map();
@@ -6571,6 +6692,8 @@ var StrataGateRuntime = class {
   backgroundNamespaceRuns = /* @__PURE__ */ new Map();
   backgroundWorkerTimer;
   backgroundWorkerRun;
+  backgroundWorkerWakePending = false;
+  disposeAdaptersUpdated;
   settingsTail = Promise.resolve();
   batchSequence = 0;
   closed = false;
@@ -6586,13 +6709,15 @@ var StrataGateRuntime = class {
       this.backgroundWorkerRun = run;
       void run.finally(() => {
         if (this.backgroundWorkerRun === run) this.backgroundWorkerRun = void 0;
-        this.scheduleBackgroundWorker(BACKGROUND_WORKER_INTERVAL_MS);
+        const delay = this.backgroundWorkerWakePending ? 0 : BACKGROUND_WORKER_INTERVAL_MS;
+        this.backgroundWorkerWakePending = false;
+        this.scheduleBackgroundWorker(delay);
       });
     }, delayMs);
     this.backgroundWorkerTimer.unref?.();
   }
   async runBackgroundWorker() {
-    if (this.closed) return;
+    if (this.closed || !this.models.isReady()) return;
     let namespaces;
     try {
       namespaces = await this.adminNamespaces();
@@ -6610,6 +6735,7 @@ var StrataGateRuntime = class {
     }
   }
   async runBackgroundNamespace(namespace) {
+    if (this.closed || !this.models.isReady()) return;
     const existing = this.backgroundNamespaceRuns.get(namespace);
     if (existing) return existing;
     const run = (async () => {
@@ -6625,9 +6751,11 @@ var StrataGateRuntime = class {
         const hasActiveSessionWork = [
           ...this.derivationTimers.keys(),
           ...this.derivationRuns.keys(),
-          ...this.migrationTimers.keys()
+          ...this.migrationTimers.keys(),
+          ...this.migrationRuns.keys()
         ].some((key) => key.startsWith(`${namespace}\0`) || key === namespace);
         if (hasActiveSessionWork) return;
+        if (!this.models.isReady()) return;
         const resumed = await this.models.runDetached(
           `stratagate-worker:${namespace}`,
           () => memory.resumePendingWork()
@@ -6655,6 +6783,33 @@ var StrataGateRuntime = class {
       if (this.backgroundNamespaceRuns.get(namespace) === run) this.backgroundNamespaceRuns.delete(namespace);
     }
   }
+  wakeBackgroundWorker() {
+    if (this.closed) return;
+    if (this.backgroundWorkerTimer) {
+      clearTimeout(this.backgroundWorkerTimer);
+      this.backgroundWorkerTimer = void 0;
+    }
+    if (this.backgroundWorkerRun) {
+      this.backgroundWorkerWakePending = true;
+      return;
+    }
+    this.scheduleBackgroundWorker(0);
+  }
+  wakeModelWorkers() {
+    if (this.closed) return;
+    this.wakeBackgroundWorker();
+    for (const reference of this.knownSessions.values()) {
+      const session = reference.deref();
+      if (!session || !this.models.isReady(session)) continue;
+      const opening = this.spaces.get(this.namespaceFor(session));
+      if (!opening) continue;
+      void opening.then((memory) => {
+        if (this.closed || !this.models.isReady(session)) return;
+        this.scheduleGraphMigration(session, memory);
+        this.scheduleBlockDerivation(session, memory);
+      }).catch((error) => this.onIngestError(error));
+    }
+  }
   acceptEvent(session, event) {
     if (this.closed) return;
     if (!this.config.ingestSubagents && session.header.origin === "subagent") return;
@@ -7138,6 +7293,7 @@ var StrataGateRuntime = class {
   async close() {
     if (this.closed) return;
     this.closed = true;
+    this.disposeAdaptersUpdated();
     if (this.backgroundWorkerTimer) clearTimeout(this.backgroundWorkerTimer);
     this.backgroundWorkerTimer = void 0;
     for (const timer of this.migrationTimers.values()) clearTimeout(timer);
@@ -7155,6 +7311,7 @@ var StrataGateRuntime = class {
     const settled = await Promise.allSettled(this.spaces.values());
     await Promise.allSettled(this.backgroundNamespaceRuns.values());
     if (this.backgroundWorkerRun) await Promise.allSettled([this.backgroundWorkerRun]);
+    await Promise.allSettled(this.migrationRuns.values());
     await Promise.allSettled(this.derivationRuns.values());
     await Promise.allSettled(this.externalImportRuns.values());
     await Promise.all(settled.flatMap((result) => result.status === "fulfilled" ? [result.value.close()] : []));
@@ -7691,6 +7848,9 @@ var StrataGateRuntime = class {
           if (kind === "event-extraction") return memory.retryEventExtraction(jobId);
           return memory.retryGraphProjection(jobId);
         };
+        if (!this.models.isReady(session)) {
+          throw new Error("StrataGate model adapter is not ready; retry after DSH finishes registering adapters");
+        }
         const result = session && this.namespaceFor(session) === key ? await this.models.run(session, retry) : await this.models.runDetached(threadId, retry);
         await this.persistSuccessfulResponses(memory);
         const currentBlock = blockId ? memory.listBlocks().find(({ id: candidateId }) => candidateId === blockId) : void 0;
@@ -7890,7 +8050,7 @@ var StrataGateRuntime = class {
   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;
+    if (this.closed || !this.models.isReady(session) || 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 = [
@@ -7901,7 +8061,7 @@ var StrataGateRuntime = class {
     const delay = Math.max(0, Math.min(...retryTimes) - Date.now());
     const timer = setTimeout(() => {
       this.derivationTimers.delete(key);
-      if (this.closed) return;
+      if (this.closed || !this.models.isReady(session)) return;
       const failedBefore = this.failedCoreJobs(memory);
       const run = this.models.run(session, () => memory.resumePendingWork({ threadId })).then(async (resumed) => {
         await this.persistSuccessfulResponses(memory);
@@ -7929,24 +8089,29 @@ var StrataGateRuntime = class {
   }
   scheduleGraphMigration(session, memory) {
     const namespace = this.namespaceFor(session);
-    if (this.closed || this.migrationTimers.has(namespace)) return;
+    if (this.closed || !this.models.isReady(session) || this.migrationTimers.has(namespace) || this.migrationRuns.has(namespace)) return;
     if (typeof memory.listGraphProjectionJobs !== "function") return;
     const pending = memory.listGraphProjectionJobs().some((job) => graphProjectionCanRun(job));
     if (!pending) return;
     const timer = setTimeout(() => {
       this.migrationTimers.delete(namespace);
-      if (this.closed) return;
+      if (this.closed || !this.models.isReady(session)) return;
       const failedBefore = this.failedCoreJobs(memory);
       const completedBefore = memory.listGraphProjectionJobs().filter(({ status }) => status === "completed").length;
-      void this.models.run(session, () => memory.resumePendingWork()).then(async () => {
+      let madeProgress = false;
+      const run = this.models.run(session, () => memory.resumePendingWork()).then(async () => {
         await this.persistSuccessfulResponses(memory);
         this.noteNewCoreJobFailures(session, failedBefore, memory);
         const completedAfter = memory.listGraphProjectionJobs().filter(({ status }) => status === "completed").length;
-        if (completedAfter > completedBefore) this.scheduleGraphMigration(session, memory);
+        madeProgress = completedAfter > completedBefore;
       }).catch((error) => {
         this.notePluginError(session, error);
         this.onIngestError(error);
+      }).finally(() => {
+        if (this.migrationRuns.get(namespace) === run) this.migrationRuns.delete(namespace);
+        if (madeProgress) this.scheduleGraphMigration(session, memory);
       });
+      this.migrationRuns.set(namespace, run);
     }, 1500);
     timer.unref?.();
     this.migrationTimers.set(namespace, timer);