npm - @geravant/sinain - Versions diffs - 1.20.0 → 1.22.0 - Mend

@geravant/sinain 1.20.0 → 1.22.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/package.json +1 -1
package/sinain-core/src/learning/local-curation.ts +3 -0
package/sinain-core/src/server.ts +575 -4
package/sinain-core/src/web-db/schema.ts +23 -1
package/sinain-core/src/web-db/store.ts +127 -0
package/sinain-memory/graph_query.py +6 -4
package/sinain-memory/knowledge_integrator.py +87 -10

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@geravant/sinain",
-  "version": "1.20.0",
+  "version": "1.22.0",
   "description": "Ambient intelligence that sees what you see, hears what you hear, and acts on your behalf",
   "type": "module",
   "bin": {

package/sinain-core/src/learning/local-curation.ts CHANGED Viewed

@@ -366,6 +366,9 @@ export class LocalCurationService {
       this.writeDailyNotes(digest, transcript as any);
       // Step 2: Integrate into playbook + knowledge graph
+      // Inject raw feed items so integrator stores verbatim quotes + agent analysis
+      digest._rawItems = transcript;
+      digest._feedItemCount = transcript.length;
       try {
         const integratorOutput = execFileSync("python3", [
           resolve(this.scriptsDir, "knowledge_integrator.py"),

package/sinain-core/src/server.ts CHANGED Viewed

@@ -331,6 +331,32 @@ const KNOWLEDGE_UI_V2_HTML = `<!DOCTYPE html>
   .toast .timer { height: 2px; background: var(--accent); position: absolute;
                   bottom: 0; left: 0; transition: width linear; }
   .toast button { padding: 4px 10px; font-size: 12px; }
+  /* Share badge in header */
+  .share-badge { color: var(--accent); font-weight: 600; font-variant-numeric: tabular-nums; }
+  /* Shares view */
+  .shares-list { display: flex; flex-direction: column; gap: 12px; }
+  .share-row { background: var(--bg-elev); border: 1px solid var(--border);
+               border-radius: 6px; padding: 14px 16px;
+               display: grid; grid-template-columns: auto 1fr auto; gap: 12px;
+               align-items: center; }
+  .share-row .icon { font-size: 18px; line-height: 1; }
+  .share-row .body { min-width: 0; }
+  .share-row .title { font-weight: 600; color: var(--accent); white-space: nowrap;
+                      overflow: hidden; text-overflow: ellipsis; }
+  .share-row .meta { color: var(--fg-dim); font-size: 12px; margin-top: 2px;
+                     white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+  .share-row .actions { display: flex; gap: 6px; flex-wrap: wrap; }
+  .share-row .pill { padding: 2px 8px; border-radius: 999px; font-size: 11px; font-weight: 600;
+                     letter-spacing: 0.02em; text-transform: uppercase; }
+  .pill-waiting    { background: rgba(180,83,9,0.10);   color: var(--warn); }
+  .pill-connecting { background: rgba(37,99,235,0.10);  color: var(--accent); }
+  .pill-delivered  { background: rgba(21,128,61,0.10);  color: #15803d; }
+  .pill-disconnected { background: var(--chip);          color: var(--fg-faint); }
+  .pill-revoked    { background: rgba(185,28,28,0.08);  color: var(--danger); }
+  .pill-expired    { background: var(--chip);            color: var(--fg-faint); }
+  .pill-permanent  { background: var(--chip);            color: var(--fg-dim); }
+  .pulse { animation: pulse 1.6s ease-in-out infinite; }
+  @keyframes pulse { 0%,100% { opacity: 1; } 50% { opacity: 0.55; } }
   /* Loading */
   .spinner { display: inline-block; width: 14px; height: 14px;
              border: 2px solid var(--border); border-top-color: var(--accent);
@@ -351,6 +377,7 @@ const KNOWLEDGE_UI_V2_HTML = `<!DOCTYPE html>
     <div id="searchResults" class="search-results"></div>
   </div>
   <div class="header-actions">
+    <button onclick="navigate('/knowledge/ui/shares')" title="My share links">📤 Shares <span id="shareBadge" class="share-badge"></span></button>
     <a href="/knowledge/ui-legacy"><button>Legacy view</button></a>
   </div>
 </header>
@@ -381,6 +408,11 @@ async function api(path, opts = {}) {
   }
 }
+// ── Cross-machine sharing config (env-injected at serve time) ────────────
+const SHARE_PEERJS_HOST = __SHARE_PEERJS_HOST__;     // empty string → peerjs.com cloud
+const SHARE_INLINE_MAX_BYTES = __SHARE_INLINE_MAX_BYTES__;
+const SHARE_TTL_HOURS = __SHARE_TTL_HOURS__;
 // ── Router ────────────────────────────────────────────────────────────────
 function navigate(path) {
   history.pushState({}, "", path);
@@ -390,6 +422,8 @@ window.addEventListener("popstate", render);
 window.addEventListener("DOMContentLoaded", () => {
   setupSearch();
   setupGlobalDrop();
+  ShareManager.resumePeerShares().catch(e => console.warn("share resume failed", e));
+  refreshShareBadge();
   render();
 });
@@ -397,6 +431,8 @@ function render() {
   const path = location.pathname;
   if (path === "/knowledge/ui" || path === "/knowledge/ui/") {
     renderHome();
+  } else if (path === "/knowledge/ui/shares" || path === "/knowledge/ui/shares/") {
+    renderSharesView();
   } else if (path.startsWith("/knowledge/ui/entity/")) {
     const entity = decodeURIComponent(path.slice("/knowledge/ui/entity/".length));
     renderEntityPage(entity);
@@ -408,6 +444,258 @@ function render() {
   }
 }
+// ── Share infrastructure (gzip helpers, peerjs loader, ShareManager) ─────
+function randomHex(byteCount) {
+  const buf = new Uint8Array(byteCount);
+  crypto.getRandomValues(buf);
+  return Array.from(buf, b => b.toString(16).padStart(2, "0")).join("");
+}
+async function gzipBase64(text) {
+  // CompressionStream("gzip") is in all modern browsers (Chrome 80+, Safari
+  // 16.4+, Firefox 113+). No external library needed.
+  const cs = new Blob([text]).stream().pipeThrough(new CompressionStream("gzip"));
+  const buf = new Uint8Array(await new Response(cs).arrayBuffer());
+  // base64url so the output is URL-safe (no +, /, =).
+  let bin = "";
+  for (let i = 0; i < buf.length; i++) bin += String.fromCharCode(buf[i]);
+  return btoa(bin).replace(/\\+/g, "-").replace(/\\//g, "_").replace(/=+$/, "");
+}
+async function ungzipBase64(encoded) {
+  const padded = encoded.replace(/-/g, "+").replace(/_/g, "/")
+    + "===".slice((encoded.length + 3) % 4);
+  const bin = atob(padded);
+  const bytes = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+  const ds = new Blob([bytes]).stream().pipeThrough(new DecompressionStream("gzip"));
+  return await new Response(ds).text();
+}
+let _peerjsLoading = null;
+function ensurePeerJsLoaded() {
+  if (window.Peer) return Promise.resolve();
+  if (_peerjsLoading) return _peerjsLoading;
+  _peerjsLoading = new Promise((res, rej) => {
+    const s = document.createElement("script");
+    // Pinned version + SRI hash. If you bump version, regenerate hash via:
+    //   curl -sL https://cdn.jsdelivr.net/npm/peerjs@1.5.4/dist/peerjs.min.js | openssl dgst -sha384 -binary | openssl base64 -A
+    s.src = "https://cdn.jsdelivr.net/npm/peerjs@1.5.4/dist/peerjs.min.js";
+    s.crossOrigin = "anonymous";
+    s.onload = () => res();
+    s.onerror = (e) => rej(new Error("peerjs failed to load — network or CDN issue"));
+    document.head.appendChild(s);
+  });
+  return _peerjsLoading;
+}
+function newPeer(idOrUndef) {
+  // Honor SHARE_PEERJS_HOST env-injected override. Empty string = peerjs.com default.
+  const opts = SHARE_PEERJS_HOST ? { host: SHARE_PEERJS_HOST } : {};
+  return idOrUndef ? new window.Peer(idOrUndef, opts) : new window.Peer(opts);
+}
+const ShareManager = (() => {
+  // share_token → live Peer instance (sender side only). Bundles are re-fetched
+  // on demand rather than kept in JS memory across resume.
+  const peers = new Map();
+  async function buildBundle(entity) {
+    const r = await fetch(\`/knowledge/concepts/export?entity=\${encodeURIComponent(entity)}\` +
+      \`&depth=1&include_page=1\`);
+    if (!r.ok) throw new Error("export failed: " + r.status);
+    return await r.text();
+  }
+  async function createShare(entity) {
+    const bundle = await buildBundle(entity);
+    const sizeBytes = new TextEncoder().encode(bundle).length;
+    const token = randomHex(8);  // 16 hex chars
+    if (sizeBytes <= SHARE_INLINE_MAX_BYTES) {
+      const compressed = await gzipBase64(bundle);
+      const url = location.origin + "/knowledge/ui/entity/" +
+        encodeURIComponent(entity) + "#bundle=" + compressed;
+      await api("/knowledge/shares", { method: "POST",
+        headers: {"Content-Type": "application/json"},
+        body: JSON.stringify({
+          entity_id: entity, mode: "fragment", share_token: token, url, bundle_size: sizeBytes
+        })
+      });
+      try { await navigator.clipboard.writeText(url); } catch { /* clipboard denied */ }
+      showToast("✓ Link copied · self-contained, can't be revoked", 6000);
+      refreshShareBadge();
+      return { mode: "fragment", url };
+    }
+    // Peer mode
+    await ensurePeerJsLoaded();
+    const peer = newPeer(token);
+    await new Promise((res, rej) => {
+      peer.on("open", () => res());
+      peer.on("error", e => rej(e));
+      setTimeout(() => rej(new Error("peerjs broker timeout")), 8000);
+    });
+    const url = location.origin + "/knowledge/ui/entity/" +
+      encodeURIComponent(entity) + "#peer=" + token;
+    await api("/knowledge/shares", { method: "POST",
+      headers: {"Content-Type": "application/json"},
+      body: JSON.stringify({
+        entity_id: entity, mode: "peer", share_token: token, url, bundle_size: sizeBytes
+      })
+    });
+    peers.set(token, peer);
+    attachSenderHandlers(peer, token, entity);
+    try { await navigator.clipboard.writeText(url); } catch {}
+    showToast("✓ Link copied · live until you revoke (see Shares)", 6000);
+    refreshShareBadge();
+    return { mode: "peer", url };
+  }
+  function attachSenderHandlers(peer, token, entity) {
+    peer.on("connection", (conn) => {
+      patchStatus(token, "connecting");
+      conn.on("open", async () => {
+        try {
+          // Re-fetch bundle each time — keeps memory low and reflects latest state.
+          const bundle = await buildBundle(entity);
+          conn.send({ type: "bundle", payload: bundle });
+        } catch (e) {
+          conn.send({ type: "error", message: String(e).slice(0, 200) });
+          conn.close();
+        }
+      });
+      conn.on("data", (msg) => {
+        if (msg && msg.type === "ack") {
+          patchStatus(token, "delivered", { delivered_at: Date.now() });
+          // Keep peer alive briefly for retries, then release.
+          setTimeout(() => destroyPeer(token), 5000);
+        }
+      });
+      conn.on("close", () => { /* normal */ });
+    });
+    peer.on("disconnected", () => patchStatus(token, "disconnected"));
+    peer.on("close", () => patchStatus(token, "disconnected"));
+    peer.on("error", (err) => {
+      console.warn("share peer error", token, err && err.type, err && err.message);
+    });
+  }
+  async function patchStatus(token, status, extra) {
+    const body = Object.assign({ status }, extra || {});
+    await api("/knowledge/shares/" + encodeURIComponent(token), {
+      method: "PATCH", headers: {"Content-Type": "application/json"},
+      body: JSON.stringify(body),
+    });
+    refreshShareBadge();
+  }
+  async function resumePeerShares() {
+    const r = await api("/knowledge/shares?status=waiting&status=connecting&status=disconnected");
+    if (!r || !r.ok) return;
+    for (const share of r.shares || []) {
+      if (share.mode !== "peer") continue;
+      try {
+        await ensurePeerJsLoaded();
+        const peer = newPeer(share.share_token);
+        await new Promise((res, rej) => {
+          peer.on("open", () => res());
+          peer.on("error", e => rej(e));
+          setTimeout(() => rej(new Error("peerjs open timeout")), 8000);
+        });
+        peers.set(share.share_token, peer);
+        attachSenderHandlers(peer, share.share_token, share.entity_id);
+        if (share.status !== "waiting") {
+          await patchStatus(share.share_token, "waiting");
+        }
+      } catch (e) {
+        console.warn("resume failed for", share.share_token, e && e.message);
+        // Mark as disconnected so the user sees it failed; they can manually revoke.
+        await patchStatus(share.share_token, "disconnected").catch(() => {});
+      }
+    }
+  }
+  function destroyPeer(token) {
+    const peer = peers.get(token);
+    if (peer) {
+      try { peer.destroy(); } catch {}
+      peers.delete(token);
+    }
+  }
+  async function revoke(token) {
+    destroyPeer(token);
+    await api("/knowledge/shares/" + encodeURIComponent(token), {
+      method: "PATCH", headers: {"Content-Type": "application/json"},
+      body: JSON.stringify({ status: "revoked", revoked_at: Date.now() })
+    });
+    refreshShareBadge();
+  }
+  async function forget(token) {
+    destroyPeer(token);
+    await api("/knowledge/shares/" + encodeURIComponent(token), { method: "DELETE" });
+    refreshShareBadge();
+  }
+  async function connectAsRecipient(token) {
+    showToast('<span class="spinner"></span> Connecting peer-to-peer…', 30_000);
+    await ensurePeerJsLoaded();
+    const me = newPeer();
+    await new Promise((res, rej) => {
+      me.on("open", () => res());
+      me.on("error", e => rej(e));
+      setTimeout(() => rej(new Error("peerjs broker timeout")), 8000);
+    });
+    return new Promise((resolve, reject) => {
+      const conn = me.connect(token, { reliable: true });
+      const cleanup = () => { try { conn.close(); } catch {} try { me.destroy(); } catch {} };
+      const openTimeout = setTimeout(() => {
+        cleanup();
+        reject(new Error("source offline or unreachable"));
+      }, 15_000);
+      conn.on("open", () => clearTimeout(openTimeout));
+      conn.on("error", (e) => { cleanup(); reject(e); });
+      conn.on("data", async (msg) => {
+        if (!msg) return;
+        if (msg.type === "error") {
+          cleanup();
+          reject(new Error("source error: " + msg.message));
+          return;
+        }
+        if (msg.type === "bundle") {
+          try {
+            const importR = await api("/knowledge/concepts/import?conflict=merge", {
+              method: "POST",
+              headers: {"Content-Type": "application/json"},
+              body: msg.payload,
+            });
+            conn.send({ type: "ack" });
+            setTimeout(cleanup, 500);
+            resolve(importR);
+          } catch (e) {
+            cleanup();
+            reject(e);
+          }
+        }
+      });
+    });
+  }
+  return { createShare, resumePeerShares, revoke, forget, connectAsRecipient };
+})();
+async function refreshShareBadge() {
+  try {
+    const r = await api("/knowledge/shares?status=waiting&status=connecting");
+    const count = (r && r.shares) ? r.shares.length : 0;
+    const badge = document.getElementById("shareBadge");
+    if (badge) badge.textContent = count > 0 ? "(" + count + ")" : "";
+  } catch {}
+}
 // ── Home view ─────────────────────────────────────────────────────────────
 async function renderHome() {
   document.title = "Sinain Knowledge";
@@ -454,6 +742,111 @@ function timeAgo(ts) {
   return Math.round(diff / 86_400_000) + "d ago";
 }
+function fmtBytes(n) {
+  if (n == null) return "?";
+  if (n < 1024) return n + " B";
+  if (n < 1024 * 1024) return (n / 1024).toFixed(1) + " KB";
+  return (n / 1024 / 1024).toFixed(1) + " MB";
+}
+// ── Shares view ───────────────────────────────────────────────────────────
+async function renderSharesView() {
+  document.title = "Shares · Sinain";
+  const root = $("#root");
+  root.innerHTML = '<div class="loading-block"><span class="spinner"></span> Loading shares…</div>';
+  const r = await api("/knowledge/shares?include_archived=1");
+  const shares = (r && r.shares) || [];
+  refreshShareBadge();
+  if (shares.length === 0) {
+    root.innerHTML = \`
+      <h1>Shares</h1>
+      <div class="empty-row" style="padding:24px;">
+        No shares yet. Open an entity page and click 📤 Share to create one.
+      </div>\`;
+    return;
+  }
+  root.innerHTML = '<h1>Shares</h1><div class="shares-list" id="sharesList"></div>';
+  const list = $("#sharesList");
+  list.innerHTML = shares.map(renderShareRow).join("");
+  // Wire per-row actions via event delegation
+  list.addEventListener("click", async (e) => {
+    const btn = e.target.closest("button[data-action]");
+    if (!btn) return;
+    const token = btn.dataset.token;
+    const action = btn.dataset.action;
+    const share = shares.find(s => s.share_token === token);
+    if (!share) return;
+    if (action === "copy") {
+      try {
+        await navigator.clipboard.writeText(share.url);
+        showToast("✓ URL copied");
+      } catch {
+        showToast("Copy failed — your browser may block clipboard access");
+      }
+    } else if (action === "revoke") {
+      if (share.mode === "fragment") {
+        const ok = confirm(
+          "Mark this share as revoked?\\n\\n" +
+          "Note: the URL is self-contained — anyone who already has it can still import. " +
+          "This only removes it from your active list.");
+        if (!ok) return;
+      }
+      await ShareManager.revoke(token);
+      renderSharesView();
+    } else if (action === "forget") {
+      const ok = confirm("Remove this share from your list permanently?");
+      if (!ok) return;
+      await ShareManager.forget(token);
+      renderSharesView();
+    } else if (action === "open") {
+      navigate("/knowledge/ui/entity/" + encodeURIComponent(share.entity_id));
+    }
+  });
+}
+function renderShareRow(s) {
+  const isPeer = s.mode === "peer";
+  const statusClass = "pill-" + (s.mode === "fragment" && s.status === "delivered" ? "permanent" : s.status);
+  const statusLabel = s.mode === "fragment" && s.status === "delivered" ? "permanent" : s.status;
+  const pulsing = (s.status === "waiting" || s.status === "connecting") ? " pulse" : "";
+  const icon = ({
+    waiting: "⏳", connecting: "⚡", delivered: isPeer ? "✓" : "📎",
+    disconnected: "⚠", revoked: "✕", expired: "⌛"
+  })[s.status] || "•";
+  const sub = [];
+  sub.push(timeAgo(s.created_at));
+  if (s.bundle_size != null) sub.push(fmtBytes(s.bundle_size));
+  if (isPeer) sub.push("PEER"); else sub.push("LINK");
+  if (s.delivered_at) sub.push("delivered " + timeAgo(s.delivered_at));
+  if (s.recipient_hint) sub.push(s.recipient_hint);
+  // Per-mode actions: peer has Revoke (real); fragment has Revoke (best-effort)
+  // and both have Copy + Forget.
+  const showRevoke = (s.status === "waiting" || s.status === "connecting" || s.status === "disconnected"
+                     || (s.mode === "fragment" && s.status === "delivered"));
+  return \`
+    <div class="share-row\${pulsing}">
+      <div class="icon">\${icon}</div>
+      <div class="body">
+        <div class="title" onclick="navigate('/knowledge/ui/entity/' + encodeURIComponent('\${esc(s.entity_id)}'))" style="cursor:pointer">
+          \${esc(s.entity_id)}
+        </div>
+        <div class="meta">\${sub.map(esc).join(" · ")}</div>
+      </div>
+      <div class="actions">
+        <span class="pill \${statusClass}">\${esc(statusLabel)}</span>
+        <button data-action="copy" data-token="\${esc(s.share_token)}" title="Copy share URL">📋</button>
+        \${showRevoke ? \`<button data-action="revoke" data-token="\${esc(s.share_token)}" title="\${isPeer ? 'Revoke this share (recipient will see source offline)' : 'Mark revoked (URL still works for anyone who has it)'}">✕</button>\` : ""}
+        <button data-action="forget" data-token="\${esc(s.share_token)}" title="Remove from list">🗑</button>
+      </div>
+    </div>\`;
+}
 // ── Search ────────────────────────────────────────────────────────────────
 function setupSearch() {
   const input = $("#search");
@@ -491,6 +884,30 @@ async function renderEntityPage(entity) {
   const root = $("#root");
   root.innerHTML = \`<div class="loading-block"><span class="spinner"></span> Loading \${esc(entity)}…</div>\`;
+  // Auto-import path for share links — runs BEFORE the local existence check
+  // so a recipient with no prior data on this entity gets the page populated.
+  if (location.hash.startsWith("#bundle=")) {
+    try {
+      const json = await ungzipBase64(location.hash.slice("#bundle=".length));
+      await api("/knowledge/concepts/import?conflict=merge", {
+        method: "POST", headers: {"Content-Type": "application/json"}, body: json
+      });
+      showToast("✓ Concept imported");
+    } catch (e) {
+      showToast("Import failed: " + (e.message || "decode error"));
+    }
+    history.replaceState({}, "", location.pathname);  // strip hash
+  } else if (location.hash.startsWith("#peer=")) {
+    const token = location.hash.slice("#peer=".length);
+    history.replaceState({}, "", location.pathname);  // strip early — keeps refresh sane
+    try {
+      await ShareManager.connectAsRecipient(token);
+      showToast("✓ Concept imported via peer");
+    } catch (e) {
+      showToast("Peer share failed: " + (e.message || "unreachable"));
+    }
+  }
   const page = await api("/knowledge/page?entity=" + encodeURIComponent(entity));
   if (!page.ok || page.fact_count === 0) {
     if (page.fact_count === 0) {
@@ -515,8 +932,9 @@ async function renderEntityPage(entity) {
         <button id="bmFavorite" class="icon" title="Favorite">★</button>
         <button id="bmArchive" class="icon" title="Archive">🗄</button>
         <button id="actRefresh" class="icon" title="Re-render">↻</button>
-        <button id="actCopyLink" class="icon" title="Copy link">🔗</button>
-        <button id="actExport" class="icon" title="Export concept">⬇</button>
+        <button id="actCopyLink" class="icon" title="Copy entity URL (recipient needs same data)">🔗</button>
+        <button id="actShare" class="icon" title="Share concept (auto-imports for recipient)">📤</button>
+        <button id="actExport" class="icon" title="Download bundle file (manual transfer)">⬇</button>
       </div>
     </div>
     <div class="layout-3col">
@@ -549,6 +967,7 @@ async function renderEntityPage(entity) {
   $("#bmArchive").onclick = () => bookmarkAction(entity, "archive");
   $("#actRefresh").onclick = () => refreshPage(entity);
   $("#actCopyLink").onclick = () => copyLink(entity);
+  $("#actShare").onclick = () => shareEntity(entity);
   $("#actExport").onclick = () => exportConcept(entity);
   // Wire bullet retraction (event delegation)
@@ -673,6 +1092,17 @@ async function exportConcept(entity) {
   showToast("✓ Exporting concept bundle…");
 }
+async function shareEntity(entity) {
+  showToast('<span class="spinner"></span> Preparing share…', 30_000);
+  try {
+    await ShareManager.createShare(entity);
+    // Toast + clipboard already handled by ShareManager. User can navigate
+    // freely; status is visible in the Shares view.
+  } catch (e) {
+    showToast("Share failed: " + (e && e.message ? e.message : String(e)));
+  }
+}
 // ── Retraction modal + undo toast ─────────────────────────────────────────
 function openRetractModal(factId, bulletEl, sourceEntity) {
   const text = bulletEl.querySelector(".text").textContent;
@@ -836,6 +1266,22 @@ async function importFiles(files, redirectAfter) {
 </script>
 </body></html>`;
+/**
+ * Render the V2 SPA HTML with env-var-driven config substituted in.
+ * The placeholders `__SHARE_PEERJS_HOST__` etc. are inert in the source
+ * template; we replace them at serve time so the SPA can read the values
+ * without an extra `/knowledge/share/config` round-trip on load.
+ */
+function renderKnowledgeUiV2(): string {
+  const peerHost = process.env.SINAIN_PEERJS_HOST || "";  // empty = peerjs.com cloud default
+  const inlineMax = parseInt(process.env.SINAIN_SHARE_INLINE_MAX_BYTES || "6000");
+  const ttlHours = parseInt(process.env.SINAIN_SHARE_TTL_HOURS || "24");
+  return KNOWLEDGE_UI_V2_HTML
+    .replace(/__SHARE_PEERJS_HOST__/g, JSON.stringify(peerHost))
+    .replace(/__SHARE_INLINE_MAX_BYTES__/g, String(inlineMax))
+    .replace(/__SHARE_TTL_HOURS__/g, String(ttlHours));
+}
 /** Server epoch — lets clients detect restarts. */
 const serverEpoch = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
@@ -1492,6 +1938,131 @@ export function createAppServer(deps: ServerDeps) {
         return;
       }
+      // ── /knowledge/shares ── (cross-machine concept share metadata) ──
+      if (req.method === "POST" && url.pathname === "/knowledge/shares") {
+        if (!deps.webDb) {
+          res.writeHead(503);
+          res.end(JSON.stringify({ ok: false, error: "web.db not initialized" }));
+          return;
+        }
+        let body: any;
+        try { body = JSON.parse(await readBody(req, 16_384)); } catch {
+          res.writeHead(400);
+          res.end(JSON.stringify({ ok: false, error: "invalid JSON" }));
+          return;
+        }
+        const required = ["entity_id", "mode", "share_token", "url"];
+        for (const k of required) {
+          if (!body[k] || typeof body[k] !== "string") {
+            res.writeHead(400);
+            res.end(JSON.stringify({ ok: false, error: `${k} required` }));
+            return;
+          }
+        }
+        if (!["fragment", "peer"].includes(body.mode)) {
+          res.writeHead(400);
+          res.end(JSON.stringify({ ok: false, error: "mode must be fragment|peer" }));
+          return;
+        }
+        try {
+          const row = deps.webDb.createSharedDoc({
+            share_token: body.share_token,
+            entity_id: body.entity_id,
+            mode: body.mode,
+            // Fragment shares are 'delivered' the moment the link is created
+            // (the bundle is in the URL); peer shares start as 'waiting'.
+            status: body.mode === "fragment" ? "delivered" : "waiting",
+            bundle_size: typeof body.bundle_size === "number" ? body.bundle_size : null,
+            url: body.url,
+            delivered_at: body.mode === "fragment" ? Date.now() : null,
+            revoked_at: null,
+            recipient_hint: null,
+            notes: body.notes || null,
+          });
+          res.end(JSON.stringify({ ok: true, share: row }));
+        } catch (err: any) {
+          // Most likely UNIQUE constraint on share_token
+          res.writeHead(409);
+          res.end(JSON.stringify({ ok: false, error: err.message?.slice(0, 200) }));
+        }
+        return;
+      }
+      if (req.method === "GET" && url.pathname === "/knowledge/shares") {
+        if (!deps.webDb) {
+          res.writeHead(503);
+          res.end(JSON.stringify({ ok: false, error: "web.db not initialized" }));
+          return;
+        }
+        // Auto-expire stale shares opportunistically on each list call.
+        const ttlHours = parseInt(process.env.SINAIN_SHARE_TTL_HOURS || "24");
+        if (ttlHours > 0) {
+          deps.webDb.expireStaleShares(ttlHours * 60 * 60 * 1000);
+        }
+        const statusParams = url.searchParams.getAll("status").filter(Boolean);
+        const limit = Math.min(parseInt(url.searchParams.get("limit") || "200"), 500);
+        const includeArchived = url.searchParams.get("include_archived") === "1";
+        const shares = deps.webDb.listSharedDocs({
+          statuses: statusParams.length > 0 ? statusParams as any : undefined,
+          limit,
+          includeArchived,
+        });
+        const activeCount = deps.webDb.countActiveShares();
+        res.end(JSON.stringify({ ok: true, shares, active_count: activeCount }));
+        return;
+      }
+      if (req.method === "PATCH" && url.pathname.startsWith("/knowledge/shares/")) {
+        if (!deps.webDb) {
+          res.writeHead(503);
+          res.end(JSON.stringify({ ok: false, error: "web.db not initialized" }));
+          return;
+        }
+        const token = decodeURIComponent(url.pathname.slice("/knowledge/shares/".length));
+        if (!token) {
+          res.writeHead(400);
+          res.end(JSON.stringify({ ok: false, error: "share_token required" }));
+          return;
+        }
+        let body: any;
+        try { body = JSON.parse(await readBody(req, 4096)); } catch {
+          res.writeHead(400);
+          res.end(JSON.stringify({ ok: false, error: "invalid JSON" }));
+          return;
+        }
+        const status = body.status;
+        const valid = ["waiting","connecting","delivered","disconnected","revoked","expired"];
+        if (!status || !valid.includes(status)) {
+          res.writeHead(400);
+          res.end(JSON.stringify({ ok: false, error: `status must be one of ${valid.join("|")}` }));
+          return;
+        }
+        const ok = deps.webDb.updateSharedDocStatus(token, status, {
+          delivered_at: typeof body.delivered_at === "number" ? body.delivered_at : undefined,
+          revoked_at: typeof body.revoked_at === "number" ? body.revoked_at : undefined,
+          recipient_hint: typeof body.recipient_hint === "string" ? body.recipient_hint.slice(0, 200) : undefined,
+        });
+        if (!ok) {
+          res.writeHead(404);
+          res.end(JSON.stringify({ ok: false, error: "share not found" }));
+          return;
+        }
+        res.end(JSON.stringify({ ok: true, share: deps.webDb.getSharedDoc(token) }));
+        return;
+      }
+      if (req.method === "DELETE" && url.pathname.startsWith("/knowledge/shares/")) {
+        if (!deps.webDb) {
+          res.writeHead(503);
+          res.end(JSON.stringify({ ok: false, error: "web.db not initialized" }));
+          return;
+        }
+        const token = decodeURIComponent(url.pathname.slice("/knowledge/shares/".length));
+        const removed = deps.webDb.deleteSharedDoc(token);
+        res.end(JSON.stringify({ ok: true, removed }));
+        return;
+      }
       // Legacy fact-browser kept for fallback / quick raw access.
       if (req.method === "GET" && url.pathname === "/knowledge/ui-legacy") {
         res.setHeader("Content-Type", "text/html");
@@ -1503,7 +2074,7 @@ export function createAppServer(deps: ServerDeps) {
       // bookmarks, retraction, concept transfer.
       if (req.method === "GET" && url.pathname === "/knowledge/ui") {
         res.setHeader("Content-Type", "text/html");
-        res.end(KNOWLEDGE_UI_V2_HTML);
+        res.end(renderKnowledgeUiV2());
         return;
       }
@@ -1511,7 +2082,7 @@ export function createAppServer(deps: ServerDeps) {
       // we just serve the same HTML; client-side router parses location.pathname.
       if (req.method === "GET" && url.pathname.startsWith("/knowledge/ui/")) {
         res.setHeader("Content-Type", "text/html");
-        res.end(KNOWLEDGE_UI_V2_HTML);
+        res.end(renderKnowledgeUiV2());
         return;
       }

package/sinain-core/src/web-db/schema.ts CHANGED Viewed

@@ -7,7 +7,7 @@
  * that should not be visible to the curator/distiller.
  */
-export const SCHEMA_VERSION = 1;
+export const SCHEMA_VERSION = 2;
 export const SCHEMA_SQL = `
 -- Schema version tracking (for future migrations)
@@ -97,4 +97,26 @@ CREATE TABLE IF NOT EXISTS search_log (
   result_count  INTEGER
 );
 CREATE INDEX IF NOT EXISTS idx_search_log_ts ON search_log(ts DESC);
+-- Cross-machine concept share tracking (URL-fragment + WebRTC peer modes).
+-- Persistent across SPA refresh — ShareManager reads this on load and
+-- re-binds peer connections using the stored share_token as the peerjs ID.
+CREATE TABLE IF NOT EXISTS shared_docs (
+  id             INTEGER PRIMARY KEY AUTOINCREMENT,
+  share_token    TEXT NOT NULL UNIQUE,
+  entity_id      TEXT NOT NULL,
+  mode           TEXT NOT NULL CHECK (mode IN ('fragment','peer')),
+  status         TEXT NOT NULL CHECK (status IN ('waiting','connecting','delivered','disconnected','revoked','expired')),
+  bundle_size    INTEGER,
+  url            TEXT NOT NULL,
+  created_at     INTEGER NOT NULL,
+  delivered_at   INTEGER,
+  revoked_at     INTEGER,
+  recipient_hint TEXT,
+  notes          TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_shared_docs_status
+  ON shared_docs(status, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_shared_docs_entity
+  ON shared_docs(entity_id);
 `;

package/sinain-core/src/web-db/store.ts CHANGED Viewed

@@ -58,6 +58,26 @@ export interface ConceptImportRow {
   notes: string | null;
 }
+export type SharedDocMode = "fragment" | "peer";
+export type SharedDocStatus =
+  | "waiting" | "connecting" | "delivered"
+  | "disconnected" | "revoked" | "expired";
+export interface SharedDocRow {
+  id?: number;
+  share_token: string;
+  entity_id: string;
+  mode: SharedDocMode;
+  status: SharedDocStatus;
+  bundle_size: number | null;
+  url: string;
+  created_at: number;
+  delivered_at: number | null;
+  revoked_at: number | null;
+  recipient_hint: string | null;
+  notes: string | null;
+}
 const PAGE_CACHE_LRU_CAP = 500;
 export class WebDb {
@@ -276,4 +296,111 @@ export class WebDb {
       )
       .run(Date.now(), query, resolved_to, result_count);
   }
+  // ── Shared docs ─────────────────────────────────────────
+  // Cross-machine sharing: persistent records of share links the user
+  // produced. ShareManager (browser) reads these on SPA load to resume
+  // peer connections.
+  createSharedDoc(row: Omit<SharedDocRow, "id" | "created_at"> & { created_at?: number }): SharedDocRow {
+    const created_at = row.created_at ?? Date.now();
+    const r = this.db
+      .prepare(
+        `INSERT INTO shared_docs
+         (share_token, entity_id, mode, status, bundle_size, url,
+          created_at, delivered_at, revoked_at, recipient_hint, notes)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      )
+      .run(
+        row.share_token,
+        row.entity_id,
+        row.mode,
+        row.status,
+        row.bundle_size,
+        row.url,
+        created_at,
+        row.delivered_at,
+        row.revoked_at,
+        row.recipient_hint,
+        row.notes,
+      );
+    return this.db
+      .prepare("SELECT * FROM shared_docs WHERE id = ?")
+      .get(Number(r.lastInsertRowid)) as SharedDocRow;
+  }
+  /** List shares; default returns all non-revoked + non-expired, recent first. */
+  listSharedDocs(opts?: { statuses?: SharedDocStatus[]; limit?: number; includeArchived?: boolean }): SharedDocRow[] {
+    const limit = opts?.limit ?? 200;
+    const statuses = opts?.statuses;
+    if (statuses && statuses.length > 0) {
+      const placeholders = statuses.map(() => "?").join(",");
+      return this.db
+        .prepare(
+          `SELECT * FROM shared_docs WHERE status IN (${placeholders})
+           ORDER BY created_at DESC LIMIT ?`,
+        )
+        .all(...statuses, limit) as SharedDocRow[];
+    }
+    if (opts?.includeArchived) {
+      return this.db
+        .prepare("SELECT * FROM shared_docs ORDER BY created_at DESC LIMIT ?")
+        .all(limit) as SharedDocRow[];
+    }
+    return this.db
+      .prepare(
+        `SELECT * FROM shared_docs WHERE status NOT IN ('revoked','expired')
+         ORDER BY created_at DESC LIMIT ?`,
+      )
+      .all(limit) as SharedDocRow[];
+  }
+  getSharedDoc(share_token: string): SharedDocRow | null {
+    const row = this.db
+      .prepare("SELECT * FROM shared_docs WHERE share_token = ?")
+      .get(share_token) as SharedDocRow | undefined;
+    return row ?? null;
+  }
+  updateSharedDocStatus(share_token: string, status: SharedDocStatus,
+                        extra?: { delivered_at?: number; revoked_at?: number; recipient_hint?: string }): boolean {
+    // Compose dynamic SET clause based on which extras are present.
+    const sets: string[] = ["status = ?"];
+    const params: any[] = [status];
+    if (extra?.delivered_at != null) { sets.push("delivered_at = ?"); params.push(extra.delivered_at); }
+    if (extra?.revoked_at != null) { sets.push("revoked_at = ?"); params.push(extra.revoked_at); }
+    if (extra?.recipient_hint != null) { sets.push("recipient_hint = ?"); params.push(extra.recipient_hint); }
+    params.push(share_token);
+    const r = this.db
+      .prepare(`UPDATE shared_docs SET ${sets.join(", ")} WHERE share_token = ?`)
+      .run(...params);
+    return r.changes > 0;
+  }
+  deleteSharedDoc(share_token: string): boolean {
+    const r = this.db.prepare("DELETE FROM shared_docs WHERE share_token = ?").run(share_token);
+    return r.changes > 0;
+  }
+  /** Auto-expire stale shares: waiting/disconnected older than ttl_ms. */
+  expireStaleShares(ttl_ms: number): number {
+    const cutoff = Date.now() - ttl_ms;
+    const r = this.db
+      .prepare(
+        `UPDATE shared_docs SET status = 'expired'
+         WHERE status IN ('waiting','disconnected','connecting') AND created_at < ?`,
+      )
+      .run(cutoff);
+    return r.changes;
+  }
+  countActiveShares(): number {
+    const row = this.db
+      .prepare(
+        `SELECT COUNT(*) AS n FROM shared_docs
+         WHERE status IN ('waiting','connecting','disconnected')`,
+      )
+      .get() as { n: number };
+    return row.n;
+  }
 }

package/sinain-memory/graph_query.py CHANGED Viewed

@@ -76,7 +76,7 @@ def query_facts_by_entities(
             attrs = store.entity(fid)
             if not attrs:
                 continue
-            fact = {"entityId": fid}
+            fact = {"entity_id": fid}
             for attr_name, values in attrs.items():
                 if attr_name == "tag":
                     continue  # Don't include tags in output (noise)
@@ -117,7 +117,7 @@ def query_top_facts(db_path: str, limit: int = 30) -> list[dict]:
             attrs = store.entity(fid)
             if not attrs:
                 continue
-            fact = {"entityId": fid}
+            fact = {"entity_id": fid}
             for attr_name, values in attrs.items():
                 fact[attr_name] = values[0] if len(values) == 1 else values
             facts.append(fact)
@@ -425,12 +425,14 @@ def query_facts_hybrid(
             pass
     # Graph boost: facts linked to mentioned entities via backrefs get priority
+    # +0.05 is significant vs RRF scores of ~0.015-0.033 — ensures entity-linked facts
+    # rank above FTS noise in large graphs (100K+ triples)
     if graph_fact_ids or community_fact_ids:
         for eid in rrf_scores:
             if eid in graph_fact_ids:
-                rrf_scores[eid] += 0.02  # direct graph-linked facts
+                rrf_scores[eid] += 0.05  # direct graph-linked facts
             elif eid in community_fact_ids:
-                rrf_scores[eid] += 0.01  # community-expanded facts (half weight)
+                rrf_scores[eid] += 0.025  # community-expanded facts (half weight)
     # Apply confidence decay as secondary signal (fresh facts rank above stale ones)
     from triplestore import decayed_confidence

package/sinain-memory/knowledge_integrator.py CHANGED Viewed

@@ -418,16 +418,33 @@ def _extract_entity_from_fact(fact_text: str, known_entities: list) -> str:
 def _facts_to_graph_ops(digest: dict) -> list[dict]:
-    """Convert distiller facts/entities/decisions directly to graph ops.
+    """Convert ALL distiller output + raw feed items to graph ops.
-    DETERMINISTIC — no LLM needed. The distiller already extracted structured
-    facts with entity names. This function mechanically converts them to
-    assert operations for the triplestore.
+    DETERMINISTIC — no LLM needed. Stores distilled knowledge (facts,
+    decisions, patterns, preferences, summary) AND verbatim raw captures
+    (audio quotes, agent analysis) so the triplestore is the single
+    source of truth for session recall.
     """
     ops = []
     known_entities = digest.get("entities", [])
+    raw_items = digest.pop("_rawItems", None) or []
-    # Each fact becomes an assert op
+    # Session anchor from whatHappened
+    session_ts = digest.get("ts", "")[:16]  # "2026-05-07T10:08"
+    session_eid = f"session:{session_ts}" if session_ts else None
+    if session_eid and digest.get("whatHappened"):
+        ops.append({
+            "op": "assert",
+            "entity": session_ts,
+            "attribute": "value",
+            "value": digest["whatHappened"],
+            "confidence": 0.9,
+            "domain": "session",
+            "kind": "distilled",
+            "session_ref": session_eid,
+        })
+    # Facts (distilled)
     for fact_text in digest.get("facts", []):
         if not fact_text or len(fact_text) < 5:
             continue
@@ -435,13 +452,14 @@ def _facts_to_graph_ops(digest: dict) -> list[dict]:
         ops.append({
             "op": "assert",
             "entity": entity,
-            "attribute": "fact",
+            "attribute": "value",
             "value": fact_text,
             "confidence": 0.9,
-            "domain": "",
+            "kind": "distilled",
+            "session_ref": session_eid,
         })
-    # Each decision becomes an assert with lower confidence (time-bound)
+    # Decisions (distilled, lower confidence — time-bound)
     for decision_text in digest.get("decisions", []):
         if not decision_text or len(decision_text) < 5:
             continue
@@ -449,10 +467,63 @@ def _facts_to_graph_ops(digest: dict) -> list[dict]:
         ops.append({
             "op": "assert",
             "entity": entity,
-            "attribute": "decision",
+            "attribute": "value",
             "value": decision_text,
             "confidence": 0.7,
-            "domain": "",
+            "kind": "distilled",
+            "session_ref": session_eid,
+        })
+    # Patterns + Preferences (distilled)
+    for text in digest.get("patterns", []) + digest.get("preferences", []):
+        if not text or not isinstance(text, str) or len(text) < 5:
+            continue
+        entity = _extract_entity_from_fact(text, known_entities)
+        ops.append({
+            "op": "assert",
+            "entity": entity,
+            "attribute": "value",
+            "value": text,
+            "confidence": 0.7,
+            "kind": "distilled",
+            "session_ref": session_eid,
+        })
+    # Verbatim audio quotes (top 20 by length, > 30 chars)
+    audio = [i for i in raw_items
+             if i.get("source") == "audio" and len(i.get("text", "")) > 30]
+    for item in sorted(audio, key=lambda x: -len(x.get("text", "")))[:20]:
+        text = re.sub(r"^\[.*?\]\s*", "", item["text"])  # strip emoji prefixes
+        if len(text) < 20:
+            continue
+        entity = _extract_entity_from_fact(text, known_entities)
+        ops.append({
+            "op": "assert",
+            "entity": entity,
+            "attribute": "value",
+            "value": text,
+            "confidence": 0.95,
+            "kind": "verbatim",
+            "session_ref": session_eid,
+        })
+    # Agent analysis responses (last 10, > 50 chars — verbatim)
+    agents = [i for i in raw_items
+              if i.get("source") in ("agent", "openclaw")
+              and len(i.get("text", "")) > 50]
+    for item in agents[-10:]:
+        text = re.sub(r"^\[.*?\]\s*", "", item["text"])  # strip emoji prefixes
+        if len(text) < 30:
+            continue
+        entity = _extract_entity_from_fact(text, known_entities)
+        ops.append({
+            "op": "assert",
+            "entity": entity,
+            "attribute": "value",
+            "value": text,
+            "confidence": 0.8,
+            "kind": "verbatim",
+            "session_ref": session_eid,
         })
     return ops
@@ -506,6 +577,12 @@ def _execute_graph_ops(db_path: str, ops: list[dict], digest_ts: str, digest_ent
                 store.assert_triple(tx, entity_id, "reinforce_count", "1")
                 if domain:
                     store.assert_triple(tx, entity_id, "domain", domain)
+                kind = op_data.get("kind", "distilled")
+                store.assert_triple(tx, entity_id, "kind", kind)
+                # Link to session anchor via ref edge
+                session_ref = op_data.get("session_ref")
+                if session_ref:
+                    store.assert_triple(tx, entity_id, "session", session_ref, value_type="ref")
                 # Auto-tag for keyword-based discovery
                 for tag in _extract_tags(value):
                     store.assert_triple(tx, entity_id, "tag", tag)