persnally 2.0.0

package/build/src/connect.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Writes the Persnally MCP server into AI clients' configs.
+ * Only touches clients that are actually installed; merges, never clobbers.
+ */
+export declare const CLIENTS: readonly ["claude-code", "claude-desktop", "cursor"];
+export type Client = (typeof CLIENTS)[number];
+export declare function mcpServerPath(): string;
+/** Returns the config file written, or null when the client isn't installed. */
+export declare function connectClient(client: Client): string | null;
+export declare function connectAll(): {
+    client: Client;
+    file: string | null;
+}[];

package/build/src/connect.js

@@ -0,0 +1,51 @@
+/**
+ * Writes the Persnally MCP server into AI clients' configs.
+ * Only touches clients that are actually installed; merges, never clobbers.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+export const CLIENTS = ["claude-code", "claude-desktop", "cursor"];
+function configPathFor(client) {
+    const home = homedir();
+    switch (client) {
+        case "claude-code": {
+            const file = join(home, ".claude.json");
+            return { file, installed: existsSync(file) || existsSync(join(home, ".claude")) };
+        }
+        case "claude-desktop": {
+            const dir = join(home, "Library", "Application Support", "Claude");
+            return { file: join(dir, "claude_desktop_config.json"), installed: existsSync(dir) };
+        }
+        case "cursor": {
+            const dir = join(home, ".cursor");
+            return { file: join(dir, "mcp.json"), installed: existsSync(dir) };
+        }
+    }
+}
+export function mcpServerPath() {
+    if (process.env.PERSNALLY_MCP && existsSync(process.env.PERSNALLY_MCP))
+        return process.env.PERSNALLY_MCP;
+    // Bundled in this package: build/src/connect.js → build/src/mcp/index.js
+    const bundled = join(import.meta.dirname, "mcp", "index.js");
+    if (existsSync(bundled))
+        return bundled;
+    throw new Error("Persnally MCP server build not found — set PERSNALLY_MCP to its index.js");
+}
+/** Returns the config file written, or null when the client isn't installed. */
+export function connectClient(client) {
+    const { file, installed } = configPathFor(client);
+    if (!installed)
+        return null;
+    const cfg = existsSync(file)
+        ? JSON.parse(readFileSync(file, "utf-8"))
+        : {};
+    const servers = (cfg.mcpServers ??= {});
+    servers.persnally = { command: "node", args: [mcpServerPath()] };
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, JSON.stringify(cfg, null, 2) + "\n");
+    return file;
+}
+export function connectAll() {
+    return CLIENTS.map((client) => ({ client, file: connectClient(client) }));
+}

package/build/src/consolidate.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Nightly consolidation — the daemon reflects while the user sleeps.
+ * Always refreshes decay; with an engine and enough new signal it emits
+ * behavior assertions (provenance: derived from the events considered)
+ * and re-synthesizes the profile. Last-run state lives in config, not
+ * the event log — it's operational state, not user data.
+ */
+import type { ChosenExtractor } from "./llm.js";
+import type { EventStore } from "./store.js";
+export declare const CONSOLIDATION_HOUR = 3;
+export interface ConsolidationResult {
+    newSignals: number;
+    assertions: number;
+    profileRefreshed: boolean;
+}
+/** Run once per local day, at or after the consolidation hour. */
+export declare function shouldRunNow(lastRun: string | undefined, now: Date): boolean;
+export declare function runConsolidation(store: EventStore, engine: ChosenExtractor | null, now?: Date): Promise<ConsolidationResult>;

package/build/src/consolidate.js

@@ -0,0 +1,67 @@
+/**
+ * Nightly consolidation — the daemon reflects while the user sleeps.
+ * Always refreshes decay; with an engine and enough new signal it emits
+ * behavior assertions (provenance: derived from the events considered)
+ * and re-synthesizes the profile. Last-run state lives in config, not
+ * the event log — it's operational state, not user data.
+ */
+import { z } from "zod";
+import { loadConfig, saveConfig } from "./config.js";
+import { newEvent, PAYLOAD_SCHEMAS } from "./events.js";
+import { synthesizeProfile } from "./profile.js";
+const ASSERTION_MIN_SIGNALS = 5;
+const PROFILE_MIN_SIGNALS = 10;
+const PROVENANCE_CAP = 100;
+export const CONSOLIDATION_HOUR = 3; // local time
+/** Run once per local day, at or after the consolidation hour. */
+export function shouldRunNow(lastRun, now) {
+    if (now.getHours() < CONSOLIDATION_HOUR)
+        return false;
+    if (!lastRun)
+        return true;
+    const last = new Date(lastRun);
+    return last.toDateString() !== now.toDateString();
+}
+const reflection = z.object({
+    assertions: z.array(PAYLOAD_SCHEMAS["signal.assertion"]).max(3),
+});
+export async function runConsolidation(store, engine, now = new Date()) {
+    const lastRun = loadConfig().last_consolidation;
+    const since = typeof lastRun === "string" ? lastRun : new Date(0).toISOString();
+    // recorded_at, not ts: imports carry historical ts but are new to the store.
+    const newSignals = store
+        .query({ limit: 100_000, recordedSince: since })
+        .filter((e) => e.type.startsWith("signal."));
+    // Decay shifts daily even with no new events — always re-derive.
+    store.rebuild(now.getTime());
+    let assertions = [];
+    if (engine && newSignals.length >= ASSERTION_MIN_SIGNALS) {
+        const summary = newSignals
+            .map((e) => {
+            const p = e.payload;
+            return e.type === "signal.topic"
+                ? `- topic: ${p.topic} (${p.intent}, ${p.sentiment}, weight ${p.weight})`
+                : `- ${e.type}: ${JSON.stringify(p).slice(0, 140)}`;
+        })
+            .join("\n");
+        const result = await engine.extract({
+            model: engine.model,
+            instruction: "These are signals from one user's recent AI activity. Identify at most 3 behavioral patterns worth remembering — recurring focus, a shift in attention, a decision pattern. kind must be 'behavior'. Only assert what this evidence supports; fewer good assertions beat filler.",
+            schema: reflection,
+            content: summary,
+        });
+        const from = newSignals.slice(0, PROVENANCE_CAP).map((e) => e.id);
+        assertions = reflection.parse(result).assertions.map((a) => newEvent("signal.assertion", "system", a, { kind: "derived", from }, now.toISOString()));
+        if (assertions.length) {
+            store.append(assertions);
+            store.rebuild(now.getTime());
+        }
+    }
+    let profileRefreshed = false;
+    if (engine && newSignals.length >= PROFILE_MIN_SIGNALS) {
+        await synthesizeProfile(store, engine.extract, engine.model);
+        profileRefreshed = true;
+    }
+    saveConfig({ last_consolidation: now.toISOString() });
+    return { newSignals: newSignals.length, assertions: assertions.length, profileRefreshed };
+}

package/build/src/daemon.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Local HTTP API + dashboard — loopback only, the single access path to the event store.
+ * Phase 2's MCP context server will be a client of this API.
+ */
+import http from "node:http";
+import type { EventStore } from "./store.js";
+export declare const DEFAULT_PORT = 4983;
+export declare const VERSION: string;
+export declare function startDaemon(store: EventStore, port?: number): http.Server;

package/build/src/daemon.js

@@ -0,0 +1,167 @@
+/**
+ * Local HTTP API + dashboard — loopback only, the single access path to the event store.
+ * Phase 2's MCP context server will be a client of this API.
+ */
+import http from "node:http";
+import { readFileSync } from "node:fs";
+import { loadConfig } from "./config.js";
+import { runConsolidation, shouldRunNow } from "./consolidate.js";
+import { allowedCategories, loadScopes } from "./permissions.js";
+import { newEvent, validateEvent } from "./events.js";
+import { chooseExtractor } from "./llm.js";
+import { synthesizeProfile } from "./profile.js";
+export const DEFAULT_PORT = 4983;
+// Single source of truth for the user-visible version: package.json.
+const pkg = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf-8"));
+export const VERSION = pkg.version;
+export function startDaemon(store, port = DEFAULT_PORT) {
+    const localHosts = [`127.0.0.1:${port}`, `localhost:${port}`];
+    const server = http.createServer(async (req, res) => {
+        // Loopback binding alone doesn't stop browsers: webpages can fire
+        // no-preflight POSTs at 127.0.0.1 (CSRF) or reach it via DNS rebinding.
+        if (!localHosts.includes(req.headers.host ?? "")) {
+            return json(res, 403, { error: "forbidden: unrecognized Host" });
+        }
+        const origin = req.headers.origin;
+        if (origin && !localHosts.some((h) => origin === `http://${h}`)) {
+            return json(res, 403, { error: "forbidden: cross-origin requests are not allowed" });
+        }
+        const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
+        try {
+            if (req.method === "GET" && url.pathname === "/") {
+                res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+                return res.end(dashboardHtml());
+            }
+            if (req.method === "GET" && url.pathname === "/health") {
+                return json(res, 200, { ok: true, version: VERSION });
+            }
+            if (req.method === "GET" && url.pathname === "/stats") {
+                return json(res, 200, store.stats());
+            }
+            if (req.method === "GET" && url.pathname === "/topics") {
+                const client = url.searchParams.get("client");
+                const allowed = client ? allowedCategories(client) : null;
+                let topics = store.topics(num(url, "limit", 50));
+                if (allowed)
+                    topics = topics.filter((t) => allowed.includes(t.category));
+                return json(res, 200, topics);
+            }
+            if (req.method === "GET" && url.pathname === "/profile") {
+                // The synthesized profile is holistic prose — a scoped client gets only its
+                // allowed topics (above), never the cross-category narrative.
+                const client = url.searchParams.get("client");
+                if (client && allowedCategories(client) !== null) {
+                    return json(res, 403, { error: "scoped: this client does not have profile access", scoped: true });
+                }
+                const profile = store.getProfile();
+                return profile ? json(res, 200, profile) : json(res, 404, { error: "no profile synthesized yet" });
+            }
+            if (req.method === "GET" && url.pathname === "/scopes") {
+                return json(res, 200, loadScopes());
+            }
+            if (req.method === "POST" && url.pathname === "/synthesize") {
+                const engine = await chooseExtractor("profile");
+                return json(res, 200, await synthesizeProfile(store, engine.extract, engine.model));
+            }
+            if (req.method === "POST" && url.pathname === "/consolidate") {
+                const engine = await chooseExtractor("extract").catch(() => null);
+                return json(res, 200, await runConsolidation(store, engine));
+            }
+            if (req.method === "GET" && url.pathname === "/events") {
+                const ids = url.searchParams.get("ids");
+                if (ids)
+                    return json(res, 200, store.getEvents(ids.split(",").filter(Boolean)));
+                return json(res, 200, store.query({
+                    type: url.searchParams.get("type") ?? undefined,
+                    source: url.searchParams.get("source") ?? undefined,
+                    since: url.searchParams.get("since") ?? undefined,
+                    limit: num(url, "limit", 100),
+                }));
+            }
+            if (req.method === "POST" && url.pathname === "/events") {
+                // JSON-only forces browsers to preflight (which fails above) — no-preflight
+                // content types like text/plain can't reach the write path.
+                if (!(req.headers["content-type"] ?? "").includes("application/json")) {
+                    return json(res, 415, { error: "Content-Type must be application/json" });
+                }
+                const body = await readBody(req);
+                // The daemon owns event identity: items without an id get one assigned here.
+                const events = (Array.isArray(body) ? body : [body]).map((raw) => {
+                    const r = raw;
+                    return r.id
+                        ? validateEvent(r)
+                        : newEvent(r.type, String(r.source ?? ""), r.payload, r.provenance, typeof r.ts === "string" ? r.ts : undefined);
+                });
+                store.append(events);
+                // Views derive only from signal.* events — skip the O(all-events) rebuild
+                // for telemetry writes like context.read.
+                if (events.some((e) => e.type.startsWith("signal.")))
+                    store.rebuild();
+                return json(res, 201, { inserted: events.length, ids: events.map((e) => e.id) });
+            }
+            if (req.method === "DELETE" && url.pathname === "/events") {
+                if (url.searchParams.get("confirm") !== "all") {
+                    return json(res, 400, { error: "destructive: requires ?confirm=all" });
+                }
+                store.forgetAll();
+                return json(res, 200, { deleted: "all" });
+            }
+            if (req.method === "DELETE" && url.pathname.startsWith("/topics/")) {
+                const topic = decodeURIComponent(url.pathname.slice("/topics/".length));
+                if (!topic)
+                    return json(res, 400, { error: "topic required" });
+                return json(res, 200, { deleted: store.forgetTopic(topic) });
+            }
+            return json(res, 404, { error: "not found" });
+        }
+        catch (e) {
+            return json(res, 400, { error: e instanceof Error ? e.message : "bad request" });
+        }
+    });
+    server.listen(port, "127.0.0.1");
+    // Nightly reflection: check every 30 min, run once per day at/after the consolidation hour.
+    const timer = setInterval(async () => {
+        const lastRun = loadConfig().last_consolidation;
+        if (!shouldRunNow(typeof lastRun === "string" ? lastRun : undefined, new Date()))
+            return;
+        try {
+            const engine = await chooseExtractor("extract").catch(() => null);
+            const r = await runConsolidation(store, engine);
+            console.error(`consolidation: ${r.newSignals} new signals, ${r.assertions} assertions, profile ${r.profileRefreshed ? "refreshed" : "kept"}`);
+        }
+        catch (e) {
+            console.error("consolidation failed:", e instanceof Error ? e.message : e);
+        }
+    }, 30 * 60 * 1000);
+    timer.unref();
+    server.on("close", () => clearInterval(timer));
+    return server;
+}
+let cachedHtml;
+function dashboardHtml() {
+    cachedHtml ??= readFileSync(new URL("./dashboard.html", import.meta.url), "utf-8");
+    return cachedHtml;
+}
+function json(res, status, body) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(body));
+}
+function num(url, key, fallback) {
+    const v = Number(url.searchParams.get(key));
+    return Number.isFinite(v) && v > 0 ? v : fallback;
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        req.on("data", (chunk) => (data += chunk));
+        req.on("end", () => {
+            try {
+                resolve(JSON.parse(data));
+            }
+            catch {
+                reject(new Error("invalid JSON body"));
+            }
+        });
+        req.on("error", reject);
+    });
+}

package/build/src/dashboard.html

@@ -0,0 +1,181 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>Persnally — your context engine</title>
+<style>
+  :root {
+    --bg: #0d0e12; --panel: #14161c; --panel-2: #1a1d25; --line: #262a35;
+    --text: #e8eaf0; --dim: #8b92a5; --accent: #6ee7b7; --warn: #f87171;
+    --intent: #93c5fd;
+  }
+  * { box-sizing: border-box; margin: 0; }
+  body {
+    background: var(--bg); color: var(--text);
+    font: 15px/1.6 -apple-system, "Segoe UI", system-ui, sans-serif;
+    max-width: 880px; margin: 0 auto; padding: 40px 24px 80px;
+  }
+  header { display: flex; justify-content: space-between; align-items: baseline; flex-wrap: wrap; gap: 8px; }
+  h1 { font-size: 22px; letter-spacing: -0.3px; }
+  h1 span { color: var(--accent); }
+  .tagline { color: var(--dim); font-size: 14px; }
+  .stats { display: flex; gap: 24px; margin: 22px 0 34px; color: var(--dim); font-size: 13px; }
+  .stats b { color: var(--text); font-size: 17px; display: block; }
+  section { margin-bottom: 40px; }
+  h2 { font-size: 13px; text-transform: uppercase; letter-spacing: 1.4px; color: var(--dim); margin-bottom: 14px; }
+  .card { background: var(--panel); border: 1px solid var(--line); border-radius: 10px; padding: 18px 20px; margin-bottom: 12px; }
+  .headline { font-size: 17px; font-weight: 600; line-height: 1.5; }
+  .meta { color: var(--dim); font-size: 12px; margin-top: 8px; }
+  .sec-title { font-weight: 600; margin-bottom: 6px; }
+  .sec-body { color: #c6cad6; white-space: pre-wrap; }
+  .evidence-btn {
+    background: none; border: none; color: var(--accent); cursor: pointer;
+    font-size: 12px; padding: 0; margin-top: 10px; font-family: inherit;
+  }
+  .evidence { margin-top: 10px; border-top: 1px dashed var(--line); padding-top: 10px; display: none; }
+  .evidence.open { display: block; }
+  .ev-item { font-size: 12.5px; color: var(--dim); padding: 4px 0; }
+  .ev-item code { color: var(--intent); background: var(--panel-2); padding: 1px 6px; border-radius: 4px; }
+  table { width: 100%; border-collapse: collapse; }
+  td { padding: 9px 8px; border-bottom: 1px solid var(--line); vertical-align: middle; font-size: 14px; }
+  .bar { height: 6px; border-radius: 3px; background: var(--accent); min-width: 2px; }
+  .bar-cell { width: 120px; }
+  .cat { color: var(--dim); font-size: 12.5px; }
+  .neg { color: var(--warn); }
+  .del {
+    background: none; border: 1px solid var(--line); color: var(--dim); border-radius: 6px;
+    cursor: pointer; font-size: 11.5px; padding: 2px 9px;
+  }
+  .del:hover { color: var(--warn); border-color: var(--warn); }
+  .btn {
+    background: var(--accent); color: #07241a; border: none; border-radius: 8px;
+    padding: 8px 16px; font-weight: 600; cursor: pointer; font-size: 13.5px;
+  }
+  .btn:disabled { opacity: 0.5; cursor: wait; }
+  .empty { color: var(--dim); padding: 24px; text-align: center; }
+  footer { color: var(--dim); font-size: 12px; border-top: 1px solid var(--line); padding-top: 16px; }
+</style>
+</head>
+<body>
+<header>
+  <div>
+    <h1>persnally<span>d</span></h1>
+    <div class="tagline">so every AI finally knows you · local-first, nothing leaves this machine</div>
+  </div>
+  <button class="btn" id="synthesize">Re-synthesize profile</button>
+</header>
+
+<div class="stats" id="stats"></div>
+
+<section>
+  <h2>Your profile — every claim traceable to evidence</h2>
+  <div id="profile"><div class="empty">Loading…</div></div>
+</section>
+
+<section>
+  <h2>Interest graph — decayed, weighted, deletable</h2>
+  <div class="card" style="padding:6px 14px"><table id="topics"></table></div>
+</section>
+
+<footer>
+  Stored at ~/.persnally/persnally.db · deleting a topic hard-deletes its events and everything derived from them ·
+  <code>persnallyd forget --all</code> erases everything
+</footer>
+
+<script>
+const $ = (id) => document.getElementById(id);
+const esc = (s) => String(s).replace(/[&<>"']/g, (c) =>
+  ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
+
+async function get(path) {
+  const r = await fetch(path);
+  if (!r.ok) return null;
+  return r.json();
+}
+
+async function loadStats() {
+  const s = await get("/stats");
+  if (!s) return;
+  const span = s.first ? `${s.first.slice(0, 10)} → ${s.last.slice(0, 10)}` : "—";
+  $("stats").innerHTML = `
+    <div><b>${s.total}</b>events</div>
+    <div><b>${s.byType["signal.topic"] ?? 0}</b>topic signals</div>
+    <div><b>${s.byType["signal.assertion"] ?? 0}</b>assertions</div>
+    <div><b>${span}</b>covered</div>`;
+}
+
+async function loadProfile() {
+  const p = await get("/profile");
+  if (!p) {
+    $("profile").innerHTML = `<div class="card empty">No profile yet — import data, then hit “Re-synthesize profile”.</div>`;
+    return;
+  }
+  const sections = p.sections.map((s, i) => `
+    <div class="card">
+      <div class="sec-title">${esc(s.title)}</div>
+      <div class="sec-body">${esc(s.body)}</div>
+      ${s.evidence_event_ids.length ? `
+        <button class="evidence-btn" data-i="${i}">why does it think this? · ${s.evidence_event_ids.length} events</button>
+        <div class="evidence" id="ev-${i}" data-ids="${esc(s.evidence_event_ids.join(","))}"></div>` : ""}
+    </div>`).join("");
+  $("profile").innerHTML = `
+    <div class="card"><div class="headline">${esc(p.headline)}</div>
+    <div class="meta">generated ${esc(p.generated_at)} · ${esc(p.model)} · synthesized from structured events only</div></div>
+    ${sections}`;
+
+  document.querySelectorAll(".evidence-btn").forEach((btn) =>
+    btn.addEventListener("click", () => toggleEvidence(btn.dataset.i)));
+}
+
+async function toggleEvidence(i) {
+  const box = $(`ev-${i}`);
+  box.classList.toggle("open");
+  if (box.dataset.loaded || !box.classList.contains("open")) return;
+  const events = await get(`/events?ids=${box.dataset.ids}`) ?? [];
+  box.innerHTML = events.map((e) => {
+    const p = e.payload;
+    const summary = e.type === "signal.topic"
+      ? `${p.topic} (${p.intent}, ${p.sentiment})`
+      : p.claim ?? JSON.stringify(p).slice(0, 120);
+    const origin = e.provenance.kind === "import"
+      ? `${e.provenance.file}${e.provenance.conversation_uuid ? " · convo " + e.provenance.conversation_uuid.slice(0, 8) : ""}`
+      : e.provenance.kind;
+    return `<div class="ev-item"><code>${esc(e.type)}</code> ${esc(summary)} — <i>${esc(origin)}, ${esc(e.ts.slice(0, 10))}</i></div>`;
+  }).join("") || `<div class="ev-item">events not found (deleted?)</div>`;
+  box.dataset.loaded = "1";
+}
+
+async function loadTopics() {
+  const topics = await get("/topics?limit=40") ?? [];
+  const max = Math.max(...topics.map((t) => t.weight), 0.01);
+  $("topics").innerHTML = topics.map((t) => `
+    <tr>
+      <td class="bar-cell"><div class="bar" style="width:${Math.max((t.weight / max) * 100, 2)}%"></div></td>
+      <td>${esc(t.topic)}${t.sentiment_balance < -0.2 ? ' <span class="neg">▾</span>' : ""}</td>
+      <td class="cat">${esc(t.category)} · ${esc(t.dominant_intent)} · ${t.signals}×</td>
+      <td class="cat">${esc(t.last_seen.slice(0, 10))}</td>
+      <td><button class="del" data-topic="${esc(t.topic)}">forget</button></td>
+    </tr>`).join("") || `<tr><td class="empty">No topics yet — run an import.</td></tr>`;
+
+  document.querySelectorAll(".del").forEach((btn) =>
+    btn.addEventListener("click", async () => {
+      if (!confirm(`Hard-delete "${btn.dataset.topic}" and everything derived from it?`)) return;
+      await fetch(`/topics/${encodeURIComponent(btn.dataset.topic)}`, { method: "DELETE" });
+      loadTopics(); loadStats();
+    }));
+}
+
+$("synthesize").addEventListener("click", async () => {
+  const btn = $("synthesize");
+  btn.disabled = true; btn.textContent = "Synthesizing… (can take a minute)";
+  const r = await fetch("/synthesize", { method: "POST" });
+  if (!r.ok) alert((await r.json()).error ?? "synthesis failed");
+  btn.disabled = false; btn.textContent = "Re-synthesize profile";
+  loadProfile();
+});
+
+loadStats(); loadProfile(); loadTopics();
+</script>
+</body>
+</html>

package/build/src/decay.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Interest weighting, ported from v1's interest-engine with the double-count fix:
+ * v1 summed raw weights per signal AND multiplied a frequency bonus on top, defeating
+ * the half-life for repeated topics. Here each signal decays individually and
+ * frequency emerges from the decayed sum alone.
+ */
+export interface WeightSignal {
+    ts: string;
+    weight: number;
+    depth: string;
+    sentiment: string;
+    intent: string;
+}
+export interface TopicWeight {
+    weight: number;
+    sentiment_balance: number;
+    dominant_intent: string;
+}
+export declare function topicWeight(signals: WeightSignal[], now?: number): TopicWeight;

package/build/src/decay.js

@@ -0,0 +1,33 @@
+/**
+ * Interest weighting, ported from v1's interest-engine with the double-count fix:
+ * v1 summed raw weights per signal AND multiplied a frequency bonus on top, defeating
+ * the half-life for repeated topics. Here each signal decays individually and
+ * frequency emerges from the decayed sum alone.
+ */
+const HALF_LIFE_DAYS = 7;
+const LAMBDA = Math.LN2 / HALF_LIFE_DAYS;
+const MS_PER_DAY = 86_400_000;
+const MAX_WEIGHT = 10;
+const DEPTH_SCORES = { mention: 0.3, moderate: 0.6, deep: 1.0 };
+const SENTIMENT_VALUES = { positive: 0.5, negative: -0.5, neutral: 0 };
+export function topicWeight(signals, now = Date.now()) {
+    let sum = 0;
+    let sentiment = 0;
+    const intents = new Map();
+    for (const s of signals) {
+        const days = Math.max((now - Date.parse(s.ts)) / MS_PER_DAY, 0);
+        sum += s.weight * (DEPTH_SCORES[s.depth] ?? 0.3) * Math.exp(-LAMBDA * days);
+        sentiment += SENTIMENT_VALUES[s.sentiment] ?? 0;
+        intents.set(s.intent, (intents.get(s.intent) ?? 0) + 1);
+    }
+    const balance = signals.length ? sentiment / signals.length : 0;
+    // Negative sentiment deprioritizes (floor 0.2), never boosts.
+    const sentimentMultiplier = Math.max(0.2, 1 + Math.min(balance, 0) * 0.8);
+    // Most-frequent intent — v1 documented this but actually took the latest.
+    const dominant = [...intents.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? "discussing";
+    return {
+        weight: Math.min(sum * sentimentMultiplier, MAX_WEIGHT),
+        sentiment_balance: balance,
+        dominant_intent: dominant,
+    };
+}