signetai 0.200.25 → 0.200.26

package/dist/mcp-stdio.js

@@ -6725,7 +6725,7 @@ var require_base64_js = __commonJS((exports) => {
 });
 
 // ../../platform/daemon/src/mcp-stdio.ts
-import { existsSync as existsSync10, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync12, statSync as statSync3 } from "node:fs";
 import { isAbsolute } from "node:path";
 
 // ../../node_modules/.bun/@modelcontextprotocol+sdk@1.30.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
@@ -44336,6 +44336,154 @@ function pendingDreamingEvidenceContinuations(db, agentId, limit, kind) {
   });
 }
 
+// ../../platform/daemon/src/pipeline/dreaming-token-cache.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { join as join6 } from "node:path";
+import { dirname as dirname6 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { Worker } from "node:worker_threads";
+
+// ../../platform/daemon/src/native-runtime-assets.ts
+import { createHash as createHash2 } from "node:crypto";
+import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync4, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname as dirname3, join as join5 } from "node:path";
+function nativeRuntimeAssets() {
+  return globalThis.__SIGNET_NATIVE_RUNTIME_ASSETS__ ?? {};
+}
+function resolveEmbeddedWorkerPath(name) {
+  const worker = (nativeRuntimeAssets().workers ?? []).find((asset) => asset.name === name);
+  if (!worker)
+    return null;
+  const hash2 = createHash2("sha256").update(worker.contentBase64).digest("hex").slice(0, 16);
+  const dir = join5(tmpdir(), "signet-native-workers");
+  const path = join5(dir, `${name.replace(/[^a-zA-Z0-9_.-]/g, "_")}-${hash2}.mjs`);
+  mkdirSync4(dir, { recursive: true });
+  if (!existsSync3(path)) {
+    writeFileSync(path, Buffer.from(worker.contentBase64, "base64"));
+  }
+  return path;
+}
+
+// ../../platform/daemon/src/pipeline/dreaming-token-cache.ts
+function resolveWorkerPath() {
+  const moduleDir = dirname6(fileURLToPath2(import.meta.url));
+  const bundled = join6(moduleDir, "dreaming-token-worker.js");
+  return existsSync4(bundled) ? bundled : resolveEmbeddedWorkerPath("dreaming-token-worker") ?? join6(moduleDir, "dreaming-token-worker.ts");
+}
+
+class DreamingBacklogTokenCache {
+  values = new Map;
+  entries = new Map;
+  entryValues = new Map;
+  pending = new Map;
+  inflight = new Map;
+  worker = null;
+  nextRequestId = 1;
+  async refresh(agentId, entries) {
+    const active = this.inflight.get(agentId);
+    if (active !== undefined)
+      return active;
+    const promise3 = this.refreshNow(agentId, entries);
+    this.inflight.set(agentId, promise3);
+    try {
+      return await promise3;
+    } finally {
+      this.inflight.delete(agentId);
+    }
+  }
+  get(agentId) {
+    return this.values.get(agentId) ?? 0;
+  }
+  hasValue(agentId) {
+    return this.values.has(agentId);
+  }
+  stop() {
+    const worker = this.worker;
+    this.worker = null;
+    if (worker !== null)
+      worker.terminate();
+    for (const pending of this.pending.values())
+      pending.reject(new Error("Dreaming token worker stopped"));
+    this.pending.clear();
+    this.inflight.clear();
+  }
+  async refreshNow(agentId, entries) {
+    const nextKeys = new Set(entries.map((entry) => entry.key));
+    const agentEntries = this.entries.get(agentId) ?? new Map;
+    const agentValues = this.entryValues.get(agentId) ?? new Map;
+    this.entries.set(agentId, agentEntries);
+    this.entryValues.set(agentId, agentValues);
+    for (const key of agentEntries.keys()) {
+      if (!nextKeys.has(key))
+        agentEntries.delete(key);
+    }
+    const uncached = entries.filter((entry) => {
+      const cached2 = agentEntries.get(entry.key);
+      return cached2 === undefined || cached2.text !== entry.text;
+    });
+    if (uncached.length > 0) {
+      const counts = await this.count(uncached);
+      for (const entry of uncached) {
+        const result = counts.find((item) => item.key === entry.key);
+        if (result === undefined)
+          throw new Error(`Dreaming token worker omitted ${entry.key}`);
+        agentEntries.set(entry.key, entry);
+        agentValues.set(entry.key, result.count);
+      }
+    }
+    let total = 0;
+    for (const entry of entries) {
+      const count = agentValues.get(entry.key);
+      if (count === undefined)
+        throw new Error(`Missing cached Dreaming token count for ${entry.key}`);
+      total += count;
+    }
+    for (const key of agentValues.keys()) {
+      if (!nextKeys.has(key))
+        agentValues.delete(key);
+    }
+    this.values.set(agentId, total);
+    return total;
+  }
+  count(entries) {
+    const worker = this.ensureWorker();
+    const requestId = this.nextRequestId++;
+    return new Promise((resolve, reject) => {
+      this.pending.set(requestId, { resolve, reject });
+      worker.postMessage({ type: "count", requestId, entries });
+    });
+  }
+  ensureWorker() {
+    if (this.worker !== null)
+      return this.worker;
+    const worker = new Worker(resolveWorkerPath());
+    worker.unref?.();
+    worker.on("message", (message) => {
+      const pending = this.pending.get(message.requestId);
+      if (pending === undefined)
+        return;
+      this.pending.delete(message.requestId);
+      pending.resolve(message.counts);
+    });
+    const fail = (error51) => {
+      for (const pending of this.pending.values())
+        pending.reject(error51);
+      this.pending.clear();
+      this.worker = null;
+    };
+    worker.on("error", fail);
+    worker.on("exit", (code) => {
+      if (code !== 0)
+        fail(new Error(`Dreaming token worker exited with code ${code}`));
+      if (this.worker === worker)
+        this.worker = null;
+    });
+    this.worker = worker;
+    return worker;
+  }
+}
+
 // ../../node_modules/.bun/js-tiktoken@1.0.21/node_modules/js-tiktoken/dist/chunk-VL2OQCWN.js
 var import_base64_js = __toESM(require_base64_js(), 1);
 var __defProp3 = Object.defineProperty;
@@ -44489,6 +44637,7 @@ function truncateToTokens(text, limit) {
 var EVIDENCE_WATERMARK_FLOOR_MS = Date.parse(EPISODIC_CAPTURED_AT_FLOOR);
 var FAILURE_BACKOFF_BASE_MS = 5 * 60 * 1000;
 var DREAMING_HALT_COOLDOWN_MS = 24 * 60 * 60 * 1000;
+var dreamingBacklogTokenCache = new DreamingBacklogTokenCache;
 
 // ../../platform/daemon/src/knowledge-graph.ts
 function toCanonicalName(raw) {
@@ -49313,9 +49462,9 @@ function getDreamingCapabilityManifest() {
 
 // ../../platform/daemon/src/graphiq.ts
 import { spawn } from "node:child_process";
-import { constants, accessSync, existsSync as existsSync3 } from "node:fs";
+import { constants, accessSync, existsSync as existsSync6 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { delimiter, join as join5 } from "node:path";
+import { delimiter, join as join8 } from "node:path";
 function getAgentsDir() {
   return resolveDefaultBasePath();
 }
@@ -49330,8 +49479,8 @@ function getActiveGraphiqDbPath() {
 }
 function resolveGraphiqBinary() {
   const path = process.env.PATH ?? "";
-  const candidates2 = path.split(delimiter).filter((entry) => entry.length > 0).map((entry) => join5(entry, "graphiq"));
-  candidates2.push(join5(homedir3(), ".local", "bin", "graphiq"));
+  const candidates2 = path.split(delimiter).filter((entry) => entry.length > 0).map((entry) => join8(entry, "graphiq"));
+  candidates2.push(join8(homedir3(), ".local", "bin", "graphiq"));
   for (const candidate of candidates2) {
     try {
       accessSync(candidate, constants.X_OK);
@@ -49345,7 +49494,7 @@ async function runGraphiqCli(args, timeoutMs = 15000) {
   if (!active) {
     throw new Error("GraphIQ has no active indexed project. Run `signet index <path>` first.");
   }
-  if (!existsSync3(active.dbPath)) {
+  if (!existsSync6(active.dbPath)) {
     throw new Error(`GraphIQ database not found for active project: ${active.dbPath}`);
   }
   const binary = resolveGraphiqBinary();
@@ -49415,32 +49564,32 @@ function runCommand(command, args, timeoutMs, extraEnv) {
 }
 
 // ../../platform/daemon/src/plugins/index.ts
-import { existsSync as existsSync9, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync8 } from "node:fs";
 
 // ../../platform/daemon/src/secrets.ts
 import {
-  chmodSync,
+  chmodSync as chmodSync2,
   closeSync,
-  existsSync as existsSync6,
+  existsSync as existsSync9,
   fsyncSync,
-  mkdirSync as mkdirSync6,
+  mkdirSync as mkdirSync7,
   openSync,
   readFileSync as readFileSync5,
   readdirSync as readdirSync3,
   renameSync as renameSync3,
   unlinkSync as unlinkSync3,
-  writeFileSync
+  writeFileSync as writeFileSync3
 } from "node:fs";
-import { join as join8 } from "node:path";
+import { join as join11 } from "node:path";
 
 // ../../platform/daemon/src/plugins/audit.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync3 } from "node:fs";
-import { dirname as dirname3, join as join6 } from "node:path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync3 } from "node:fs";
+import { dirname as dirname8, join as join10 } from "node:path";
 var SENSITIVE_KEY_RE = /(^|[_-])(api-key|apikey|auth-token|authorization|bearer|client-secret|credential|credentials|password|private-key|refresh-token|secret|secret-value|token|value)([_-]|$)/i;
 var SENSITIVE_ASSIGNMENT_RE = /\b((?:access[_-]?token|api[_-]?key|auth(?:orization)?|bearer|client[_-]?secret|credential|password|refresh[_-]?token|secret|token)\s*[:=]\s*)(["']?)([^"'\s,;&]+)/gi;
 var KNOWN_SECRET_VALUE_RE = /\b(AKIA[0-9A-Z]{16}|github_pat_[A-Za-z0-9_]{20,}|gh[pousr]_[A-Za-z0-9_]{20,}|sk-[A-Za-z0-9_-]{12,}|xox[baprs]-[A-Za-z0-9-]{10,})\b/g;
 function getDefaultPluginAuditPath() {
-  return join6(resolveDefaultBasePath(), ".daemon", "plugins", "audit-v1.ndjson");
+  return join10(resolveDefaultBasePath(), ".daemon", "plugins", "audit-v1.ndjson");
 }
 function recordPluginAuditEvent(input, auditPath) {
   if (auditPath === null)
@@ -49457,7 +49606,7 @@ function recordPluginAuditEvent(input, auditPath) {
     data: sanitizeAuditData(input.data ?? {})
   };
   try {
-    mkdirSync4(dirname3(path), { recursive: true });
+    mkdirSync6(dirname8(path), { recursive: true });
     appendFileSync2(path, `${JSON.stringify(event)}
 `, { mode: 384 });
   } catch (err) {
@@ -49803,10 +49952,10 @@ function getAgentsDir2() {
   return resolveDefaultBasePath();
 }
 function getSecretsDir() {
-  return join8(getAgentsDir2(), ".secrets");
+  return join11(getAgentsDir2(), ".secrets");
 }
 function getSecretsFile() {
-  return join8(getSecretsDir(), "secrets.enc");
+  return join11(getSecretsDir(), "secrets.enc");
 }
 var DEFAULT_SECRET_EXEC_TIMEOUT_MS = 5 * 60000;
 var MAX_SECRET_EXEC_TIMEOUT_MS = 30 * 60000;
@@ -49841,14 +49990,14 @@ function cleanupStaleSecretStoreTemps() {
     if (!name.startsWith(SECRET_STORE_TEMP_PREFIX) || isSecretStoreTempProcessLive(name))
       continue;
     try {
-      unlinkSync3(join8(dir, name));
+      unlinkSync3(join11(dir, name));
     } catch {}
   }
 }
 function loadStore() {
   cleanupStaleSecretStoreTemps();
   const file2 = getSecretsFile();
-  if (!existsSync6(file2)) {
+  if (!existsSync9(file2)) {
     return { version: 1, secrets: {} };
   }
   try {
@@ -50113,8 +50262,8 @@ var signetGraphiqManifest = {
 };
 
 // ../../platform/daemon/src/plugins/host.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname6, join as join10 } from "node:path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname9, join as join12 } from "node:path";
 
 // ../../platform/daemon/src/plugins/manifest.ts
 var PLUGIN_ID_RE = /^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)+$/;
@@ -50462,7 +50611,7 @@ class PluginHostV1 {
     };
   }
   loadStore() {
-    if (!this.storagePath || !existsSync8(this.storagePath)) {
+    if (!this.storagePath || !existsSync10(this.storagePath)) {
       return { version: 1, plugins: {} };
     }
     try {
@@ -50490,13 +50639,13 @@ class PluginHostV1 {
       });
       return;
     }
-    mkdirSync7(dirname6(this.storagePath), { recursive: true });
-    writeFileSync3(this.storagePath, `${JSON.stringify(this.store, null, 2)}
+    mkdirSync8(dirname9(this.storagePath), { recursive: true });
+    writeFileSync5(this.storagePath, `${JSON.stringify(this.store, null, 2)}
 `, { mode: 384 });
   }
 }
 function getDefaultPluginRegistryPath() {
-  return join10(resolveDefaultBasePath(), SIGNET_PLUGIN_REGISTRY_DIR, SIGNET_PLUGIN_REGISTRY_FILE);
+  return join12(resolveDefaultBasePath(), SIGNET_PLUGIN_REGISTRY_DIR, SIGNET_PLUGIN_REGISTRY_FILE);
 }
 function resolveState(manifest, enabled, health, validationErrors) {
   if (validationErrors.length > 0) {
@@ -50619,7 +50768,7 @@ function auditResultForRecord(record5) {
 // ../../platform/daemon/src/plugins/index.ts
 function resolveGraphiqEnabled() {
   const statePath = getGraphiqStatePath(getAgentsDir());
-  if (existsSync9(statePath)) {
+  if (existsSync11(statePath)) {
     try {
       const parsed = JSON.parse(readFileSync8(statePath, "utf-8"));
       if (typeof parsed === "object" && parsed !== null && typeof parsed.enabled === "boolean") {
@@ -52714,7 +52863,7 @@ function isLocalDaemonUrl(url2) {
 }
 function isValidAgentsDir(dir) {
   try {
-    return isAbsolute(dir) && existsSync10(dir) && statSync3(dir).isDirectory();
+    return isAbsolute(dir) && existsSync12(dir) && statSync3(dir).isDirectory();
   } catch {
     return false;
   }

package/native-manifest.json

@@ -1,43 +1,43 @@
 {
   "schemaVersion": 1,
-  "version": "0.200.25",
+  "version": "0.200.26",
   "assets": [
     {
       "name": "signet-darwin-arm64",
       "platform": "darwin-arm64",
-      "sha256": "bccc471166d060d39f7786d036c33a6cb7d9ce24b47735c564bd1daa10764b8f",
-      "size": 125350432
+      "sha256": "fb67e16bdeecc02d8e3fb6d2ada09c174e78800f94654440c64d933a44791a99",
+      "size": 126820000
     },
     {
       "name": "signet-darwin-x64",
       "platform": "darwin-x64",
-      "sha256": "c4d8bd1db8015210fdfff78accf0cb5a0bec7881551e421cadc1d595761f939a",
-      "size": 130320960
+      "sha256": "1686a8f5a408a2e801786c2deaf8c6997d5b2e6249d5f162e495eeadb41a7427",
+      "size": 131795520
     },
     {
       "name": "signet-linux-arm64",
       "platform": "linux-arm64",
-      "sha256": "0ecb4c8291e80900f0f90ca2b7d4245a9bf7fd3caf6c49d6d76858800582e104",
-      "size": 169883492
+      "sha256": "148c0534ee0b3576518a382001ce0b1ed80812a8a99763737612c5840b2ac046",
+      "size": 171357544
     },
     {
       "name": "signet-linux-x64",
       "platform": "linux-x64",
-      "sha256": "ce7a3976d9a1f9c9735aa28141e7c2bd5126c2fddda867c856912cb403d8c780",
-      "size": 172258074
+      "sha256": "552ec0a18e0d897241690fd9a378e769dd3484f5f8bc60f0e0f3b152ab8829c8",
+      "size": 173732126
     },
     {
       "name": "signet-win32-x64.exe",
       "platform": "win32-x64",
-      "sha256": "445a4dbfd02b5ea2de1456da79792e2d69f8d86933a73db497f78dfdcd346c51",
-      "size": 180382720
+      "sha256": "0fa666d379aedb776ce1ee5fd743a987325b0bbb948742cb680aedc8a95364de",
+      "size": 181856768
     }
   ],
   "components": {
     "connectors": {
-      "url": "signet-connectors-0.200.25.tar.gz",
-      "sha256": "daadb726f1c8923459ec8ad64709c1224be8d0a4fea4a195b584a821af98ace5",
-      "size": 21942
+      "url": "signet-connectors-0.200.26.tar.gz",
+      "sha256": "0fed5e65d53b0edaab4c9adae5b749bd6ebe9035386df550b87560f4a06f71d5",
+      "size": 21946
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signetai",
-  "version": "0.200.25",
+  "version": "0.200.26",
   "description": "Signet native CLI installer wrapper",
   "type": "module",
   "bin": {
@@ -65,10 +65,10 @@
     "access": "public"
   },
   "optionalDependencies": {
-    "signetai-darwin-arm64": "https://github.com/Signet-AI/signetai/releases/download/v0.200.25/signetai-darwin-arm64-0.200.25.tgz",
-    "signetai-darwin-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.200.25/signetai-darwin-x64-0.200.25.tgz",
-    "signetai-linux-arm64": "https://github.com/Signet-AI/signetai/releases/download/v0.200.25/signetai-linux-arm64-0.200.25.tgz",
-    "signetai-linux-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.200.25/signetai-linux-x64-0.200.25.tgz",
-    "signetai-win32-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.200.25/signetai-win32-x64-0.200.25.tgz"
+    "signetai-darwin-arm64": "https://github.com/Signet-AI/signetai/releases/download/v0.200.26/signetai-darwin-arm64-0.200.26.tgz",
+    "signetai-darwin-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.200.26/signetai-darwin-x64-0.200.26.tgz",
+    "signetai-linux-arm64": "https://github.com/Signet-AI/signetai/releases/download/v0.200.26/signetai-linux-arm64-0.200.26.tgz",
+    "signetai-linux-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.200.26/signetai-linux-x64-0.200.26.tgz",
+    "signetai-win32-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.200.26/signetai-win32-x64-0.200.26.tgz"
   }
 }