persnally 2.0.0

package/build/src/mcp/telemetry.js

@@ -0,0 +1,29 @@
+/**
+ * Local-only telemetry for the Phase 0 capture-rate experiment.
+ * Appends one JSON line per event to ~/.persnally/telemetry.jsonl — counts and
+ * timestamps only, never conversation content. Analyzed by experiments/capture_rate.py.
+ */
+import { appendFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+const DIR = join(homedir(), ".persnally");
+const FILE = join(DIR, "telemetry.jsonl");
+let clientName = "unknown";
+export function setClient(name) {
+    if (name)
+        clientName = name;
+}
+export function getClient() {
+    return clientName;
+}
+export function logEvent(event, data = {}) {
+    try {
+        if (!existsSync(DIR))
+            mkdirSync(DIR, { recursive: true });
+        const line = JSON.stringify({ ts: new Date().toISOString(), event, client: clientName, ...data });
+        appendFileSync(FILE, line + "\n");
+    }
+    catch {
+        // Telemetry must never break the server.
+    }
+}

package/build/src/paths.d.ts

@@ -0,0 +1,2 @@
+/** All local state lives here. PERSNALLY_DIR override exists for tests and power users. */
+export declare const DATA_DIR: string;

package/build/src/paths.js

@@ -0,0 +1,4 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** All local state lives here. PERSNALLY_DIR override exists for tests and power users. */
+export const DATA_DIR = process.env.PERSNALLY_DIR ?? join(homedir(), ".persnally");

package/build/src/permissions.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Per-client category scopes. Default-open: a client with no entry sees
+ * everything. Once scoped, it sees only its allowed categories — enforced
+ * at the daemon, so no MCP client can read past its grant. Stored in config.
+ */
+export declare const CATEGORIES: readonly ["technology", "business", "finance", "career", "health", "science", "creative", "education", "lifestyle", "news", "other"];
+export type Category = (typeof CATEGORIES)[number];
+export type Scopes = Record<string, Category[]>;
+export declare function loadScopes(): Scopes;
+export declare function setScope(client: string, categories: Category[]): void;
+export declare function clearScope(client: string): boolean;
+/** null = unrestricted (sees all). An array = the only categories this client may read. */
+export declare function allowedCategories(client: string): Category[] | null;
+export declare function isAllowed(client: string, category: string): boolean;

package/build/src/permissions.js

@@ -0,0 +1,33 @@
+/**
+ * Per-client category scopes. Default-open: a client with no entry sees
+ * everything. Once scoped, it sees only its allowed categories — enforced
+ * at the daemon, so no MCP client can read past its grant. Stored in config.
+ */
+import { loadConfig, saveConfig } from "./config.js";
+export const CATEGORIES = [
+    "technology", "business", "finance", "career", "health",
+    "science", "creative", "education", "lifestyle", "news", "other",
+];
+export function loadScopes() {
+    const s = loadConfig().client_scopes;
+    return s && typeof s === "object" ? s : {};
+}
+export function setScope(client, categories) {
+    saveConfig({ client_scopes: { ...loadScopes(), [client]: categories } });
+}
+export function clearScope(client) {
+    const scopes = loadScopes();
+    if (!(client in scopes))
+        return false;
+    delete scopes[client];
+    saveConfig({ client_scopes: scopes });
+    return true;
+}
+/** null = unrestricted (sees all). An array = the only categories this client may read. */
+export function allowedCategories(client) {
+    return loadScopes()[client] ?? null;
+}
+export function isAllowed(client, category) {
+    const allowed = allowedCategories(client);
+    return allowed === null || allowed.includes(category);
+}

package/build/src/profile.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Profile synthesis — the Mirror. Turns the event store into a descriptive profile,
+ * each section citing the event ids it rests on so "why does it think this?"
+ * resolves to actual evidence.
+ */
+import { z } from "zod";
+import { type LlmExtract } from "./llm.js";
+import type { EventStore } from "./store.js";
+export declare const profileSchema: z.ZodObject<{
+    headline: z.ZodString;
+    sections: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        body: z.ZodString;
+        evidence_event_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Profile = z.infer<typeof profileSchema> & {
+    generated_at: string;
+    model: string;
+};
+export declare function synthesizeProfile(store: EventStore, extract?: LlmExtract, model?: string): Promise<Profile>;
+export declare function renderProfile(p: Profile): string;

package/build/src/profile.js

@@ -0,0 +1,62 @@
+/**
+ * Profile synthesis — the Mirror. Turns the event store into a descriptive profile,
+ * each section citing the event ids it rests on so "why does it think this?"
+ * resolves to actual evidence.
+ */
+import { z } from "zod";
+import { anthropicExtract, DEFAULT_PROFILE_MODEL } from "./llm.js";
+export const profileSchema = z.object({
+    headline: z.string().min(1),
+    sections: z.array(z.object({
+        title: z.string().min(1),
+        body: z.string().min(1),
+        evidence_event_ids: z.array(z.string()).default([]),
+    })).min(1),
+});
+const INSTRUCTION = `Write the sharpest possible picture of this person from their extracted signals.
+
+Rules:
+- Cover only what the evidence supports: current work, how they think and decide, technical depth, communication style, what they care about and avoid, and non-obvious inferences the pattern reveals.
+- Be specific and concrete. Where you're inferring rather than told, say so. Do not flatter.
+- Every section must list the event ids (given in [brackets]) of the signals it rests on.
+- The test: the person reads it and thinks "how did it know that?"`;
+export async function synthesizeProfile(store, extract = anthropicExtract, model = DEFAULT_PROFILE_MODEL) {
+    const topics = store.topics(30);
+    const assertions = store.query({ type: "signal.assertion", limit: 200 });
+    if (!topics.length && !assertions.length) {
+        throw new Error("Nothing to synthesize from — run an import first.");
+    }
+    const content = [
+        "## Weighted interests (decayed)",
+        ...topics.map((t) => `- [${t.event_ids[0] ?? ""}] ${t.topic} (${t.category}, weight ${t.weight.toFixed(2)}, ` +
+            `${t.dominant_intent}, ${t.signals} signals${t.entities.length ? `, entities: ${t.entities.slice(0, 5).join(", ")}` : ""})`),
+        "",
+        "## Extracted assertions",
+        ...assertions.map((e) => {
+            const p = e.payload;
+            return `- [${e.id}] (${p.kind}, conf ${p.confidence}) ${p.claim} — ${p.evidence}`;
+        }),
+    ].join("\n");
+    const raw = await extract({
+        model,
+        instruction: INSTRUCTION,
+        schema: profileSchema,
+        content,
+        maxTokens: 8000,
+    });
+    const parsed = profileSchema.parse(raw);
+    const profile = { ...parsed, generated_at: new Date().toISOString(), model };
+    store.saveProfile(profile);
+    return profile;
+}
+export function renderProfile(p) {
+    const lines = [`# ${p.headline}`, ""];
+    for (const s of p.sections) {
+        lines.push(`## ${s.title}`, s.body);
+        if (s.evidence_event_ids.length)
+            lines.push(`  ↳ evidence: ${s.evidence_event_ids.length} event(s)`);
+        lines.push("");
+    }
+    lines.push(`(generated ${p.generated_at} by ${p.model})`);
+    return lines.join("\n");
+}

package/build/src/setup.d.ts

@@ -0,0 +1,23 @@
+/**
+ * One-command onboarding: find exports (zipped or unzipped), pick an engine,
+ * import everything, synthesize, connect AI clients, open the dashboard.
+ * Idempotent — already-imported sources are recorded in config and skipped.
+ */
+export type ExportKind = "claude" | "chatgpt";
+export interface FoundExport {
+    kind: ExportKind;
+    path: string;
+    origin: string;
+    cleanup?: string;
+}
+/** Scans a directory (default ~/Downloads) for Claude/ChatGPT exports, zipped or not. */
+export declare function detectExports(searchDir?: string): FoundExport[];
+import { type PersnallyEvent } from "./events.js";
+import type { ChosenExtractor } from "./llm.js";
+export declare const DENSITY_QUESTIONS: readonly ["What are you working on right now?", "What topics or technologies do you care most about these days?"];
+export declare function isThin(signalCount: number): boolean;
+/** Turns free-text answers into seed events — via the engine when available,
+ *  else a deterministic phrase split so the key-free path still works. */
+export declare function eventsFromAnswers(answers: string[], engine: ChosenExtractor | null): Promise<PersnallyEvent[]>;
+export declare function alreadyImported(origin: string): boolean;
+export declare function markImported(origin: string): void;

package/build/src/setup.js

@@ -0,0 +1,111 @@
+/**
+ * One-command onboarding: find exports (zipped or unzipped), pick an engine,
+ * import everything, synthesize, connect AI clients, open the dashboard.
+ * Idempotent — already-imported sources are recorded in config and skipped.
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdtempSync, readdirSync, rmSync, openSync, readSync, closeSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { loadConfig, saveConfig } from "./config.js";
+function sniffKind(conversationsJson) {
+    const fd = openSync(conversationsJson, "r");
+    const buf = Buffer.alloc(4096);
+    const n = readSync(fd, buf, 0, buf.length, 0);
+    closeSync(fd);
+    const head = buf.toString("utf-8", 0, n);
+    if (head.includes('"chat_messages"'))
+        return "claude";
+    if (head.includes('"mapping"'))
+        return "chatgpt";
+    return null;
+}
+function zipHasConversations(zipPath) {
+    try {
+        return execFileSync("unzip", ["-l", zipPath], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] })
+            .includes("conversations.json");
+    }
+    catch {
+        return false;
+    }
+}
+/** Scans a directory (default ~/Downloads) for Claude/ChatGPT exports, zipped or not. */
+export function detectExports(searchDir = join(homedir(), "Downloads")) {
+    if (!existsSync(searchDir))
+        return [];
+    const found = [];
+    for (const entry of readdirSync(searchDir, { withFileTypes: true })) {
+        const full = join(searchDir, entry.name);
+        if (entry.isDirectory() && existsSync(join(full, "conversations.json"))) {
+            const kind = sniffKind(join(full, "conversations.json"));
+            if (kind)
+                found.push({ kind, path: full, origin: full });
+        }
+        else if (entry.isFile() && entry.name.endsWith(".zip") && zipHasConversations(full)) {
+            const tmp = mkdtempSync(join(tmpdir(), "persnally-export-"));
+            execFileSync("unzip", ["-q", full, "-d", tmp]);
+            const root = existsSync(join(tmp, "conversations.json"))
+                ? tmp
+                : readdirSync(tmp).map((d) => join(tmp, d)).find((d) => existsSync(join(d, "conversations.json")));
+            const kind = root ? sniffKind(join(root, "conversations.json")) : null;
+            if (root && kind)
+                found.push({ kind, path: root, origin: full, cleanup: tmp });
+            else
+                rmSync(tmp, { recursive: true, force: true });
+        }
+    }
+    return found;
+}
+// ── Density floor: never leave the user with an empty mirror ──
+import { z } from "zod";
+import { newEvent, PAYLOAD_SCHEMAS } from "./events.js";
+const THIN_SIGNAL_THRESHOLD = 15;
+export const DENSITY_QUESTIONS = [
+    "What are you working on right now?",
+    "What topics or technologies do you care most about these days?",
+];
+export function isThin(signalCount) {
+    return signalCount < THIN_SIGNAL_THRESHOLD;
+}
+const seedExtraction = z.object({ topics: z.array(PAYLOAD_SCHEMAS["signal.topic"]) });
+/** Turns free-text answers into seed events — via the engine when available,
+ *  else a deterministic phrase split so the key-free path still works. */
+export async function eventsFromAnswers(answers, engine) {
+    if (!answers.join("").replace(/[^a-zA-Z0-9]/g, ""))
+        return [];
+    const text = answers.map((a, i) => `${DENSITY_QUESTIONS[i] ?? "Q"}: ${a}`).join("\n");
+    if (engine) {
+        const result = await engine.extract({
+            model: engine.model,
+            instruction: "The user answered two onboarding questions about themselves. Extract 2-6 topic signals. Weight by how central each seems; intent 'building' for active work, 'learning'/'researching' for interests.",
+            schema: seedExtraction,
+            content: text,
+        });
+        return seedExtraction.parse(result).topics.map((t) => newEvent("signal.topic", "cli", t, { kind: "local", surface: "cli" }));
+    }
+    // Key-free fallback: comma/and-separated phrases become moderate signals.
+    const phrases = answers
+        .flatMap((a) => a.split(/,|\band\b|;/))
+        .map((p) => p.trim())
+        .filter((p) => p.length > 2 && p.length < 80 && /[a-zA-Z0-9]/.test(p))
+        .slice(0, 8);
+    return phrases.map((topic, i) => newEvent("signal.topic", "cli", {
+        topic,
+        weight: 0.6,
+        intent: i === 0 ? "building" : "discussing",
+        sentiment: "neutral",
+        depth: "moderate",
+        category: "other",
+        entities: [],
+    }, { kind: "local", surface: "cli" }));
+}
+export function alreadyImported(origin) {
+    const sources = loadConfig().imported_sources;
+    return Array.isArray(sources) && sources.includes(origin);
+}
+export function markImported(origin) {
+    const sources = loadConfig().imported_sources;
+    const list = Array.isArray(sources) ? sources : [];
+    if (!list.includes(origin))
+        saveConfig({ imported_sources: [...list, origin] });
+}

package/build/src/store.d.ts

@@ -0,0 +1,62 @@
+/**
+ * EventStore — append-only SQLite event log plus rebuildable derived views.
+ * Single source of truth per docs/EVENT_SCHEMA.md; views can always be re-derived.
+ */
+import { type PersnallyEvent } from "./events.js";
+export declare const DEFAULT_DB_PATH: string;
+export interface QueryOpts {
+    type?: string;
+    source?: string;
+    since?: string;
+    recordedSince?: string;
+    limit?: number;
+}
+export interface TopicRow {
+    topic_key: string;
+    topic: string;
+    category: string;
+    signals: number;
+    weight: number;
+    sentiment_balance: number;
+    dominant_intent: string;
+    entities: string[];
+    first_seen: string;
+    last_seen: string;
+    event_ids: string[];
+}
+export interface StoredProfile {
+    headline: string;
+    sections: {
+        title: string;
+        body: string;
+        evidence_event_ids: string[];
+    }[];
+    generated_at: string;
+    model: string;
+}
+export declare class EventStore {
+    private db;
+    constructor(path?: string);
+    private migrate;
+    append(events: PersnallyEvent[]): number;
+    query(opts?: QueryOpts): PersnallyEvent[];
+    getEvents(ids: string[]): PersnallyEvent[];
+    stats(): {
+        total: number;
+        byType: Record<string, number>;
+        bySource: Record<string, number>;
+        first: string | null;
+        last: string | null;
+    };
+    topics(limit?: number): TopicRow[];
+    /** Re-derive view_topics from signal.topic events using decayed per-signal weighting. */
+    rebuild(now?: number): void;
+    saveProfile(p: StoredProfile): void;
+    getProfile(): StoredProfile | null;
+    /** Hard-deletes matching topic events plus derived events referencing them, then rebuilds. */
+    forgetTopic(topic: string): number;
+    /** Removes every event from one import batch — a bad import is fully reversible. */
+    forgetBatch(batch: string): number;
+    forgetAll(): void;
+    close(): void;
+}

package/build/src/store.js

@@ -0,0 +1,233 @@
+/**
+ * EventStore — append-only SQLite event log plus rebuildable derived views.
+ * Single source of truth per docs/EVENT_SCHEMA.md; views can always be re-derived.
+ */
+import Database from "better-sqlite3";
+import { mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { topicWeight } from "./decay.js";
+import { normalizeTopic, validateEvent } from "./events.js";
+import { DATA_DIR } from "./paths.js";
+const VIEW_SCHEMA_VERSION = 2;
+export const DEFAULT_DB_PATH = join(DATA_DIR, "persnally.db");
+export class EventStore {
+    db;
+    constructor(path = DEFAULT_DB_PATH) {
+        mkdirSync(dirname(path), { recursive: true });
+        this.db = new Database(path);
+        this.db.pragma("journal_mode = WAL");
+        this.migrate();
+    }
+    migrate() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS events (
+        id          TEXT PRIMARY KEY,
+        ts          TEXT NOT NULL,
+        recorded_at TEXT NOT NULL,
+        source      TEXT NOT NULL,
+        type        TEXT NOT NULL,
+        payload     TEXT NOT NULL,
+        provenance  TEXT NOT NULL,
+        schema_ver  INTEGER NOT NULL DEFAULT 1
+      );
+      CREATE INDEX IF NOT EXISTS idx_events_ts   ON events (ts);
+      CREATE INDEX IF NOT EXISTS idx_events_type ON events (type, ts);
+      CREATE INDEX IF NOT EXISTS idx_events_src  ON events (source, ts);
+    `);
+        // Views are derived state: on schema change, drop and re-derive rather than ALTER.
+        const ver = this.db.pragma("user_version", { simple: true }) ?? 0;
+        if (ver < VIEW_SCHEMA_VERSION) {
+            this.db.exec("DROP TABLE IF EXISTS view_topics; DROP TABLE IF EXISTS view_profile;");
+            this.db.pragma(`user_version = ${VIEW_SCHEMA_VERSION}`);
+        }
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS view_topics (
+        topic_key         TEXT PRIMARY KEY,
+        topic             TEXT NOT NULL,
+        category          TEXT NOT NULL,
+        signals           INTEGER NOT NULL,
+        weight            REAL NOT NULL,
+        sentiment_balance REAL NOT NULL,
+        dominant_intent   TEXT NOT NULL,
+        entities          TEXT NOT NULL,
+        first_seen        TEXT NOT NULL,
+        last_seen         TEXT NOT NULL,
+        event_ids         TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS view_profile (
+        id           INTEGER PRIMARY KEY CHECK (id = 1),
+        headline     TEXT NOT NULL,
+        sections     TEXT NOT NULL,
+        generated_at TEXT NOT NULL,
+        model        TEXT NOT NULL
+      );
+    `);
+        // ver 0 is either a fresh db or a pre-versioning one — rebuild whenever events already exist.
+        if (ver < VIEW_SCHEMA_VERSION) {
+            const n = this.db.prepare("SELECT COUNT(*) n FROM events").get().n;
+            if (n > 0)
+                this.rebuild();
+        }
+    }
+    append(events) {
+        const insert = this.db.prepare(`INSERT INTO events (id, ts, recorded_at, source, type, payload, provenance, schema_ver)
+       VALUES (@id, @ts, @recorded_at, @source, @type, @payload, @provenance, @schema_ver)`);
+        const run = this.db.transaction((batch) => {
+            for (const raw of batch) {
+                const e = validateEvent(raw);
+                insert.run({
+                    ...e,
+                    payload: JSON.stringify(e.payload),
+                    provenance: JSON.stringify(e.provenance),
+                });
+            }
+        });
+        run(events);
+        return events.length;
+    }
+    query(opts = {}) {
+        const where = [];
+        const params = {};
+        if (opts.type) {
+            where.push("type = @type");
+            params.type = opts.type;
+        }
+        if (opts.source) {
+            where.push("source = @source");
+            params.source = opts.source;
+        }
+        if (opts.since) {
+            where.push("ts >= @since");
+            params.since = opts.since;
+        }
+        if (opts.recordedSince) {
+            where.push("recorded_at >= @recordedSince");
+            params.recordedSince = opts.recordedSince;
+        }
+        const sql = `SELECT * FROM events ${where.length ? "WHERE " + where.join(" AND ") : ""}
+                 ORDER BY ts DESC LIMIT @limit`;
+        params.limit = opts.limit ?? 100;
+        return this.db.prepare(sql).all(params).map(rowToEvent);
+    }
+    getEvents(ids) {
+        if (!ids.length)
+            return [];
+        const placeholders = ids.map(() => "?").join(",");
+        return this.db
+            .prepare(`SELECT * FROM events WHERE id IN (${placeholders})`)
+            .all(...ids)
+            .map(rowToEvent);
+    }
+    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()
+            .map((r) => [r.k, r.n]));
+        const span = this.db.prepare("SELECT MIN(ts) first, MAX(ts) last FROM events").get();
+        return { total, byType: group("type"), bySource: group("source"), ...span };
+    }
+    topics(limit = 50) {
+        const rows = this.db
+            .prepare("SELECT * FROM view_topics ORDER BY weight DESC LIMIT ?")
+            .all(limit);
+        return rows.map((r) => ({ ...r, entities: JSON.parse(r.entities), event_ids: JSON.parse(r.event_ids) }));
+    }
+    /** Re-derive view_topics from signal.topic events using decayed per-signal weighting. */
+    rebuild(now = Date.now()) {
+        this.db.exec("DELETE FROM view_topics");
+        const acc = new Map();
+        for (const e of this.query({ type: "signal.topic", limit: 1_000_000 })) {
+            const p = e.payload;
+            const key = normalizeTopic(p.topic);
+            if (!key)
+                continue;
+            let a = acc.get(key);
+            if (!a) {
+                a = { topic: p.topic, categories: new Map(), signals: [], entities: new Set(), first: e.ts, last: e.ts, ids: [] };
+                acc.set(key, a);
+            }
+            a.categories.set(p.category, (a.categories.get(p.category) ?? 0) + 1);
+            a.signals.push({ ts: e.ts, weight: p.weight, depth: p.depth, sentiment: p.sentiment, intent: p.intent });
+            for (const ent of p.entities)
+                a.entities.add(ent);
+            if (e.ts < a.first)
+                a.first = e.ts;
+            if (e.ts > a.last)
+                a.last = e.ts;
+            a.ids.push(e.id);
+        }
+        const rows = [...acc.entries()].map(([key, a]) => {
+            const w = topicWeight(a.signals, now);
+            return {
+                topic_key: key,
+                topic: a.topic,
+                category: [...a.categories.entries()].sort((x, y) => y[1] - x[1])[0][0],
+                signals: a.signals.length,
+                weight: w.weight,
+                sentiment_balance: w.sentiment_balance,
+                dominant_intent: w.dominant_intent,
+                entities: [...a.entities].slice(0, 20),
+                first_seen: a.first,
+                last_seen: a.last,
+                event_ids: a.ids,
+            };
+        });
+        const insert = this.db.prepare(`INSERT INTO view_topics VALUES (@topic_key, @topic, @category, @signals, @weight,
+        @sentiment_balance, @dominant_intent, @entities, @first_seen, @last_seen, @event_ids)`);
+        const run = this.db.transaction((batch) => {
+            for (const r of batch) {
+                insert.run({ ...r, entities: JSON.stringify(r.entities), event_ids: JSON.stringify(r.event_ids) });
+            }
+        });
+        run(rows);
+    }
+    saveProfile(p) {
+        this.db.prepare(`INSERT INTO view_profile (id, headline, sections, generated_at, model)
+       VALUES (1, @headline, @sections, @generated_at, @model)
+       ON CONFLICT(id) DO UPDATE SET headline=@headline, sections=@sections, generated_at=@generated_at, model=@model`).run({ ...p, sections: JSON.stringify(p.sections) });
+    }
+    getProfile() {
+        const row = this.db.prepare("SELECT * FROM view_profile WHERE id = 1").get();
+        return row ? { ...row, sections: JSON.parse(row.sections) } : null;
+    }
+    /** Hard-deletes matching topic events plus derived events referencing them, then rebuilds. */
+    forgetTopic(topic) {
+        const key = normalizeTopic(topic);
+        const candidates = this.query({ type: "signal.topic", limit: 1_000_000 }).filter((e) => normalizeTopic(e.payload.topic) === key);
+        const ids = new Set(candidates.map((e) => e.id));
+        for (const e of this.query({ limit: 1_000_000 })) {
+            const prov = e.provenance;
+            if (prov.kind === "derived" && prov.from?.some((id) => ids.has(id)))
+                ids.add(e.id);
+        }
+        const del = this.db.prepare("DELETE FROM events WHERE id = ?");
+        const run = this.db.transaction((toDelete) => {
+            for (const id of toDelete)
+                del.run(id);
+        });
+        run([...ids]);
+        this.rebuild();
+        return ids.size;
+    }
+    /** Removes every event from one import batch — a bad import is fully reversible. */
+    forgetBatch(batch) {
+        const result = this.db
+            .prepare("DELETE FROM events WHERE json_extract(provenance, '$.batch') = ?")
+            .run(batch);
+        this.rebuild();
+        return result.changes;
+    }
+    forgetAll() {
+        this.db.exec("DELETE FROM events; DELETE FROM view_topics;");
+    }
+    close() {
+        this.db.close();
+    }
+}
+function rowToEvent(row) {
+    const r = row;
+    return {
+        ...r,
+        payload: JSON.parse(r.payload),
+        provenance: JSON.parse(r.provenance),
+    };
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "persnally",
+  "version": "2.0.0",
+  "license": "FSL-1.1-MIT",
+  "description": "The context engine for you — local-first, across every AI. So every AI finally knows you.",
+  "type": "module",
+  "bin": {
+    "persnally": "build/src/cli.js",
+    "persnallyd": "build/src/cli.js",
+    "persnally-mcp": "build/src/mcp/index.js"
+  },
+  "files": [
+    "build/src",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc && node -e \"require('fs').copyFileSync('src/dashboard.html','build/src/dashboard.html')\"",
+    "test": "npm run build && node --test build/test/*.test.js && node test-mcp-e2e.mjs",
+    "serve": "npm run build && node build/src/cli.js serve",
+    "prepublishOnly": "node -e \"const fs=require('fs');fs.copyFileSync('../README.md','README.md');fs.copyFileSync('../LICENSE','LICENSE')\" && npm test"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.104.1",
+    "@modelcontextprotocol/sdk": "^1.5.0",
+    "better-sqlite3": "^11.8.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.12",
+    "@types/node": "^22.13.5",
+    "typescript": "^5.7.3"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "context-engine",
+    "personal-context",
+    "local-first",
+    "ai",
+    "claude",
+    "interest-graph"
+  ],
+  "author": "Persnally",
+  "homepage": "https://persnally.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sidpan2011/persnally"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}