stratagate-dsh 0.1.0 → 0.2.0

package/dist/index.js

@@ -188,6 +188,7 @@ var DshModelBridge = class {
 
 // src/runtime.ts
 import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 
 // ../../src/blocks.ts
@@ -505,7 +506,7 @@ function rrfRank(rankings) {
 }
 
 // ../../src/storage.ts
-var STRATAGATE_STORAGE_SCHEMA_VERSION = 3;
+var STRATAGATE_STORAGE_SCHEMA_VERSION = 4;
 var StorageConflictError = class extends Error {
   constructor(namespace, expectedRevision, actualRevision) {
     super(`Storage revision conflict for ${namespace}: expected ${expectedRevision}, found ${actualRevision ?? "missing"}`);
@@ -541,6 +542,11 @@ function normalizeSnapshot(value) {
       schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
       ingestionReceipts: []
     };
+  } else if (schemaVersion === 3) {
+    snapshot = {
+      ...structuredClone(value),
+      schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION
+    };
   } else if (schemaVersion === STRATAGATE_STORAGE_SCHEMA_VERSION) {
     snapshot = structuredClone(value);
   } else {
@@ -882,6 +888,7 @@ CREATE TABLE IF NOT EXISTS usage_receipts (
   receipt_id TEXT NOT NULL,
   event_ids_json TEXT NOT NULL,
   element_ids_json TEXT NOT NULL,
+  audit_json TEXT NOT NULL DEFAULT '{}',
   created_at TEXT NOT NULL,
   PRIMARY KEY (namespace, receipt_id),
   FOREIGN KEY (namespace) REFERENCES memory_spaces(namespace) ON DELETE CASCADE
@@ -1116,14 +1123,18 @@ var SqliteStorage = class {
       updatedAt: row.updated_at
     }));
     const usageReceipts = this.database.prepare(`
-      SELECT receipt_id, event_ids_json, element_ids_json, created_at
+      SELECT receipt_id, event_ids_json, element_ids_json, audit_json, created_at
       FROM usage_receipts WHERE namespace = ? ORDER BY created_at, receipt_id
-    `).all(key).map((row) => ({
-      id: row.receipt_id,
-      eventIds: parseJson(row.event_ids_json, "usage_receipts.event_ids_json"),
-      elementIds: parseJson(row.element_ids_json, "usage_receipts.element_ids_json"),
-      createdAt: row.created_at
-    }));
+    `).all(key).map((row) => {
+      const audit2 = parseJson(row.audit_json, "usage_receipts.audit_json");
+      return {
+        id: row.receipt_id,
+        eventIds: parseJson(row.event_ids_json, "usage_receipts.event_ids_json"),
+        elementIds: parseJson(row.element_ids_json, "usage_receipts.element_ids_json"),
+        ...Object.keys(audit2).length === 0 ? {} : { audit: audit2 },
+        createdAt: row.created_at
+      };
+    });
     const ingestionReceipts = this.database.prepare(`
       SELECT receipt_id, created_at
       FROM ingestion_receipts WHERE namespace = ? ORDER BY created_at, receipt_id
@@ -1462,8 +1473,8 @@ var SqliteStorage = class {
       );
     }
     const insertReceipt = this.database.prepare(`
-      INSERT INTO usage_receipts (namespace, receipt_id, event_ids_json, element_ids_json, created_at)
-      VALUES (?, ?, ?, ?, ?)
+      INSERT INTO usage_receipts (namespace, receipt_id, event_ids_json, element_ids_json, audit_json, created_at)
+      VALUES (?, ?, ?, ?, ?, ?)
       ON CONFLICT (namespace, receipt_id) DO NOTHING
     `);
     for (const receipt of snapshot.usageReceipts) {
@@ -1472,6 +1483,7 @@ var SqliteStorage = class {
         receipt.id,
         JSON.stringify(receipt.eventIds),
         JSON.stringify(receipt.elementIds),
+        JSON.stringify(receipt.audit ?? {}),
         receipt.createdAt
       );
     }
@@ -1495,14 +1507,18 @@ var SqliteStorage = class {
         this.database.exec(SCHEMA);
         this.database.exec(`PRAGMA user_version = ${STRATAGATE_STORAGE_SCHEMA_VERSION}`);
       });
-    } else if (version === 1 || version === 2) {
+    } else if (version === 1 || version === 2 || version === 3) {
       this.immediateTransaction(() => {
         if (version === 1) {
-          const receiptColumns = this.database.prepare("PRAGMA table_info('usage_receipts')").all();
-          if (!receiptColumns.some(({ name: name2 }) => name2 === "element_ids_json")) {
+          const receiptColumns2 = this.database.prepare("PRAGMA table_info('usage_receipts')").all();
+          if (!receiptColumns2.some(({ name: name2 }) => name2 === "element_ids_json")) {
             this.database.exec("ALTER TABLE usage_receipts ADD COLUMN element_ids_json TEXT NOT NULL DEFAULT '[]'");
           }
         }
+        const receiptColumns = this.database.prepare("PRAGMA table_info('usage_receipts')").all();
+        if (!receiptColumns.some(({ name: name2 }) => name2 === "audit_json")) {
+          this.database.exec("ALTER TABLE usage_receipts ADD COLUMN audit_json TEXT NOT NULL DEFAULT '{}'");
+        }
         this.database.exec(SCHEMA);
         this.database.prepare("UPDATE memory_spaces SET schema_version = ? WHERE schema_version < ?").run(STRATAGATE_STORAGE_SCHEMA_VERSION, STRATAGATE_STORAGE_SCHEMA_VERSION);
         this.database.exec(`PRAGMA user_version = ${STRATAGATE_STORAGE_SCHEMA_VERSION}`);
@@ -1537,6 +1553,10 @@ var SqliteStorage = class {
   assertOpen() {
     if (this.closed) throw new Error("SQLite storage is closed");
   }
+  listNamespaces() {
+    this.assertOpen();
+    return this.database.prepare("SELECT namespace FROM memory_spaces ORDER BY namespace").all().map(({ namespace }) => namespace);
+  }
 };
 
 // ../../src/store.ts
@@ -1716,6 +1736,9 @@ var StrataGate = class _StrataGate {
   listElementProjectionJobs() {
     return [...this.elementProjectionJobs.values()];
   }
+  listUsageReceipts() {
+    return [...this.usageReceipts.values()];
+  }
   exportSnapshot() {
     return cloneSnapshot({
       schemaVersion: STRATAGATE_STORAGE_SCHEMA_VERSION,
@@ -2036,11 +2059,12 @@ var StrataGate = class _StrataGate {
     const normalizedRefs = Array.isArray(refs) ? { eventIds: refs } : refs;
     const requestedEventIds = [...new Set(normalizedRefs.eventIds ?? [])];
     const requestedElementIds = [...new Set(normalizedRefs.elementIds ?? [])];
+    const audit2 = options.audit === void 0 ? void 0 : structuredClone(options.audit);
     if (receiptId) {
       const existing = this.usageReceipts.get(receiptId);
       if (existing) {
-        if (!sameIds(existing.eventIds, requestedEventIds) || !sameIds(existing.elementIds, requestedElementIds)) {
-          throw new Error(`Usage receipt ${receiptId} was already recorded with different memory IDs`);
+        if (!sameIds(existing.eventIds, requestedEventIds) || !sameIds(existing.elementIds, requestedElementIds) || JSON.stringify(existing.audit ?? null) !== JSON.stringify(audit2 ?? null)) {
+          throw new Error(`Usage receipt ${receiptId} was already recorded with different memory IDs or audit metadata`);
         }
         return;
       }
@@ -2065,6 +2089,7 @@ var StrataGate = class _StrataGate {
         id: receiptId,
         eventIds: requestedEventIds,
         elementIds: requestedElementIds,
+        ...audit2 === void 0 ? {} : { audit: audit2 },
         createdAt: now
       });
     });
@@ -2624,7 +2649,12 @@ var StrataGateRuntime = class {
         for (const id of target?.eventIds ?? []) eventIds.add(id);
         for (const id of target?.elementIds ?? []) elementIds.add(id);
       }
-      this.adopted.set(key, { eventIds: [...eventIds], elementIds: [...elementIds] });
+      this.adopted.set(key, {
+        eventIds: [...eventIds],
+        elementIds: [...elementIds],
+        batchId: batch.id,
+        assessment
+      });
     } else {
       this.adopted.delete(key);
     }
@@ -2634,7 +2664,20 @@ var StrataGateRuntime = class {
     const key = String(session.id);
     const refs = this.adopted.get(key);
     if (!refs) throw new Error("No sufficient StrataGate evidence has been assessed for this session");
-    await (await this.space(session)).recordMemoryUse(refs, { receiptId: `dsh:${key}:tool:${receiptId}` });
+    const turn = activeTurn(session);
+    await (await this.space(session)).recordMemoryUse(refs, {
+      receiptId: `dsh:${key}:tool:${receiptId}`,
+      audit: {
+        sessionId: key,
+        ...turn === void 0 ? {} : { turn },
+        batchId: refs.batchId,
+        evidenceRefs: refs.assessment.evidenceRefs,
+        verdict: refs.assessment.verdict,
+        fit: refs.assessment.fit,
+        missing: refs.assessment.missing,
+        nextStrategy: refs.assessment.nextStrategy
+      }
+    });
     this.adopted.delete(key);
     return { recorded: true, eventIds: refs.eventIds, elementIds: refs.elementIds };
   }
@@ -2665,6 +2708,28 @@ var StrataGateRuntime = class {
     if (this.config.namespaceMode === "session") return `${prefix}:session:${String(session.id)}`;
     return `${prefix}:project:${projectKey(session.header.cwd)}`;
   }
+  async adminNamespaces() {
+    await this.flush();
+    if (this.config.database === ":memory:" || !existsSync(this.config.database)) return [];
+    const storage = new SqliteStorage({ filename: this.config.database, readonly: true });
+    try {
+      return storage.listNamespaces();
+    } finally {
+      await storage.close();
+    }
+  }
+  async adminSnapshot(namespace) {
+    await this.flush();
+    const key = namespace.trim();
+    if (!key) throw new TypeError("StrataGate admin namespace must not be empty");
+    if (this.config.database === ":memory:" || !existsSync(this.config.database)) return null;
+    const storage = new SqliteStorage({ filename: this.config.database, readonly: true });
+    try {
+      return (await storage.load(key))?.snapshot ?? null;
+    } finally {
+      await storage.close();
+    }
+  }
   space(session) {
     const namespace = this.namespaceFor(session);
     let opening = this.spaces.get(namespace);
@@ -2692,6 +2757,13 @@ var StrataGateRuntime = class {
     return { batchId: id, evidenceRefs: [...refs.keys()], results };
   }
 };
+function activeTurn(session) {
+  for (let index = session.events.length - 1; index >= 0; index -= 1) {
+    const event = session.events[index];
+    if (event?.type === "turn/start") return event.data.turn;
+  }
+  return void 0;
+}
 
 // src/tools.ts
 import { defineTool } from "@deepseek-ai/dsh-tools";
@@ -2813,6 +2885,246 @@ function registerMemoryTools(ctx, runtime) {
   }));
 }
 
+// src/web.ts
+function sendJson(res, status, body) {
+  res.statusCode = status;
+  res.setHeader("Content-Type", "application/json; charset=utf-8");
+  res.setHeader("Cache-Control", "no-store");
+  res.end(JSON.stringify(redactValue(body)));
+}
+function numeric(value, fallback, minimum, maximum) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? Math.min(maximum, Math.max(minimum, Math.floor(parsed))) : fallback;
+}
+function redact(text2) {
+  return text2.replace(/\b(?:sk|gh[opasu]|github_pat)_[A-Za-z0-9_-]{12,}\b/g, "[REDACTED_TOKEN]").replace(/\b(Bearer\s+)[A-Za-z0-9._~+/-]{12,}={0,2}\b/gi, "$1[REDACTED]").replace(/\b(api[_-]?key|token|password|secret)\s*[:=]\s*([^\s,;]+)/gi, "$1=[REDACTED]");
+}
+function redactValue(value) {
+  if (typeof value === "string") return redact(value);
+  if (Array.isArray(value)) return value.map(redactValue);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactValue(item)]));
+  }
+  return value;
+}
+function redactedMessage(message, blockId) {
+  const { toolCalls, ...base } = message;
+  const common = { ...base, content: redact(message.content), blockId };
+  return toolCalls ? { ...common, toolCalls: redactValue(toolCalls) } : common;
+}
+function sourceMessages(snapshot, ids) {
+  const output = [];
+  for (const block of snapshot.blocks) {
+    for (const message of block.l5Raw) {
+      if (!ids || ids.has(message.id)) {
+        output.push(redactedMessage(message, block.id));
+      }
+    }
+  }
+  for (const message of snapshot.openTail) {
+    if (!ids || ids.has(message.id)) {
+      output.push(redactedMessage(message, null));
+    }
+  }
+  return output;
+}
+function eventSummary(event) {
+  return {
+    id: event.id,
+    title: event.title,
+    summary: event.summary,
+    tags: event.tags,
+    sourceBlockId: event.sourceBlockId,
+    sourceMessageIds: event.sourceMessageIds,
+    temporal: event.temporal,
+    scope: event.scope,
+    criticality: event.criticality,
+    confidence: event.confidence,
+    status: event.status,
+    supersededBy: event.supersededBy,
+    weight: event.weight,
+    createdAt: event.createdAt,
+    updatedAt: event.updatedAt
+  };
+}
+function elementSummary(element) {
+  return {
+    id: element.id,
+    name: element.name,
+    type: element.type,
+    aliases: element.aliases,
+    currentState: element.currentState,
+    facts: element.facts,
+    sourceEventIds: element.sourceEventIds,
+    sourceMessageIds: element.sourceMessageIds,
+    weight: element.weight,
+    createdAt: element.createdAt,
+    updatedAt: element.updatedAt
+  };
+}
+function matchesQuery(value, query) {
+  if (!query) return true;
+  return JSON.stringify(value).toLocaleLowerCase().includes(query.toLocaleLowerCase());
+}
+async function requiredSnapshot(runtime, namespace) {
+  const snapshot = await runtime.adminSnapshot(namespace);
+  if (!snapshot) throw new AdminHttpError(404, `Unknown StrataGate namespace: ${namespace}`);
+  return snapshot;
+}
+var AdminHttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+async function overview(runtime) {
+  const namespaces = await runtime.adminNamespaces();
+  const rows = [];
+  for (const namespace of namespaces) {
+    const snapshot = await runtime.adminSnapshot(namespace);
+    if (!snapshot) continue;
+    const failedJobs = snapshot.extractionJobs.filter(({ status }) => status === "failed").length + snapshot.elementProjectionJobs.filter(({ status }) => status === "failed").length;
+    const timestamps = [
+      ...snapshot.blocks.map(({ createdAt }) => createdAt),
+      ...snapshot.events.map(({ updatedAt }) => updatedAt),
+      ...snapshot.elements.map(({ updatedAt }) => updatedAt),
+      ...snapshot.usageReceipts.map(({ createdAt }) => createdAt)
+    ].sort();
+    rows.push({
+      namespace,
+      schemaVersion: snapshot.schemaVersion,
+      currentTurn: snapshot.currentTurn,
+      blockTurnSize: snapshot.blockTurnSize,
+      blocks: snapshot.blocks.length,
+      openTailMessages: snapshot.openTail.length,
+      events: snapshot.events.length,
+      activeEvents: snapshot.events.filter(({ status }) => status === "active").length,
+      elements: snapshot.elements.length,
+      usageReceipts: snapshot.usageReceipts.length,
+      failedJobs,
+      lastActivityAt: timestamps.at(-1) ?? null
+    });
+  }
+  return { readonly: true, namespaces: rows };
+}
+async function memories(runtime, url) {
+  const namespace = url.searchParams.get("namespace")?.trim() ?? "";
+  if (!namespace) throw new AdminHttpError(400, "namespace is required");
+  const snapshot = await requiredSnapshot(runtime, namespace);
+  const kind = url.searchParams.get("kind") ?? "events";
+  const query = url.searchParams.get("q")?.trim() ?? "";
+  const offset = numeric(url.searchParams.get("offset"), 0, 0, Number.MAX_SAFE_INTEGER);
+  const limit = numeric(url.searchParams.get("limit"), 100, 1, 200);
+  let values;
+  if (kind === "events") values = snapshot.events.map(eventSummary);
+  else if (kind === "elements") values = snapshot.elements.map(elementSummary);
+  else if (kind === "blocks") values = snapshot.blocks.map((block) => ({
+    id: block.id,
+    sequence: block.sequence,
+    turnRange: [block.startTurn, block.endTurn],
+    title: block.l0Title,
+    tags: block.l0Tags,
+    summary: block.l1Summary,
+    keypoints: block.l2Keypoints,
+    currentLevel: block.pointerCurrentLevel,
+    sourceMessages: block.l5Raw.length,
+    createdAt: block.createdAt
+  }));
+  else throw new AdminHttpError(400, `Unsupported memory kind: ${kind}`);
+  const filtered = values.filter((value) => matchesQuery(value, query));
+  return { namespace, kind, total: filtered.length, offset, limit, items: filtered.slice(offset, offset + limit) };
+}
+async function sources(runtime, url) {
+  const namespace = url.searchParams.get("namespace")?.trim() ?? "";
+  if (!namespace) throw new AdminHttpError(400, "namespace is required");
+  const snapshot = await requiredSnapshot(runtime, namespace);
+  const eventId = url.searchParams.get("eventId");
+  const elementId = url.searchParams.get("elementId");
+  const blockId = url.searchParams.get("blockId");
+  let events = [];
+  let elements = [];
+  let ids = /* @__PURE__ */ new Set();
+  if (eventId) {
+    const event = snapshot.events.find(({ id }) => id === eventId);
+    if (!event) throw new AdminHttpError(404, `Unknown event: ${eventId}`);
+    events = [event];
+    ids = new Set(event.sourceMessageIds);
+  } else if (elementId) {
+    const element = snapshot.elements.find(({ id }) => id === elementId);
+    if (!element) throw new AdminHttpError(404, `Unknown element: ${elementId}`);
+    elements = [element];
+    events = snapshot.events.filter(({ id }) => element.sourceEventIds.includes(id));
+    ids = new Set(events.flatMap(({ sourceMessageIds }) => sourceMessageIds));
+  } else if (blockId) {
+    const block = snapshot.blocks.find(({ id }) => id === blockId);
+    if (!block) throw new AdminHttpError(404, `Unknown block: ${blockId}`);
+    ids = new Set(block.l5Raw.map(({ id }) => id));
+    events = snapshot.events.filter(({ sourceBlockId }) => sourceBlockId === blockId);
+  } else {
+    throw new AdminHttpError(400, "eventId, elementId, or blockId is required");
+  }
+  return {
+    namespace,
+    events: events.map(eventSummary),
+    elements: elements.map(elementSummary),
+    messages: sourceMessages(snapshot, ids)
+  };
+}
+function receiptSources(snapshot, receipt) {
+  const events = snapshot.events.filter(({ id }) => receipt.eventIds.includes(id));
+  const elements = snapshot.elements.filter(({ id }) => receipt.elementIds.includes(id));
+  const eventIds = /* @__PURE__ */ new Set([...receipt.eventIds, ...elements.flatMap(({ sourceEventIds }) => sourceEventIds)]);
+  const supportingEvents = snapshot.events.filter(({ id }) => eventIds.has(id));
+  const messageIds = new Set(supportingEvents.flatMap(({ sourceMessageIds }) => sourceMessageIds));
+  return {
+    ...receipt,
+    events: events.map(eventSummary),
+    elements: elements.map(elementSummary),
+    sourceMessages: sourceMessages(snapshot, messageIds)
+  };
+}
+async function audit(runtime, url) {
+  const namespace = url.searchParams.get("namespace")?.trim() ?? "";
+  if (!namespace) throw new AdminHttpError(400, "namespace is required");
+  const snapshot = await requiredSnapshot(runtime, namespace);
+  const offset = numeric(url.searchParams.get("offset"), 0, 0, Number.MAX_SAFE_INTEGER);
+  const limit = numeric(url.searchParams.get("limit"), 50, 1, 100);
+  const receipts = [...snapshot.usageReceipts].reverse();
+  return {
+    namespace,
+    total: receipts.length,
+    offset,
+    limit,
+    items: receipts.slice(offset, offset + limit).map((receipt) => receiptSources(snapshot, receipt))
+  };
+}
+async function handleAdminRequest(runtime, req, res) {
+  try {
+    if (req.method !== "GET") throw new AdminHttpError(405, "StrataGate Memory UI is read-only");
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const path = url.pathname.replace(/\/$/, "");
+    if (path === "/api/stratagate/overview") sendJson(res, 200, await overview(runtime));
+    else if (path === "/api/stratagate/memories") sendJson(res, 200, await memories(runtime, url));
+    else if (path === "/api/stratagate/sources") sendJson(res, 200, await sources(runtime, url));
+    else if (path === "/api/stratagate/audit") sendJson(res, 200, await audit(runtime, url));
+    else throw new AdminHttpError(404, "Unknown StrataGate admin route");
+  } catch (error) {
+    const status = error instanceof AdminHttpError ? error.status : 500;
+    const message = error instanceof Error ? error.message : String(error);
+    sendJson(res, status, { error: message });
+  }
+}
+function registerAdminRoutes(ctx, runtime) {
+  const webServer = ctx.get("webServer");
+  if (!webServer) return void 0;
+  return webServer.register({
+    kind: "prefix",
+    path: "/api/stratagate",
+    handler: (req, res) => handleAdminRequest(runtime, req, res)
+  });
+}
+
 // src/index.ts
 var name = "stratagate-memory";
 var inject = ["tools", "systemPrompt", "llm", "agentDefaultModel"];
@@ -2836,9 +3148,13 @@ async function apply(ctx, config) {
   });
   ctx.systemPrompt.section({ name: "tool:stratagate-memory", order: 113, text: MEMORY_PROTOCOL });
   registerMemoryTools(ctx, runtime);
+  const disposeAdminRoutes = registerAdminRoutes(ctx, runtime);
   ctx.on("session/event", (session, event) => runtime.acceptEvent(session, event));
   ctx.logger.info(`stratagate-memory ready (${resolved.namespaceMode} namespaces, ${resolved.database})`);
-  return async () => runtime.close();
+  return async () => {
+    disposeAdminRoutes?.();
+    await runtime.close();
+  };
 }
 export {
   Config,