signetai 0.204.4 → 0.205.0

package/dist/mcp-stdio.js

@@ -49062,6 +49062,303 @@ class DreamingBacklogTokenCache {
   }
 }
 
+// ../../platform/daemon/src/pipeline/dreaming-live-events.ts
+var DREAMING_LIVE_MAX_EVENTS = 256;
+var DREAMING_LIVE_MAX_SUBSCRIBERS = 16;
+var DREAMING_LIVE_MAX_PASSES = 32;
+var DREAMING_LIVE_MAX_EVENT_CHARS = 48000;
+var DREAMING_LIVE_MAX_RAW_CHARS = 16000;
+var DREAMING_LIVE_TERMINAL_RETENTION_MS = 10 * 60000;
+function nowIso() {
+  return new Date().toISOString();
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? { ...value } : {};
+}
+function safeJson(value) {
+  try {
+    const json2 = JSON.stringify(value);
+    return json2 === undefined ? "null" : json2;
+  } catch (error51) {
+    return JSON.stringify({ serializationError: error51 instanceof Error ? error51.message : String(error51) });
+  }
+}
+function truncatedJsonValue(serialized, maxChars) {
+  const base = { truncated: true, originalChars: serialized.length };
+  let preview = serialized.slice(0, Math.max(0, maxChars - safeJson(base).length - 16));
+  let result = { ...base, preview };
+  while (safeJson(result).length > maxChars && preview.length > 0) {
+    preview = preview.slice(0, Math.max(0, preview.length - Math.max(1, Math.ceil(preview.length / 10))));
+    result = { ...base, preview };
+  }
+  return result;
+}
+function boundDreamingLiveValue(value, maxChars = DREAMING_LIVE_MAX_RAW_CHARS) {
+  const json2 = safeJson(value);
+  if (json2.length <= maxChars)
+    return value;
+  return truncatedJsonValue(json2, maxChars);
+}
+function boundString(value, maxChars) {
+  return value.length <= maxChars ? value : `${value.slice(0, maxChars)}…`;
+}
+function boundMetadataString(value, maxChars = 512) {
+  return boundString(value, maxChars);
+}
+function boundNullableMetadataString(value, maxChars) {
+  return value == null ? null : boundString(value, maxChars);
+}
+function boundEventData(value) {
+  const data = {};
+  for (const [key, rawValue] of Object.entries(value)) {
+    if (key === "raw") {
+      data[key] = boundDreamingLiveValue(rawValue, DREAMING_LIVE_MAX_RAW_CHARS);
+    } else if (typeof rawValue === "string") {
+      data[key] = boundString(rawValue, 12000);
+    } else {
+      data[key] = boundDreamingLiveValue(rawValue, 12000);
+    }
+  }
+  const serialized = safeJson(data);
+  if (serialized.length <= DREAMING_LIVE_MAX_EVENT_CHARS)
+    return data;
+  const compact = {};
+  for (const [key, rawValue] of Object.entries(data)) {
+    if (key === "raw") {
+      compact[key] = boundDreamingLiveValue(rawValue, 4000);
+    } else if (typeof rawValue === "string") {
+      compact[key] = boundString(rawValue, 2000);
+    } else {
+      compact[key] = boundDreamingLiveValue(rawValue, 4000);
+    }
+  }
+  const compactSerialized = safeJson(compact);
+  if (compactSerialized.length <= DREAMING_LIVE_MAX_EVENT_CHARS)
+    return compact;
+  return truncatedJsonValue(serialized, DREAMING_LIVE_MAX_EVENT_CHARS);
+}
+function metadataFromInput(input) {
+  return {
+    passId: boundMetadataString(input.passId),
+    agentId: boundMetadataString(input.agentId),
+    mode: boundMetadataString(input.mode),
+    status: "running",
+    startedAt: boundMetadataString(input.startedAt ?? nowIso(), 128),
+    completedAt: null,
+    summary: null,
+    error: null
+  };
+}
+function isTerminal2(status) {
+  return status !== "running";
+}
+function isTerminalEvent(event) {
+  return event.type === "pass_completed" || event.type === "pass_failed";
+}
+
+class DreamingLiveEventHub {
+  passes = new Map;
+  startPass(input) {
+    this.prune();
+    const existing = this.passes.get(input.passId);
+    if (existing) {
+      existing.metadata = {
+        ...existing.metadata,
+        agentId: boundMetadataString(input.agentId),
+        mode: boundMetadataString(input.mode),
+        startedAt: boundMetadataString(input.startedAt ?? existing.metadata.startedAt, 128)
+      };
+      existing.lastTouchedAt = Date.now();
+      return;
+    }
+    if (this.passes.size >= DREAMING_LIVE_MAX_PASSES)
+      return;
+    const pass = {
+      metadata: metadataFromInput(input),
+      nextCursor: 1,
+      events: [],
+      subscribers: new Set,
+      lastTouchedAt: Date.now()
+    };
+    this.passes.set(input.passId, pass);
+    this.append(pass, "pass_started", {
+      agentId: input.agentId,
+      mode: input.mode,
+      startedAt: pass.metadata.startedAt
+    });
+  }
+  ensurePass(input) {
+    const existing = this.passes.get(input.passId);
+    if (!existing) {
+      this.startPass(input);
+      const created = this.passes.get(input.passId);
+      if (created) {
+        created.metadata = {
+          ...created.metadata,
+          status: boundMetadataString(input.status ?? created.metadata.status),
+          completedAt: boundNullableMetadataString(input.completedAt ?? created.metadata.completedAt, 128),
+          summary: boundNullableMetadataString(input.summary ?? created.metadata.summary, 12000),
+          error: boundNullableMetadataString(input.error ?? created.metadata.error, 12000)
+        };
+        this.appendRecoveredTerminal(created);
+      }
+      return;
+    }
+    if (isTerminal2(existing.metadata.status) && (input.status === undefined || input.status === "running")) {
+      existing.lastTouchedAt = Date.now();
+      return;
+    }
+    existing.metadata = {
+      ...existing.metadata,
+      status: boundMetadataString(input.status ?? existing.metadata.status),
+      completedAt: boundNullableMetadataString(input.completedAt ?? existing.metadata.completedAt, 128),
+      summary: boundNullableMetadataString(input.summary ?? existing.metadata.summary, 12000),
+      error: boundNullableMetadataString(input.error ?? existing.metadata.error, 12000)
+    };
+    existing.lastTouchedAt = Date.now();
+    this.appendRecoveredTerminal(existing);
+  }
+  publish(passId, type, data = {}) {
+    const pass = this.passes.get(passId);
+    if (!pass || isTerminal2(pass.metadata.status) && type !== "pass_completed" && type !== "pass_failed")
+      return;
+    this.append(pass, type, data);
+  }
+  finish(passId, status, data = {}) {
+    const pass = this.passes.get(passId);
+    if (!pass)
+      return;
+    if (isTerminal2(pass.metadata.status))
+      return;
+    const completedAt = nowIso();
+    const summary = typeof data.summary === "string" ? boundString(data.summary, 12000) : null;
+    const error51 = typeof data.error === "string" ? boundString(data.error, 12000) : null;
+    pass.metadata = { ...pass.metadata, status, completedAt, summary, error: error51 };
+    this.append(pass, status === "completed" ? "pass_completed" : "pass_failed", {
+      ...data,
+      status,
+      completedAt,
+      ...summary === null ? {} : { summary },
+      ...error51 === null ? {} : { error: error51 }
+    });
+  }
+  getSnapshot(passId) {
+    const pass = this.passes.get(passId);
+    if (!pass)
+      return null;
+    return this.snapshot(pass);
+  }
+  subscribe(passId, afterCursor, listener) {
+    const pass = this.passes.get(passId);
+    if (!pass)
+      return null;
+    if (pass.subscribers.size >= DREAMING_LIVE_MAX_SUBSCRIBERS) {
+      throw new Error("Too many viewers are attached to this Dreaming pass");
+    }
+    pass.subscribers.add(listener);
+    pass.lastTouchedAt = Date.now();
+    const requested = afterCursor ?? 0;
+    const latest = pass.nextCursor - 1;
+    const first = pass.events[0]?.cursor ?? null;
+    let gap = null;
+    if (requested > latest) {
+      gap = {
+        requestedCursor: requested,
+        availableFrom: first,
+        availableTo: latest,
+        reason: "cursor_ahead"
+      };
+    } else if (first !== null && requested < first - 1) {
+      gap = {
+        requestedCursor: requested,
+        availableFrom: first,
+        availableTo: latest,
+        reason: "buffer_exhausted"
+      };
+    }
+    const replay = pass.events.filter((event) => event.cursor > requested);
+    let subscribed = true;
+    return {
+      snapshot: this.snapshot(pass),
+      replay,
+      gap,
+      unsubscribe: () => {
+        if (!subscribed)
+          return;
+        subscribed = false;
+        pass.subscribers.delete(listener);
+        pass.lastTouchedAt = Date.now();
+      }
+    };
+  }
+  getSubscriberCount(passId) {
+    if (passId === undefined)
+      return [...this.passes.values()].reduce((total, pass) => total + pass.subscribers.size, 0);
+    return this.passes.get(passId)?.subscribers.size ?? 0;
+  }
+  reset() {
+    this.passes.clear();
+  }
+  append(pass, type, input) {
+    const event = {
+      passId: pass.metadata.passId,
+      agentId: pass.metadata.agentId,
+      cursor: pass.nextCursor++,
+      timestamp: nowIso(),
+      type,
+      data: boundEventData(asRecord(input))
+    };
+    pass.events.push(event);
+    if (pass.events.length > DREAMING_LIVE_MAX_EVENTS)
+      pass.events.splice(0, pass.events.length - DREAMING_LIVE_MAX_EVENTS);
+    pass.lastTouchedAt = Date.now();
+    for (const listener of [...pass.subscribers]) {
+      try {
+        listener(event);
+      } catch {}
+    }
+  }
+  snapshot(pass) {
+    return {
+      ...pass.metadata,
+      cursor: pass.nextCursor - 1,
+      replayFrom: pass.events[0]?.cursor ?? null,
+      replayTo: pass.events.at(-1)?.cursor ?? null
+    };
+  }
+  appendRecoveredTerminal(pass) {
+    if (!isTerminal2(pass.metadata.status) || pass.events.some((event) => isTerminalEvent(event)))
+      return;
+    this.append(pass, pass.metadata.status === "completed" ? "pass_completed" : "pass_failed", {
+      status: pass.metadata.status,
+      completedAt: pass.metadata.completedAt,
+      ...pass.metadata.summary === null ? {} : { summary: pass.metadata.summary },
+      ...pass.metadata.error === null ? {} : { error: pass.metadata.error }
+    });
+  }
+  prune() {
+    const cutoff = Date.now() - DREAMING_LIVE_TERMINAL_RETENTION_MS;
+    for (const [passId, pass] of this.passes) {
+      if (pass.subscribers.size === 0 && isTerminal2(pass.metadata.status) && pass.lastTouchedAt < cutoff) {
+        this.passes.delete(passId);
+      }
+    }
+    if (this.passes.size < DREAMING_LIVE_MAX_PASSES)
+      return;
+    const candidates2 = [...this.passes.entries()].filter(([, pass]) => pass.subscribers.size === 0).sort(([, left], [, right]) => {
+      const leftTerminal = isTerminal2(left.metadata.status) ? 0 : 1;
+      const rightTerminal = isTerminal2(right.metadata.status) ? 0 : 1;
+      return leftTerminal - rightTerminal || left.lastTouchedAt - right.lastTouchedAt;
+    });
+    for (const [passId] of candidates2) {
+      if (this.passes.size < DREAMING_LIVE_MAX_PASSES)
+        break;
+      this.passes.delete(passId);
+    }
+  }
+}
+var dreamingLiveEvents = new DreamingLiveEventHub;
+
 // ../../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;
@@ -49501,8 +49798,8 @@ async function listKnowledgeEntities(accessor, params) {
   });
 }
 async function getKnowledgeEntityDetail(accessor, entityId, agentId) {
-  return await accessor.withReadDbAsync(async (db) => {
-    const row = db.prepare(`SELECT
+  const row = await accessor.withReadDbAsync((db) => {
+    return db.prepare(`SELECT
 					e.*,
 					(
 						SELECT COUNT(*) FROM entity_aspects asp
@@ -49548,22 +49845,22 @@ async function getKnowledgeEntityDetail(accessor, entityId, agentId) {
 				 FROM entities e
 				 WHERE e.id = ? AND e.agent_id = ?
 				   AND COALESCE(e.status, 'active') = 'active'`).get(entityId, agentId);
-    if (!row)
-      return null;
-    const structuralDensity = await getStructuralDensity(accessor, entityId, agentId);
-    const incomingDependencyCount = Number(row.incoming_dependency_count ?? 0);
-    const outgoingDependencyCount = Number(row.outgoing_dependency_count ?? 0);
-    return {
-      entity: rowToEntity(row),
-      aspectCount: Number(row.aspect_count ?? 0),
-      attributeCount: Number(row.attribute_count ?? 0),
-      constraintCount: Number(row.constraint_count ?? 0),
-      dependencyCount: incomingDependencyCount + outgoingDependencyCount,
-      structuralDensity,
-      incomingDependencyCount,
-      outgoingDependencyCount
-    };
   });
+  if (!row)
+    return null;
+  const structuralDensity = await getStructuralDensity(accessor, entityId, agentId);
+  const incomingDependencyCount = Number(row.incoming_dependency_count ?? 0);
+  const outgoingDependencyCount = Number(row.outgoing_dependency_count ?? 0);
+  return {
+    entity: rowToEntity(row),
+    aspectCount: Number(row.aspect_count ?? 0),
+    attributeCount: Number(row.attribute_count ?? 0),
+    constraintCount: Number(row.constraint_count ?? 0),
+    dependencyCount: incomingDependencyCount + outgoingDependencyCount,
+    structuralDensity,
+    incomingDependencyCount,
+    outgoingDependencyCount
+  };
 }
 function readEntityAspectsWithCounts(db, entityId, agentId) {
   const rows = db.prepare(`SELECT
@@ -49658,7 +49955,7 @@ async function getEntityDependenciesDetailed(accessor, params) {
   });
 }
 async function getStructuralDensity(accessor, entityId, agentId) {
-  return await accessor.withReadDbAsync(async (db) => {
+  return await accessor.withReadDbAsync((db) => {
     const aspects = db.prepare(`SELECT COUNT(*) as n FROM entity_aspects
 				 WHERE entity_id = ? AND agent_id = ?`).get(entityId, agentId);
     const attributes = db.prepare(`SELECT COUNT(*) as n FROM entity_attributes ea
@@ -52636,14 +52933,16 @@ async function awaitPressureClear(timeoutMs = 30000) {
 
 // ../../platform/daemon/src/yielding-writes.ts
 var yieldToEventLoop = () => new Promise((resolve) => setTimeout(resolve, 0));
-async function writeBatch(accessor, processBatch) {
+async function writeBatch(accessor, processBatch, label, estimatedWorkUnits) {
   if (accessor.withWriteTxAsync) {
-    return accessor.withWriteTxAsync(processBatch);
+    return accessor.withWriteTxAsync(processBatch, { operation: `db.batch.${label}`, estimatedWorkUnits });
   }
   return accessor.withWriteTx(processBatch);
 }
 async function runWriteBatches(accessor, items, processItem, options) {
   const maxPerTx = typeof options.maxPerTx === "number" && Number.isFinite(options.maxPerTx) ? Math.max(1, Math.floor(options.maxPerTx)) : 50;
+  const maxRows = typeof options.maxRows === "number" && Number.isFinite(options.maxRows) ? Math.max(1, Math.floor(options.maxRows)) : maxPerTx;
+  const maxBytes = typeof options.maxBytes === "number" && Number.isFinite(options.maxBytes) ? Math.max(1, options.maxBytes) : Number.POSITIVE_INFINITY;
   const maxTxDurationMs = typeof options.maxTxDurationMs === "number" && Number.isFinite(options.maxTxDurationMs) ? Math.max(1, options.maxTxDurationMs) : Number.POSITIVE_INFINITY;
   const yieldEvery = typeof options.yieldEvery === "number" && Number.isFinite(options.yieldEvery) ? Math.max(1, Math.floor(options.yieldEvery)) : 1;
   const maxTotal = Math.min(items.length, typeof options.maxTotal === "number" && Number.isFinite(options.maxTotal) ? Math.max(0, Math.floor(options.maxTotal)) : items.length);
@@ -52651,25 +52950,35 @@ async function runWriteBatches(accessor, items, processItem, options) {
   let processed = 0;
   let batches = 0;
   let paused = 0;
+  const startedAt = performance.now();
   while (processed < maxTotal) {
     if (!options.skipPressure && isSystemPressureHigh()) {
       paused++;
       await awaitPressureClear();
     }
     let batch;
+    let batchBytes = 0;
     try {
-      batch = await writeBatch(accessor, (db) => {
-        const startedAt = performance.now();
+      const committed = await writeBatch(accessor, (db) => {
+        const startedAt2 = performance.now();
         const batchResults = [];
+        let bytes = 0;
         for (const item of items.slice(processed, maxTotal)) {
+          const estimatedBytes = options.estimateBytes?.(item) ?? 0;
+          const itemBytes = Number.isFinite(estimatedBytes) ? Math.max(0, estimatedBytes) : 0;
+          if (batchResults.length > 0 && bytes + itemBytes > maxBytes)
+            break;
           batchResults.push(processItem(db, item));
-          if (batchResults.length >= maxPerTx)
+          bytes += itemBytes;
+          if (batchResults.length >= Math.min(maxPerTx, maxRows))
             break;
-          if (performance.now() - startedAt >= maxTxDurationMs)
+          if (performance.now() - startedAt2 >= maxTxDurationMs)
             break;
         }
-        return batchResults;
-      });
+        return { results: batchResults, bytes };
+      }, options.label, Math.min(maxPerTx, maxRows));
+      batch = committed.results;
+      batchBytes = committed.bytes;
     } catch (error51) {
       const message = error51 instanceof Error ? error51.message : String(error51);
       logger.warn("yielding-writes", `${options.label}: write batch failed after ${processed} committed items`, {
@@ -52684,6 +52993,13 @@ async function runWriteBatches(accessor, items, processItem, options) {
     results.push(...batch);
     processed += batch.length;
     batches++;
+    options.checkpoint?.({
+      processed,
+      batches,
+      rows: batch.length,
+      bytes: batchBytes,
+      elapsedMs: performance.now() - startedAt
+    });
     if (batches % yieldEvery === 0)
       await yieldToEventLoop();
   }

package/native-manifest.json

@@ -1,43 +1,43 @@
 {
   "schemaVersion": 1,
-  "version": "0.204.4",
+  "version": "0.205.0",
   "assets": [
     {
       "name": "signet-darwin-arm64",
       "platform": "darwin-arm64",
-      "sha256": "507172c9aa851ef86fc8593c905d51f1c6c5609118571a0edddc29f91b6e1164",
-      "size": 139963552
+      "sha256": "e42ec2e6c14f508555c7d8541988c3d3665967a66bb329e375201db2f59c08f8",
+      "size": 140062624
     },
     {
       "name": "signet-darwin-x64",
       "platform": "darwin-x64",
-      "sha256": "332970f4fee22478aca6c90a4da85d66bafec939319463034121cb84ddb51338",
-      "size": 144837184
+      "sha256": "9baa2a2de27cbfc4f86f7232da386b24694fb848ac0198ef10bdf42c622c6b6f",
+      "size": 144919104
     },
     {
       "name": "signet-linux-arm64",
       "platform": "linux-arm64",
-      "sha256": "e82ba7e89c22ba7c5931581c748633d91ac1a11ef012793efae2c5d4e80e5577",
-      "size": 184424682
+      "sha256": "6334b1297b638777d4080dd7c39638f9748f11c90b556b7cbaf394b1bd03179b",
+      "size": 184508656
     },
     {
       "name": "signet-linux-x64",
       "platform": "linux-x64",
-      "sha256": "7ace7b9658a955c5257c5e06327459446aa8cbeabb659dd4a1aac60d85c7cb77",
-      "size": 186798049
+      "sha256": "72f0f586bee2ed9bc53e272890253fed89f0e4336a2590cbdf6e023c51701e36",
+      "size": 186882023
     },
     {
       "name": "signet-win32-x64.exe",
       "platform": "win32-x64",
-      "sha256": "595a1ca05105bd00099ab21a3e8bd0905fdf6ee345a36a5e7d19a886e8730583",
-      "size": 194870784
+      "sha256": "504ae86fefd1ec69f0fc3e73cde4f8fd13ffacd3bc2ef6103a673d0c6d85bdaf",
+      "size": 194954752
     }
   ],
   "components": {
     "connectors": {
-      "url": "signet-connectors-0.204.4.tar.gz",
-      "sha256": "696688fee77c5732b1193a03fc1ff188627645ed71c8d1d8824f69a78f5db70c",
-      "size": 21945
+      "url": "signet-connectors-0.205.0.tar.gz",
+      "sha256": "d2b9c818c1bbce8e7210c9afe6c97301c7d3d0ea71acae92e24c7e0c8f05e251",
+      "size": 21943
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signetai",
-  "version": "0.204.4",
+  "version": "0.205.0",
   "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.204.4/signetai-darwin-arm64-0.204.4.tgz",
-    "signetai-darwin-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.204.4/signetai-darwin-x64-0.204.4.tgz",
-    "signetai-linux-arm64": "https://github.com/Signet-AI/signetai/releases/download/v0.204.4/signetai-linux-arm64-0.204.4.tgz",
-    "signetai-linux-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.204.4/signetai-linux-x64-0.204.4.tgz",
-    "signetai-win32-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.204.4/signetai-win32-x64-0.204.4.tgz"
+    "signetai-darwin-arm64": "https://github.com/Signet-AI/signetai/releases/download/v0.205.0/signetai-darwin-arm64-0.205.0.tgz",
+    "signetai-darwin-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.205.0/signetai-darwin-x64-0.205.0.tgz",
+    "signetai-linux-arm64": "https://github.com/Signet-AI/signetai/releases/download/v0.205.0/signetai-linux-arm64-0.205.0.tgz",
+    "signetai-linux-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.205.0/signetai-linux-x64-0.205.0.tgz",
+    "signetai-win32-x64": "https://github.com/Signet-AI/signetai/releases/download/v0.205.0/signetai-win32-x64-0.205.0.tgz"
   }
 }