persnally 2.3.2 → 2.5.0

package/README.md

@@ -39,7 +39,7 @@ open http://127.0.0.1:4983            # see it, with evidence for every claim
 ## How it works
 
 ```
-  Your AI clients (Claude, Cursor, agents…)        Importers (claude · chatgpt · git)
+  Your AI clients (Claude, Cursor, agents…)   Importers (claude · claude-code · chatgpt · git)
         │  MCP: context out, signals in                  │  your history → events
         ▼                                                ▼
   ┌──────────────────────── persnallyd (local daemon) ────────────────────────┐

package/build/src/cli.js

@@ -18,6 +18,7 @@ import { extractChatGPTEvents, parseChatGPTExport } from "./importers/chatgpt.js
 import { extractClaudeEvents, parseClaudeExport } from "./importers/claude.js";
 import { DEFAULT_TRANSCRIPTS_DIR, extractClaudeCodeEvents, parseClaudeCodeTranscripts, } from "./importers/claude-code.js";
 import { gitEvents, scanRepos } from "./importers/git.js";
+import { freshConversations } from "./importers/extract.js";
 import { autostartInstalled, installAutostart, LOG_FILE, removeAutostart, removePidFile, runningPid, startDetached, stopDaemon, writePidFile, } from "./lifecycle.js";
 import { newEvent } from "./events.js";
 import { proseLines } from "./prose.js";
@@ -46,6 +47,7 @@ Usage:
   persnallyd forget --all           Delete all data
   persnallyd forget --batch <id>    Undo one import batch
   persnallyd status                 Store stats and daemon health
+  persnallyd activity               Context-read engagement over time (retention pulse)
   persnallyd start [--port N]       Start the daemon in the background
   persnallyd stop                   Stop the background daemon
   persnallyd serve [--port N]       Run the daemon in the foreground (127.0.0.1:${DEFAULT_PORT})
@@ -249,44 +251,77 @@ async function main() {
             const usage = "usage: persnallyd import claude|claude-code|chatgpt|git <path>";
             if (!kind)
                 return die(usage);
-            let events, batch;
-            if (kind === "claude-code") {
-                const engine = await chooseExtractor("extract");
-                const root = path ?? DEFAULT_TRANSCRIPTS_DIR;
-                const { parsed, sessionsFound, sessionsDropped } = parseClaudeCodeTranscripts(root);
-                if (!parsed.conversations.length)
-                    return die(`No usable sessions found at ${root}`);
-                console.error(`Found ${sessionsFound} session(s)${sessionsDropped ? ` — importing the ${parsed.conversations.length} most recent` : ""}. ` +
-                    `Extracting with ${engine.label}...`);
-                ({ events, batch } = await extractClaudeCodeEvents(parsed, engine.extract, engine.model, root));
-            }
-            else if (!path) {
-                return die(usage);
-            }
-            else if (kind === "git") {
+            // Git: offline, deterministic. Dedup by repo so a re-run never doubles the graph.
+            if (kind === "git") {
+                if (!path)
+                    return die(usage);
                 const authorIdx = args.indexOf("--author");
                 const summaries = scanRepos(path, authorIdx > -1 ? args[authorIdx + 1] : undefined);
                 if (!summaries.length)
                     return die(`No git repos with your commits found at ${path}`);
-                console.error(`Found ${summaries.length} repo(s): ${summaries.map((s) => `${s.repo} (${s.commits} commits)`).join(", ")}`);
-                ({ events, batch } = gitEvents(summaries));
+                const store = new EventStore();
+                const seen = store.importedGitRepos();
+                const fresh = summaries.filter((s) => !seen.has(s.repo));
+                const skipped = summaries.length - fresh.length;
+                if (!fresh.length) {
+                    store.close();
+                    console.log(`All ${summaries.length} repo(s) already imported — nothing new.`);
+                    return;
+                }
+                console.error(`Found ${summaries.length} repo(s)${skipped ? ` (${skipped} already imported)` : ""} — importing ${fresh.map((s) => `${s.repo} (${s.commits} commits)`).join(", ")}`);
+                const { events, batch } = gitEvents(fresh);
+                store.append(events);
+                store.rebuild();
+                store.close();
+                console.log(`Imported ${events.length} events from ${fresh.length} repo(s) (batch ${batch}).`);
+                console.log(`Undo with: persnallyd forget --batch ${batch}`);
+                return;
             }
-            else if (kind === "claude" || kind === "chatgpt") {
-                const engine = await chooseExtractor("extract");
-                const parsed = kind === "claude" ? parseClaudeExport(path) : parseChatGPTExport(path);
-                console.error(`Parsed ${parsed.conversations.length} conversations. Extracting with ${engine.label}...`);
-                ({ events, batch } = kind === "claude"
-                    ? await extractClaudeEvents(parsed, engine.extract, engine.model)
-                    : await extractChatGPTEvents(parsed, engine.extract, engine.model));
+            // Conversation imports: dedup by conversation_uuid so re-import only adds new chats.
+            let parsed;
+            let file = "conversations.json";
+            let parseNote = "";
+            if (kind === "claude-code") {
+                const root = path ?? DEFAULT_TRANSCRIPTS_DIR;
+                file = root;
+                const r = parseClaudeCodeTranscripts(root);
+                if (!r.parsed.conversations.length)
+                    return die(`No usable sessions found at ${root}`);
+                parsed = r.parsed;
+                if (r.sessionsDropped)
+                    parseNote = ` (most recent ${r.parsed.conversations.length} of ${r.sessionsFound})`;
+            }
+            else if (kind === "claude") {
+                if (!path)
+                    return die(usage);
+                parsed = parseClaudeExport(path);
+            }
+            else if (kind === "chatgpt") {
+                if (!path)
+                    return die(usage);
+                parsed = parseChatGPTExport(path);
             }
             else {
                 return die(`unknown import source "${kind}" — use claude, claude-code, chatgpt, or git`);
             }
             const store = new EventStore();
+            const seen = store.importedConversationUuids(`import:${kind}`);
+            const { parsed: toExtract, skipped, firstImport } = freshConversations(parsed, seen);
+            if (!toExtract.conversations.length && !firstImport) {
+                store.close();
+                console.log(`Already up to date — all ${parsed.conversations.length} conversation(s) imported. Nothing new.`);
+                return;
+            }
+            const engine = await chooseExtractor("extract");
+            console.error(`Parsed ${parsed.conversations.length} conversation(s)${parseNote}${skipped ? ` — ${skipped} already imported` : ""}. ` +
+                `Extracting ${toExtract.conversations.length} with ${engine.label}...`);
+            const { events, batch } = await (kind === "claude-code" ? extractClaudeCodeEvents(toExtract, engine.extract, engine.model, file)
+                : kind === "claude" ? extractClaudeEvents(toExtract, engine.extract, engine.model)
+                    : extractChatGPTEvents(toExtract, engine.extract, engine.model));
             store.append(events);
             store.rebuild();
             store.close();
-            console.log(`Imported ${events.length} events (batch ${batch}).`);
+            console.log(`Imported ${events.length} events from ${toExtract.conversations.length} conversation(s) (batch ${batch}).`);
             console.log(`Undo with: persnallyd forget --batch ${batch}`);
             return;
         }
@@ -428,6 +463,22 @@ async function main() {
             console.log(`Autostart: ${autostartInstalled() ? "installed" : "not installed"}`);
             return;
         }
+        case "activity": {
+            const store = new EventStore();
+            const a = store.activity();
+            store.close();
+            if (!a.firstEventAt) {
+                console.log("No activity yet — run an import or connect a client.");
+                return;
+            }
+            const verdict = a.retainedWeek2 === null ? `in progress (day ${a.daysSinceFirst}/14)` : a.retainedWeek2 ? "active ✓" : "inactive ✗";
+            console.log(`Onboarded ${a.daysSinceFirst}d ago · ${a.totalReads} context read(s) total`);
+            console.log(`Reads: ${a.reads7d} this week · ${a.reads30d} this month`);
+            console.log(`Active: ${a.activeDays7d}/7 days · ${a.activeDays14d}/14 days`);
+            console.log(`Week-2 retention: ${verdict}`);
+            console.log(`Last 14 days: ${sparkline(a.daily.map((d) => d.reads))}`);
+            return;
+        }
         case "start": {
             const existing = runningPid();
             if (existing)
@@ -493,6 +544,11 @@ async function main() {
             process.exitCode = cmd ? 1 : 0;
     }
 }
+function sparkline(values) {
+    const blocks = "▁▂▃▄▅▆▇█";
+    const max = Math.max(...values, 1);
+    return values.map((v) => (v === 0 ? "·" : blocks[Math.min(blocks.length - 1, Math.floor((v / max) * (blocks.length - 1)))])).join("");
+}
 function summarize(payload) {
     const s = JSON.stringify(payload);
     return s.length > 80 ? s.slice(0, 77) + "..." : s;

package/build/src/daemon.js

@@ -41,6 +41,9 @@ export function startDaemon(store, port = DEFAULT_PORT) {
             if (req.method === "GET" && url.pathname === "/stats") {
                 return json(res, 200, store.stats());
             }
+            if (req.method === "GET" && url.pathname === "/activity") {
+                return json(res, 200, store.activity());
+            }
             if (req.method === "GET" && url.pathname === "/topics") {
                 const client = url.searchParams.get("client");
                 const allowed = client ? allowedCategories(client) : null;

package/build/src/dashboard.html

@@ -109,7 +109,7 @@
   /* ── constellation ── */
   .constellation-wrap { position: relative; }
   .constellation { background: var(--panel); border: 1px solid var(--line); border-radius: var(--r); overflow: hidden; }
-  #graph { display: block; width: 100%; height: 520px; cursor: grab; }
+  #graph { display: block; width: 100%; height: 520px; cursor: grab; touch-action: none; }
   #graph:active { cursor: grabbing; }
   .ghint { position: absolute; top: 12px; right: 14px; font-size: 11px; color: var(--faint); pointer-events: none; }
   .legend { position: absolute; bottom: 12px; left: 14px; display: flex; gap: 14px; flex-wrap: wrap; font-size: 11px; color: var(--dim); pointer-events: none; }
@@ -153,6 +153,11 @@
   .read .what .l1 b { color: var(--text); } .read .what .l1 .p { color: var(--dim); }
   .read .what .l2 { font-size: 11px; color: var(--faint); margin-top: 2px; }
   .read .when { font-size: 11.5px; color: var(--dim); white-space: nowrap; }
+  .engage { display: flex; align-items: center; gap: 16px; flex-wrap: wrap; font-size: 12.5px; color: var(--dim); margin: 0 0 16px; }
+  .engage b { color: var(--text); font-weight: 600; }
+  .engage .spark { display: inline-flex; align-items: flex-end; gap: 2px; height: 22px; }
+  .engage .spark i { width: 6px; min-height: 2px; border-radius: 1px; display: inline-block; }
+  .engage .rk { color: var(--faint); }
 
   /* ── reflection ── */
   .refl { border-left: 2px solid var(--line-2); padding: 4px 0 4px 16px; margin-bottom: 16px; }
@@ -173,6 +178,17 @@
   .preview-ribbon code { color: var(--text); }
   a { color: var(--text); }
   :focus-visible { outline: 2px solid #FFFFFF; outline-offset: 3px; border-radius: 4px; }
+  @media (max-width: 640px) {
+    .wrap { padding: 18px 16px 96px; }
+    #graph { height: 380px; }
+    .archetype { font-size: clamp(22px, 7vw, 30px); }
+    header { margin-bottom: 24px; }
+    .value-num { font-size: 32px; }
+    #topicList { overflow-x: auto; }   /* wide table scrolls inside its card — body never does */
+    .bar-track { width: 64px; }
+    td { padding: 8px 6px; font-size: 13px; }
+    .del { padding: 3px 7px; }
+  }
   @media (prefers-reduced-motion: reduce) { .reveal { animation: none; opacity: 1; transform: none; } .read.fresh { animation: none; } }
 </style>
 </head>
@@ -215,7 +231,7 @@
       <div class="view-toggle"><button id="vGraph" class="on">map</button><button id="vList">list</button></div>
     </div>
     <div class="constellation-wrap">
-      <div class="constellation" id="graphHost"><canvas id="graph"></canvas><div class="legend" id="legend"></div><div class="ghint">drag · scroll to zoom · dbl-click resets</div></div>
+      <div class="constellation" id="graphHost"><canvas id="graph"></canvas><div class="legend" id="legend"></div><div class="ghint">drag · pinch or scroll to zoom</div></div>
       <div class="card" id="topicList" style="display:none;padding:6px 14px"><table id="topics"></table></div>
       <div class="node-pop" id="nodePop"></div>
     </div>
@@ -227,6 +243,7 @@
       <div class="value-num num" id="valueNum">0</div>
       <div class="value-cap" id="valueCap"></div>
     </div>
+    <div class="engage" id="engage"></div>
     <div class="card" id="reads" style="padding:6px 16px"></div>
   </section>
 
@@ -276,6 +293,20 @@ function clientOf(ev) {
 }
 const prettyClient = (c) => ({ "claude-code":"Claude Code","claude-desktop":"Claude Desktop","cursor":"Cursor","cli":"CLI" }[c] || c);
 const clientInitials = (c) => prettyClient(c).split(/[\s-]/).map(w=>w[0]).join("").slice(0,2).toUpperCase();
+const IMPORT_TOOL = { "import:claude":"Claude export", "import:chatgpt":"ChatGPT export", "import:claude-code":"Claude Code" };
+// Human-readable provenance for the "why?" panel — where a fact actually came from.
+function provLabel(e) {
+  const p = e.provenance || {};
+  if (p.kind === "import") {
+    const base = IMPORT_TOOL[e.source] || p.file || "import";
+    return p.conversation_uuid ? `${base} · conversation ${String(p.conversation_uuid).slice(0,8)}` : base;
+  }
+  if (p.kind === "mcp") return `${prettyClient(p.client)}${p.session ? " · session " + String(p.session).slice(0,8) : ""} · live`;
+  if (p.kind === "git") return `git: ${p.repo}${p.ref ? " @ " + p.ref : ""}`;
+  if (p.kind === "derived") return `inferred from ${(p.from||[]).length} signal${(p.from||[]).length===1?"":"s"}`;
+  if (p.kind === "local") return `you · ${p.surface || "local"}`;
+  return p.kind || "local";
+}
 
 const SNAP_KEY = "persnally.snapshot.v1";
 let DEMO = false;
@@ -344,8 +375,7 @@ async function toggleEvidence(btn) {
   box.innerHTML = events.map(e => {
     const p = e.payload || {};
     const summary = e.type === "signal.topic" ? `${p.topic} (${p.intent})` : (p.claim ?? p.topic ?? JSON.stringify(p).slice(0,90));
-    const origin = e.provenance && e.provenance.kind === "import" ? `${(e.provenance.file||"import")}` : (e.provenance ? e.provenance.kind : "local");
-    return `<div class="ev-item"><code>${esc(e.type)}</code> ${esc(summary)} — <i>${esc(origin)}, ${esc((e.ts||"").slice(0,10))}</i></div>`;
+    return `<div class="ev-item"><code>${esc(e.type)}</code> ${esc(summary)} — <i>${esc(provLabel(e))}, ${esc((e.ts||"").slice(0,10))}</i></div>`;
   }).join("") || `<div class="ev-item">evidence not found (deleted?)</div>`;
   box.dataset.loaded = "1";
 }
@@ -393,6 +423,22 @@ function renderReads(reads, total) {
   }).join("");
 }
 
+/* ── engagement (retention pulse) ── */
+function renderEngage(a) {
+  const el = $("engage");
+  if (!a || !a.firstEventAt || !a.daily) { el.innerHTML = ""; return; }
+  const max = Math.max(...a.daily.map((d) => d.reads), 1);
+  const bars = a.daily.map((d, i) => {
+    const today = i === a.daily.length - 1;
+    const h = d.reads ? Math.max(3, Math.round((d.reads / max) * 22)) : 2;
+    const c = d.reads ? (today ? "var(--text)" : "var(--dim)") : "var(--line-2)";
+    return `<i style="height:${h}px;background:${c}" title="${esc(d.date)}: ${d.reads}"></i>`;
+  }).join("");
+  const ret = a.retainedWeek2 === null ? `day ${a.daysSinceFirst}/14` : (a.retainedWeek2 ? "active ✓" : "inactive ✗");
+  el.innerHTML = `<span><b>${a.reads7d}</b> this week</span><span>active <b>${a.activeDays14d}</b> of last 14 days</span>` +
+    `<span class="spark" title="context reads, last 14 days">${bars}</span><span class="rk">week-2: ${esc(ret)}</span>`;
+}
+
 /* ── reflections ── */
 function renderReflections(assertions) {
   const behav = assertions.filter(a => a.payload && (a.payload.kind==="behavior" || a.payload.kind==="preference"));
@@ -436,7 +482,7 @@ function renderMap(topics) {
   const ctx = canvas.getContext("2d");
   const dpr = Math.min(devicePixelRatio || 1, 2);
   let w, h;
-  const resize = () => { w = host.clientWidth; h = 520; canvas.width = w*dpr; canvas.height = h*dpr; canvas.style.height = h+"px"; };
+  const resize = () => { w = host.clientWidth; h = window.innerWidth < 640 ? 380 : 520; canvas.width = w*dpr; canvas.height = h*dpr; canvas.style.height = h+"px"; };
   resize();
 
   const maxW = Math.max(...data.map(t=>t.weight), 0.01);
@@ -510,24 +556,55 @@ function renderMap(topics) {
   $("legend").innerHTML = cats.map(c => `<span><i style="color:${catColor(c)}"></i><span style="color:var(--dim)">${esc(c)}</span></span>`).join("");
 
   const pop=$("nodePop");
-  const nodeAt=(mx,my)=>{ const wx=S2Wx(mx),wy=S2Wy(my); for (let i=nodes.length-1;i>=0;i--) if (Math.hypot(wx-nodes[i].x,wy-nodes[i].y)<=nodes[i].r+5/cam.k) return i; return -1; };
+  const nodeAt=(mx,my)=>{ const wx=S2Wx(mx),wy=S2Wy(my); for (let i=nodes.length-1;i>=0;i--) if (Math.hypot(wx-nodes[i].x,wy-nodes[i].y)<=nodes[i].r+8/cam.k) return i; return -1; };
   const rel=(e)=>{ const r=canvas.getBoundingClientRect(); return [e.clientX-r.left, e.clientY-r.top]; };
-  canvas.onmousedown=(e)=>{ const [mx,my]=rel(e); const n=nodeAt(mx,my); if (n>=0) dragNode=n; else panning=true; lastX=mx; lastY=my; };
-  const onMove=(e)=>{ const [mx,my]=rel(e);
+  function showPop(n) { const p=nodes[n].t;
+    pop.innerHTML=`<div class="npt">${esc(p.topic)}</div><div class="npm">${esc(p.category)} · ${esc(p.dominant_intent)} · weight ${p.weight.toFixed(2)} · ${p.signals}×</div>${(p.entities||[]).length?`<div class="npe">${esc(p.entities.slice(0,4).join(", "))}</div>`:""}`;
+    pop.style.left=Math.min(W2Sx(nodes[n].x)+14,w-250)+"px"; pop.style.top=(W2Sy(nodes[n].y)+14)+"px"; pop.classList.add("show"); }
+
+  // Pointer events unify mouse + touch + pen; a second pointer drives pinch-zoom, a tap inspects.
+  const pts=new Map();
+  let downX=0, downY=0, moved=false, pinchD=0, pinchX=0, pinchY=0;
+  canvas.onpointerdown=(e)=>{
+    const [mx,my]=rel(e); pts.set(e.pointerId,{x:mx,y:my});
+    try { canvas.setPointerCapture(e.pointerId); } catch { /* capture unsupported — degrade to no-capture */ }
+    if (pts.size>=2) { dragNode=-1; panning=false; pop.classList.remove("show"); hover=-1;
+      const [a,b]=[...pts.values()]; pinchD=Math.hypot(a.x-b.x,a.y-b.y)||1; pinchX=(a.x+b.x)/2; pinchY=(a.y+b.y)/2; return; }
+    downX=mx; downY=my; moved=false; lastX=mx; lastY=my;
+    const n=nodeAt(mx,my); if (n>=0) dragNode=n; else panning=true;
+  };
+  canvas.onpointermove=(e)=>{
+    const [mx,my]=rel(e); if (pts.has(e.pointerId)) pts.set(e.pointerId,{x:mx,y:my});
+    if (pts.size>=2) { const [a,b]=[...pts.values()];
+      const d=Math.hypot(a.x-b.x,a.y-b.y)||1, cx=(a.x+b.x)/2, cy=(a.y+b.y)/2, wx=S2Wx(cx), wy=S2Wy(cy);
+      cam.k=Math.max(0.45,Math.min(3,cam.k*(d/pinchD)));
+      cam.x=cx-wx*cam.k+(cx-pinchX); cam.y=cy-wy*cam.k+(cy-pinchY);
+      pinchD=d; pinchX=cx; pinchY=cy; if(!alive)draw(); return; }
+    if ((dragNode>=0||panning) && (Math.abs(mx-downX)>4||Math.abs(my-downY)>4)) moved=true;
     if (dragNode>=0) { nodes[dragNode].x=S2Wx(mx); nodes[dragNode].y=S2Wy(my); nodes[dragNode].vx=0; nodes[dragNode].vy=0; pop.classList.remove("show"); wake(); if(!alive)draw(); return; }
     if (panning) { cam.x+=mx-lastX; cam.y+=my-lastY; lastX=mx; lastY=my; if(!alive)draw(); return; }
+    if (e.pointerType==="touch") return;  // no hover on touch — a tap inspects instead
     if (mx<0||my<0||mx>w||my>h) { if (hover!==-1){hover=-1;pop.classList.remove("show");if(!alive)draw();} return; }
     const n=nodeAt(mx,my);
-    if (n!==hover) { hover=n; if(!alive)draw();
-      if (n>=0) { const p=nodes[n].t; pop.innerHTML=`<div class="npt">${esc(p.topic)}</div><div class="npm">${esc(p.category)} · ${esc(p.dominant_intent)} · weight ${p.weight.toFixed(2)} · ${p.signals}×</div>${(p.entities||[]).length?`<div class="npe">${esc(p.entities.slice(0,4).join(", "))}</div>`:""}`;
-        pop.style.left=Math.min(W2Sx(nodes[n].x)+14,w-250)+"px"; pop.style.top=(W2Sy(nodes[n].y)+14)+"px"; pop.classList.add("show"); }
-      else pop.classList.remove("show"); } };
-  const onUp=()=>{ if (dragNode>=0){ dragNode=-1; wake(); } panning=false; };
+    if (n!==hover) { hover=n; if(!alive)draw(); if (n>=0) showPop(n); else pop.classList.remove("show"); }
+  };
+  const endPointer=(e)=>{
+    const tapped = (!moved && pts.size<=1 && e.pointerType==="touch") ? nodeAt(...rel(e)) : -1;
+    pts.delete(e.pointerId);
+    if (dragNode>=0) { dragNode=-1; wake(); }
+    panning=false;
+    if (tapped>=0) { if (hover===tapped && pop.classList.contains("show")) { hover=-1; pop.classList.remove("show"); } else { hover=tapped; showPop(tapped); } if(!alive)draw(); }
+    else if (!moved && e.pointerType==="touch") { hover=-1; pop.classList.remove("show"); if(!alive)draw(); }
+    if (pts.size===1) { const [p]=[...pts.values()]; lastX=p.x; lastY=p.y; panning=true; moved=true; }  // pinch → one finger: resume pan
+  };
+  canvas.onpointerup=endPointer; canvas.onpointercancel=endPointer;
   canvas.onwheel=(e)=>{ e.preventDefault(); const [mx,my]=rel(e); const wx=S2Wx(mx),wy=S2Wy(my); const f=e.deltaY<0?1.12:1/1.12; cam.k=Math.max(0.45,Math.min(3,cam.k*f)); cam.x=mx-wx*cam.k; cam.y=my-wy*cam.k; if(!alive)draw(); };
   canvas.ondblclick=()=>{ cam.k=1; cam.x=0; cam.y=0; if(!alive)draw(); };
   let rt; const onWinResize=()=>{ clearTimeout(rt); rt=setTimeout(()=>{ resize(); if(!alive)draw(); },150); };
-  window.addEventListener("mousemove", onMove); window.addEventListener("mouseup", onUp); window.addEventListener("resize", onWinResize, { passive:true });
-  mapCleanup=()=>{ window.removeEventListener("mousemove",onMove); window.removeEventListener("mouseup",onUp); window.removeEventListener("resize",onWinResize); };
+  window.addEventListener("resize", onWinResize, { passive:true });
+  mapCleanup=()=>{ window.removeEventListener("resize",onWinResize); };
+
+  if (window.innerWidth < 640) switchView("list");  // phones land on the list; the map is one tap away
 }
 function switchView(v) {
   const g = v==="graph" || v==="map";
@@ -539,21 +616,22 @@ $("vList").onclick = () => switchView("list");
 
 /* ── load ── */
 async function loadAll() {
-  let stats, profile, topics, reads, assertions, voice;
+  let stats, profile, topics, reads, assertions, voice, activity;
   try {
-    [stats, profile, topics, reads, assertions, voice] = await Promise.all([
+    [stats, profile, topics, reads, assertions, voice, activity] = await Promise.all([
       get("/stats"), get("/profile"), get("/topics?limit=40"),
-      get("/events?type=context.read&limit=60"), get("/events?type=signal.assertion&limit=20"), get("/voice"),
+      get("/events?type=context.read&limit=60"), get("/events?type=signal.assertion&limit=20"), get("/voice"), get("/activity"),
     ]);
     if (!stats) throw new Error("no daemon");
   } catch (e) {
     DEMO = true; $("ribbon").classList.add("show");
-    ({ stats, profile, topics, reads, assertions, voice } = DEMO_DATA());
+    ({ stats, profile, topics, reads, assertions, voice, activity } = DEMO_DATA());
   }
   topics = topics||[]; reads = reads||[]; assertions = assertions||[];
   const st = $("status");
   st.querySelector(".dot").classList.toggle("off", DEMO);
   st.querySelector(".lbl").textContent = DEMO ? "preview" : "active";
+  if (!DEMO) get("/health").then(h => { if (h && h.version) $("ver").textContent = `· v${h.version}`; });
   const total = (stats.byType && stats.byType["context.read"]) || reads.length;
   renderDelta(topics, reads, assertions);
   renderScaleBeat(stats);
@@ -562,6 +640,7 @@ async function loadAll() {
   renderTopicList(topics);
   renderMap(topics);
   renderReads(reads, total);
+  renderEngage(activity);
   renderReflections(assertions);
   saveSnapshot(topics);
 }
@@ -579,9 +658,10 @@ $("reflect").onclick = async () => {
 };
 setInterval(async () => {
   if (DEMO) return;
-  const [reads, stats, voice] = await Promise.all([get("/events?type=context.read&limit=60"), get("/stats"), get("/voice")]);
+  const [reads, stats, voice, activity] = await Promise.all([get("/events?type=context.read&limit=60"), get("/stats"), get("/voice"), get("/activity")]);
   if (reads && stats) renderReads(reads, (stats.byType && stats.byType["context.read"]) || reads.length);
   if (voice) renderVoice(voice); // live: voice signals captured mid-session show up without a reload
+  if (activity) renderEngage(activity);
 }, 25000);
 
 loadAll();
@@ -627,6 +707,7 @@ function DEMO_DATA() {
       { ts:iso(86400000*2), payload:{ claim:"You consistently choose local-first, auditable tools over cloud convenience.", kind:"preference", confidence:0.86 }, provenance:{ kind:"derived" } },
       { ts:iso(86400000*6), payload:{ claim:"You generate new ideas fastest right when your main bet stalls.", kind:"behavior", confidence:0.71 }, provenance:{ kind:"derived" } },
     ],
+    activity: { firstEventAt: iso(86400000*214), lastReadAt: iso(3600000*2), daysSinceFirst: 214, totalReads: 1247, reads7d: 33, reads30d: 142, activeDays7d: 5, activeDays14d: 12, retainedWeek2: true, daily: [2,0,3,5,1,4,6,2,0,3,7,5,8,4].map((r,i)=>({ date:new Date(now-(13-i)*86400000).toISOString().slice(0,10), reads:r })) },
     voice: {
       pack: "Write like this user: terse — short, declarative sentences; leads with imperatives, minimal preamble; states things flatly; no emoji; casual register (lowercases “i”); recurring phrasing: “be 100% sure”, “industry best practices”, “validate whether it's valid or not”.",
       items: [

package/build/src/importers/chatgpt.js

@@ -3,16 +3,16 @@
  * conversation as a node tree ("mapping"); user text lives in author.role
  * === "user" nodes with content.parts. Multimodal parts are skipped.
  */
-import { readFileSync, existsSync, statSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { safeIso } from "../events.js";
 import { anthropicExtract, DEFAULT_EXTRACT_MODEL } from "../llm.js";
-import { extractEvents } from "./extract.js";
+import { extractEvents, readImportFile } from "./extract.js";
 export function parseChatGPTExport(path) {
     const file = statSync(path).isDirectory() ? join(path, "conversations.json") : path;
     if (!existsSync(file))
         throw new Error(`No conversations.json at ${path}`);
-    const raw = JSON.parse(readFileSync(file, "utf-8"));
+    const raw = JSON.parse(readImportFile(file));
     const conversations = raw.map((c) => {
         const nodes = Object.values(c.mapping ?? {})
             .filter((n) => n.message?.author?.role === "user")

package/build/src/importers/claude-code.js

@@ -108,7 +108,7 @@ export async function importNewClaudeCodeSessions(store, extract, model = DEFAUL
     if (!existsSync(root))
         return { newSessions: 0, events: 0, skipped: 0 };
     const { parsed } = parseClaudeCodeTranscripts(root);
-    const seen = importedConversationUuids(store);
+    const seen = store.importedConversationUuids("import:claude-code");
     const fresh = parsed.conversations.filter((c) => !seen.has(c.uuid));
     const skipped = parsed.conversations.length - fresh.length;
     if (!fresh.length)
@@ -117,12 +117,3 @@ export async function importNewClaudeCodeSessions(store, extract, model = DEFAUL
     store.append(events);
     return { newSessions: fresh.length, events: events.length, skipped };
 }
-function importedConversationUuids(store) {
-    const uuids = new Set();
-    for (const e of store.query({ source: "import:claude-code", limit: 1_000_000 })) {
-        const uuid = e.provenance.conversation_uuid;
-        if (uuid)
-            uuids.add(uuid);
-    }
-    return uuids;
-}

package/build/src/importers/claude.js

@@ -5,12 +5,12 @@
 import { readFileSync, existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { anthropicExtract, DEFAULT_EXTRACT_MODEL } from "../llm.js";
-import { extractEvents } from "./extract.js";
+import { extractEvents, readImportFile } from "./extract.js";
 export function parseClaudeExport(dir) {
     const convPath = join(dir, "conversations.json");
     if (!existsSync(convPath))
         throw new Error(`No conversations.json in ${dir}`);
-    const raw = JSON.parse(readFileSync(convPath, "utf-8"));
+    const raw = JSON.parse(readImportFile(convPath));
     const conversations = raw.map((c) => ({
         uuid: String(c.uuid ?? ""),
         name: String(c.name ?? ""),

package/build/src/importers/extract.d.ts

@@ -4,6 +4,8 @@
  */
 import { type PersnallyEvent } from "../events.js";
 import { type LlmExtract } from "../llm.js";
+/** Reads an export file, refusing oversized ones with a clear message instead of an opaque OOM/crash. */
+export declare function readImportFile(path: string, maxBytes?: number): string;
 export interface ParsedConversation {
     uuid: string;
     name: string;
@@ -24,6 +26,17 @@ export interface ImportResult {
     batch: string;
     conversationsProcessed: number;
 }
+/**
+ * Filters a parsed export to the conversations not already imported (matched by
+ * uuid), so a re-import only adds new chats instead of doubling the graph. The
+ * one-time memory/projects snapshot carries no per-conversation id, so it's kept
+ * only on the first import of a source.
+ */
+export declare function freshConversations(parsed: ParsedExport, seen: Set<string>): {
+    parsed: ParsedExport;
+    skipped: number;
+    firstImport: boolean;
+};
 export declare function extractEvents(parsed: ParsedExport, opts: {
     source: string;
     importer: string;

package/build/src/importers/extract.js

@@ -2,12 +2,38 @@
  * Shared extraction pipeline for conversation-export importers.
  * Parsers produce a ParsedExport; this turns it into provenance-linked events.
  */
+import { readFileSync, statSync } from "node:fs";
 import { z } from "zod";
 import { newEvent, safeIso, uuidv7, PAYLOAD_SCHEMAS } from "../events.js";
 import { anthropicExtract, DEFAULT_EXTRACT_MODEL } from "../llm.js";
 import { proseLines, stripNoise } from "../prose.js";
 import { analyzeVoice } from "../stylometry.js";
 const MAX_CONVO_CHARS = 30_000;
+const MAX_IMPORT_FILE_BYTES = 400 * 1024 * 1024; // ~400 MB — under Node's ~512 MB string cap; larger needs streaming
+/** Reads an export file, refusing oversized ones with a clear message instead of an opaque OOM/crash. */
+export function readImportFile(path, maxBytes = MAX_IMPORT_FILE_BYTES) {
+    const { size } = statSync(path);
+    if (size > maxBytes) {
+        throw new Error(`${path} is ${Math.round(size / 1e6)} MB, over the ${Math.round(maxBytes / 1e6)} MB import limit. ` +
+            `Very large exports aren't supported yet — import a smaller export or split conversations.json.`);
+    }
+    return readFileSync(path, "utf-8");
+}
+/**
+ * Filters a parsed export to the conversations not already imported (matched by
+ * uuid), so a re-import only adds new chats instead of doubling the graph. The
+ * one-time memory/projects snapshot carries no per-conversation id, so it's kept
+ * only on the first import of a source.
+ */
+export function freshConversations(parsed, seen) {
+    const firstImport = seen.size === 0;
+    const conversations = parsed.conversations.filter((c) => !c.uuid || !seen.has(c.uuid));
+    const skipped = parsed.conversations.length - conversations.length;
+    const next = firstImport
+        ? { ...parsed, conversations }
+        : { ...parsed, conversations, memoryText: "", projects: [] };
+    return { parsed: next, skipped, firstImport };
+}
 const topicsExtraction = z.object({ topics: z.array(PAYLOAD_SCHEMAS["signal.topic"]) });
 const assertionsExtraction = z.object({ assertions: z.array(PAYLOAD_SCHEMAS["signal.assertion"]) });
 export async function extractEvents(parsed, opts, extract = anthropicExtract, model = DEFAULT_EXTRACT_MODEL) {

package/build/src/store.d.ts

@@ -35,6 +35,21 @@ export interface StoredProfile {
     generated_at: string;
     model: string;
 }
+export interface Activity {
+    firstEventAt: string | null;
+    lastReadAt: string | null;
+    daysSinceFirst: number;
+    totalReads: number;
+    reads7d: number;
+    reads30d: number;
+    activeDays7d: number;
+    activeDays14d: number;
+    retainedWeek2: boolean | null;
+    daily: {
+        date: string;
+        reads: number;
+    }[];
+}
 export declare class EventStore {
     private db;
     constructor(path?: string);
@@ -42,6 +57,10 @@ export declare class EventStore {
     append(events: PersnallyEvent[]): number;
     query(opts?: QueryOpts): PersnallyEvent[];
     getEvents(ids: string[]): PersnallyEvent[];
+    /** conversation_uuids already imported from a source — lets a re-import top up only new chats, never double. */
+    importedConversationUuids(source: string): Set<string>;
+    /** repo names already imported via `import git` — lets a re-import skip repos already on file. */
+    importedGitRepos(): Set<string>;
     stats(): {
         total: number;
         byType: Record<string, number>;
@@ -49,6 +68,12 @@ export declare class EventStore {
         first: string | null;
         last: string | null;
     };
+    /**
+     * Engagement over time from context.read events — the retention pulse.
+     * Local/per-install only (this machine); aggregate cohort retention would
+     * require opt-in telemetry. `now` is injectable for deterministic tests.
+     */
+    activity(now?: number): Activity;
     topics(limit?: number): TopicRow[];
     /** Re-derive view_topics from signal.topic events using decayed per-signal weighting. */
     rebuild(now?: number): void;

package/build/src/store.js

@@ -123,6 +123,26 @@ export class EventStore {
             .all(...ids)
             .map(rowToEvent);
     }
+    /** conversation_uuids already imported from a source — lets a re-import top up only new chats, never double. */
+    importedConversationUuids(source) {
+        const uuids = new Set();
+        for (const e of this.query({ source, limit: 1_000_000 })) {
+            const uuid = e.provenance.conversation_uuid;
+            if (uuid)
+                uuids.add(uuid);
+        }
+        return uuids;
+    }
+    /** repo names already imported via `import git` — lets a re-import skip repos already on file. */
+    importedGitRepos() {
+        const repos = new Set();
+        for (const e of this.query({ source: "import:git", limit: 1_000_000 })) {
+            const repo = e.provenance.repo;
+            if (repo)
+                repos.add(repo);
+        }
+        return repos;
+    }
     stats() {
         const total = this.db.prepare("SELECT COUNT(*) n FROM events").get().n;
         const group = (col) => Object.fromEntries(this.db.prepare(`SELECT ${col} k, COUNT(*) n FROM events GROUP BY ${col}`).all()
@@ -130,6 +150,53 @@ export class EventStore {
         const span = this.db.prepare("SELECT MIN(ts) first, MAX(ts) last FROM events").get();
         return { total, byType: group("type"), bySource: group("source"), ...span };
     }
+    /**
+     * Engagement over time from context.read events — the retention pulse.
+     * Local/per-install only (this machine); aggregate cohort retention would
+     * require opt-in telemetry. `now` is injectable for deterministic tests.
+     */
+    activity(now = Date.now()) {
+        const DAY = 86_400_000;
+        const dayKey = (ms) => new Date(ms).toISOString().slice(0, 10);
+        const reads = this.query({ type: "context.read", limit: 1_000_000 }); // ts DESC
+        const firstEventAt = this.db.prepare("SELECT MIN(ts) m FROM events").get().m;
+        const firstMs = firstEventAt ? new Date(firstEventAt).getTime() : null;
+        const daily = new Map();
+        for (let i = 13; i >= 0; i--)
+            daily.set(dayKey(now - i * DAY), 0);
+        let reads7d = 0, reads30d = 0, week2Read = false;
+        const days7 = new Set(), days14 = new Set();
+        for (const e of reads) {
+            const t = new Date(e.ts).getTime();
+            if (!Number.isFinite(t))
+                continue;
+            const age = now - t, k = dayKey(t);
+            if (age <= 7 * DAY) {
+                reads7d++;
+                days7.add(k);
+            }
+            if (age <= 14 * DAY)
+                days14.add(k);
+            if (age <= 30 * DAY)
+                reads30d++;
+            if (daily.has(k))
+                daily.set(k, (daily.get(k) ?? 0) + 1);
+            if (firstMs !== null && t >= firstMs + 7 * DAY && t < firstMs + 14 * DAY)
+                week2Read = true;
+        }
+        return {
+            firstEventAt,
+            lastReadAt: reads.length ? reads[0].ts : null,
+            daysSinceFirst: firstMs !== null ? Math.max(0, Math.floor((now - firstMs) / DAY)) : 0,
+            totalReads: reads.length,
+            reads7d,
+            reads30d,
+            activeDays7d: days7.size,
+            activeDays14d: days14.size,
+            retainedWeek2: firstMs !== null && now >= firstMs + 14 * DAY ? week2Read : null,
+            daily: [...daily.entries()].map(([date, r]) => ({ date, reads: r })),
+        };
+    }
     topics(limit = 50) {
         const rows = this.db
             .prepare("SELECT * FROM view_topics ORDER BY weight DESC LIMIT ?")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "persnally",
-  "version": "2.3.2",
+  "version": "2.5.0",
   "license": "FSL-1.1-MIT",
   "description": "Your own context engine — local-first, across every AI. So every AI finally knows you.",
   "type": "module",