stratagate-dsh 0.2.33 → 0.2.35

package/dist/index.js

@@ -3254,6 +3254,11 @@ var StrataGate = class _StrataGate {
     }
     return hits;
   }
+  /**
+   * Return decayed block views. Passing a threadId limits the result to that
+   * conversation; omitting it intentionally returns every thread in this
+   * StrataGate namespace (never another namespace).
+   */
   getBlockContext(threadId) {
     const blocks = threadId === void 0 ? this.blocks : this.blocks.filter((block) => block.threadId === threadId);
     return blocks.map((block) => {
@@ -3474,6 +3479,16 @@ var StrataGate = class _StrataGate {
   }
   async searchGraphNodes(query, limit = 8) {
     const candidates = this.graphNodes.filter((node) => node.status === "active" || node.status === "disputed");
+    const queryTokens = [...new Set(searchTokens(query))];
+    const fieldValues = (node) => [
+      ["name", node.name],
+      ["aliases", node.aliases.join(" ")],
+      ["tags", (node.tags ?? []).join(" ")],
+      ["type", node.type],
+      ["currentState", node.currentState],
+      ["facts", node.facts.map((fact) => `${fact.key} ${Array.isArray(fact.value) ? fact.value.join(" ") : fact.value}`).join(" ")],
+      ["relations", this.graphEdges.filter((edge) => edge.fromNodeId === node.id || edge.toNodeId === node.id).map(({ relation }) => relation).join(" ")]
+    ];
     const ranked = bm25Rank(candidates, query, (node) => weightedSearchTokens([
       [node.name, 6],
       [node.aliases.join(" "), 5],
@@ -3482,9 +3497,28 @@ var StrataGate = class _StrataGate {
       [node.currentState, 4],
       [node.facts.map((fact) => `${fact.key} ${Array.isArray(fact.value) ? fact.value.join(" ") : fact.value}`).join(" "), 4],
       [this.graphEdges.filter((edge) => edge.fromNodeId === node.id || edge.toNodeId === node.id).map(({ relation }) => relation).join(" "), 3]
-    ])).slice(0, Math.max(1, Math.min(20, limit)));
+    ])).filter(({ item }) => {
+      const fields = fieldValues(item);
+      const matches = fields.filter(([, value]) => {
+        const haystack = new Set(searchTokens(value));
+        return queryTokens.some((token) => haystack.has(token));
+      }).map(([field]) => field);
+      if (!matches.some((field) => field !== "relations")) return false;
+      return matches.some((field) => field !== "relations");
+    }).slice(0, Math.max(1, Math.min(20, limit)));
     if (searchTokens(query).length > 0 && ranked.length === 0) return [];
-    return ranked.map(({ item: node, score }) => ({ node, score }));
+    return ranked.map(({ item: node, score }) => {
+      const matchedFields = fieldValues(node).filter(([, value]) => {
+        const haystack = new Set(searchTokens(value));
+        return queryTokens.some((token) => haystack.has(token));
+      }).map(([field]) => field);
+      return {
+        node,
+        score,
+        matchedFields,
+        matchReason: `Lexical match in ${matchedFields.join(", ") || "indexed fields"}; score is ranking-only.`
+      };
+    });
   }
   requireGraphProjectionJob(id) {
     const job = this.graphProjectionJobs.get(id);
@@ -4713,7 +4747,7 @@ var StrataGateRuntime = class {
     return this.batch(session, results.map(({ event }) => ({
       ref: `event:${event.id}`,
       target: { eventIds: [event.id], elementIds: [] }
-    })), results);
+    })), results.map(({ event, score }) => compactEvent(event, score)));
   }
   async searchElements(session, query, options = {}) {
     await this.flush();
@@ -4721,23 +4755,53 @@ var StrataGateRuntime = class {
     return this.batch(session, results.map((result) => ({
       ref: `element:${result.elementId}:fact:${result.id}`,
       target: { eventIds: [], elementIds: [result.elementId] }
-    })), results);
+    })), results.map((result) => ({
+      id: result.id,
+      elementId: result.elementId,
+      name: result.name,
+      type: result.type,
+      factKey: result.fact.key,
+      value: Array.isArray(result.fact.value) ? result.fact.value.join(", ") : result.fact.value,
+      validFrom: result.fact.validFrom,
+      validTo: result.fact.validTo,
+      rankScore: result.score,
+      scoreMeaning: "Ranking-only BM25/RRF score; not confidence or factual accuracy."
+    })));
   }
-  async searchRaw(session, query, limit) {
+  async searchRaw(session, query, limit, scope = "namespace") {
     await this.flush();
-    const results = (await this.space(session)).searchRawMemory(query, limit);
+    const memory = await this.space(session);
+    const threadId = String(session.id);
+    const results = memory.searchRawMemory(query, scope === "namespace" ? limit : Number.MAX_SAFE_INTEGER).filter((result) => scope === "namespace" || result.message.threadId === threadId || result.message.threadId === void 0).slice(0, limit);
     return this.batch(session, results.map((result, index) => ({
       ref: `raw:${result.blockId}:${result.message.id}:${index}`,
       target: { eventIds: [], elementIds: [] }
-    })), results);
+    })), results.map(compactRawHit), { scope, namespace: this.namespaceFor(session), threadId });
   }
-  async blocks(session) {
+  async blocks(session, scope = "session") {
     await this.flush();
-    const results = (await this.space(session)).getBlockContext(String(session.id));
+    const memory = await this.space(session);
+    const threadId = String(session.id);
+    const snapshot = memory.exportSnapshot();
+    const namespaceBlockCount = snapshot.blocks.length;
+    const namespaceThreadIds = [...new Set(snapshot.blocks.map((block) => block.threadId).filter((value) => Boolean(value)))];
+    const openTailCount = snapshot.openTail.filter((message) => scope === "namespace" || message.threadId === threadId || message.threadId === void 0).length;
+    const results = scope === "namespace" ? memory.getBlockContext() : memory.getBlockContext().filter((block) => block.threadId === threadId || block.threadId === void 0);
+    const emptyReason = results.length > 0 ? null : namespaceBlockCount === 0 ? openTailCount > 0 ? "open_tail_pending" : "no_blocks_in_namespace" : openTailCount > 0 ? "open_tail_pending" : "blocks_exist_in_other_threads";
+    const status = {
+      scope,
+      namespace: this.namespaceFor(session),
+      threadId,
+      blockCount: results.length,
+      namespaceBlockCount,
+      namespaceThreadIds,
+      openTailCount,
+      emptyReason
+    };
     return this.batch(session, results.map((result) => ({
       ref: `block:${result.id}:level:${result.level}`,
       target: { eventIds: [], elementIds: [] }
-    })), results);
+    })), results, status);
   }
   async expandBlock(session, id, target) {
     await this.flush();
@@ -5220,7 +5284,7 @@ var StrataGateRuntime = class {
     return this.batch(session, results.map(({ node }) => ({
       ref: `graph-node:${node.id}`,
       target: { eventIds: node.sourceEventIds, elementIds: [] }
-    })), results);
+    })), results.map(({ node, score, matchedFields, matchReason }) => compactGraphNode(node, score, matchedFields, matchReason)));
   }
   async expandGraphNode(session, id) {
     await this.flush();
@@ -5274,7 +5338,7 @@ var StrataGateRuntime = class {
     const responses = this.models.takeSuccessfulResponses();
     if (responses.length > 0) await memory.recordSuccessfulModelResponses(responses);
   }
-  batch(session, evidence, results) {
+  batch(session, evidence, results, metadata = {}) {
     const id = `batch_${++this.batchSequence}`;
     const refs = new Map(evidence.map(({ ref, target }) => [ref, target]));
     const key = String(session.id);
@@ -5285,7 +5349,7 @@ var StrataGateRuntime = class {
     }
     sessionBatches.set(id, { id, refs, status: "unresolved" });
     this.latestBatchIds.set(key, id);
-    return { batchId: id, evidenceRefs: [...refs.keys()], results };
+    return { batchId: id, evidenceRefs: [...refs.keys()], results, ...metadata };
   }
   requireBatch(session, batchId, operation) {
     const key = String(session.id);
@@ -5420,6 +5484,67 @@ function renderBlockSurfaceMessage(context) {
     context.content
   ].join("\n");
 }
+function compactTemporal(event) {
+  const temporal = event.temporal;
+  return Object.fromEntries(Object.entries({
+    mentionedAt: temporal.mentionedAt,
+    happenedStart: temporal.happenedStart,
+    happenedEnd: temporal.happenedEnd,
+    precision: temporal.precision,
+    status: temporal.status,
+    eventType: temporal.eventType
+  }).filter(([, value]) => value !== void 0));
+}
+function compactText2(value, limit = 800) {
+  return value.replace(/\s+/gu, " ").trim().slice(0, limit);
+}
+function compactEvent(event, score) {
+  return {
+    id: event.id,
+    title: compactText2(event.title, 240),
+    summary: compactText2(event.summary),
+    sourceTime: event.temporal.happenedStart ?? event.temporal.mentionedAt ?? event.createdAt,
+    temporal: compactTemporal(event),
+    sourceBlockId: event.sourceBlockId,
+    status: event.status,
+    scope: event.scope,
+    criticality: event.criticality,
+    rankScore: score,
+    scoreMeaning: "Ranking-only BM25/RRF score; not confidence, probability, or factual accuracy."
+  };
+}
+function compactGraphNode(node, score, matchedFields, matchReason) {
+  return {
+    id: node.id,
+    name: node.name,
+    type: node.type,
+    aliases: node.aliases.map((alias) => compactText2(alias, 160)),
+    currentState: compactText2(node.currentState, 500),
+    status: node.status,
+    rankScore: score,
+    ...matchedFields ? { matchedFields } : {},
+    ...matchReason ? { matchReason } : {},
+    scoreMeaning: "Ranking-only BM25/RRF score; not confidence, probability, or factual accuracy."
+  };
+}
+function compactRawHit(result) {
+  const message = {
+    id: result.message.id,
+    role: result.message.role,
+    content: compactText2(result.message.content, 500),
+    createdAt: result.message.createdAt,
+    ...result.message.threadId ? { threadId: result.message.threadId } : {}
+  };
+  return {
+    id: result.message.id,
+    blockId: result.blockId,
+    turnRange: result.turnRange,
+    message,
+    sourceTime: result.message.createdAt,
+    ...result.message.threadId ? { threadId: result.message.threadId } : {},
+    detailHint: "Use memory_expand_block with blockId for complete block/source details."
+  };
+}
 function currentBlockSurfaceMessages(session) {
   const blocks = /* @__PURE__ */ new Map();
   if (!session.surface?.nodes) return blocks;
@@ -5564,7 +5689,7 @@ function sessionOf(exec) {
 function registerMemoryTools(ctx, runtime) {
   ctx.tools.register(defineTool({
     name: "memory_search_events",
-    description: "Search durable StrataGate event memories. Returns a batchId, evidenceRefs, and ranked event cards. Pass that batchId to memory_assess before relying on its evidence.",
+    description: "Search durable StrataGate event memories. Returns a compact batch of event cards (id, title, summary, time, and evidence refs); call memory_expand_event for narrative/quotes/source messages. rankScore is BM25/RRF ordering only, never confidence or factual accuracy. Pass batchId to memory_assess before relying on evidence.",
     parameters: {
       query: { type: "string", required: true, description: "What historical decision, event, preference, or outcome to find." },
       limit: { type: "integer", description: "Maximum results, 1-20." },
@@ -5582,7 +5707,7 @@ function registerMemoryTools(ctx, runtime) {
   }));
   ctx.tools.register(defineTool({
     name: "memory_search_graph",
-    description: "Search the current Event-backed Knowledge Graph for people, projects, organizations, tools, places, facts, and relations. Returns an independently assessable retrieval batch.",
+    description: "Search the current Event-backed Knowledge Graph for people, projects, organizations, tools, places, facts, and relations. Returns compact node cards with matchedFields/matchReason; call memory_expand_graph_node for complete facts and edges. rankScore is BM25/RRF ordering only, never confidence or factual accuracy. Results are independently assessable.",
     parameters: {
       query: { type: "string", required: true },
       limit: { type: "integer", description: "Maximum results, 1-20." }
@@ -5599,7 +5724,7 @@ function registerMemoryTools(ctx, runtime) {
   }));
   ctx.tools.register(defineTool({
     name: "memory_search_elements",
-    description: "Deprecated compatibility search for legacy Element-card data. Prefer memory_search_graph.",
+    description: "Deprecated compatibility search for legacy Element-card data. Returns compact fact hits; rankScore is BM25/RRF ordering only, never confidence or factual accuracy. Prefer memory_search_graph.",
     parameters: {
       query: { type: "string", required: true },
       limit: { type: "integer" },
@@ -5615,20 +5740,23 @@ function registerMemoryTools(ctx, runtime) {
   }));
   ctx.tools.register(defineTool({
     name: "memory_search_raw",
-    description: "Search verbatim archived messages when summarized memories are insufficient. Returns raw evidence refs and a batchId for assessment.",
+    description: "Search archived messages when summarized memories are insufficient. Returns compact raw hits (message id, blockId, excerpt, role, and time); use memory_expand_block with blockId for complete source details. By default searches the whole current namespace; use scope=session for the active thread. Returns evidence refs and batchId for assessment.",
     parameters: {
       query: { type: "string", required: true },
-      limit: { type: "integer" }
+      limit: { type: "integer" },
+      scope: { type: "string", enum: ["namespace", "session"], description: "Search range. Defaults to namespace for compatibility with historical raw search behavior." }
     },
     output: jsonOutput,
-    execute: async (args, exec) => runtime.searchRaw(sessionOf(exec), args.query, args.limit)
+    execute: async (args, exec) => runtime.searchRaw(sessionOf(exec), args.query, args.limit, args.scope)
   }));
   ctx.tools.register(defineTool({
     name: "memory_get_blocks",
-    description: "List decayed conversation-block summaries and their current detail levels. Returns block evidence refs and a batchId for assessment.",
-    parameters: {},
+    description: "List decayed conversation-block summaries and their current detail levels. Defaults to the active session only; use scope=namespace to inspect every thread in the current namespace. The response always reports scope, namespace, threadId, counts, and a machine-readable emptyReason when no blocks match.",
+    parameters: {
+      scope: { type: "string", enum: ["session", "namespace"], description: "Query range. Defaults to session to preserve existing isolation behavior." }
+    },
     output: jsonOutput,
-    execute: async (_args, exec) => runtime.blocks(sessionOf(exec))
+    execute: async (args, exec) => runtime.blocks(sessionOf(exec), args.scope)
   }));
   ctx.tools.register(defineTool({
     name: "memory_expand_block",