persnally 2.0.0

package/build/src/importers/git.js

@@ -0,0 +1,123 @@
+/**
+ * Git history importer — fully deterministic, no LLM, works offline.
+ * Repos become project topics; manifest dependencies become skill signals.
+ * Carries forward the v1 skill_analyzer's framework-detection approach.
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { basename, join } from "node:path";
+import { newEvent, uuidv7 } from "../events.js";
+const FRAMEWORKS = {
+    // js/ts
+    react: "frontend", next: "frontend", vue: "frontend", svelte: "frontend", "solid-js": "frontend",
+    tailwindcss: "frontend", express: "backend", fastify: "backend", hono: "backend", nestjs: "backend",
+    "better-sqlite3": "backend", prisma: "backend", drizzle: "backend", zod: "backend",
+    "@modelcontextprotocol/sdk": "ai_ml", "@anthropic-ai/sdk": "ai_ml", openai: "ai_ml", langchain: "ai_ml",
+    electron: "desktop", "react-native": "mobile", expo: "mobile",
+    // python
+    fastapi: "backend", django: "backend", flask: "backend", sqlalchemy: "backend", pydantic: "backend",
+    torch: "ai_ml", tensorflow: "ai_ml", transformers: "ai_ml", anthropic: "ai_ml", pandas: "data",
+    numpy: "data", "scikit-learn": "data",
+    // other ecosystems (manifest presence)
+    cargo: "systems", "go.mod": "backend",
+};
+/** Pure: manifest filename → content → detected framework names. */
+export function detectFrameworks(manifests) {
+    const found = new Set();
+    for (const [name, content] of Object.entries(manifests)) {
+        if (name === "package.json") {
+            try {
+                const pkg = JSON.parse(content);
+                for (const dep of Object.keys({ ...pkg.dependencies, ...pkg.devDependencies })) {
+                    if (FRAMEWORKS[dep])
+                        found.add(dep);
+                }
+            }
+            catch { /* unparseable manifest — skip, not fatal */ }
+        }
+        if (name === "requirements.txt" || name === "pyproject.toml") {
+            for (const fw of Object.keys(FRAMEWORKS)) {
+                if (new RegExp(`\\b${fw.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "i").test(content))
+                    found.add(fw);
+            }
+        }
+        if (name === "Cargo.toml")
+            found.add("cargo");
+        if (name === "go.mod")
+            found.add("go.mod");
+    }
+    return [...found];
+}
+function git(repoPath, args) {
+    return execFileSync("git", ["-C", repoPath, ...args], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+}
+export function summarizeRepo(repoPath, authorEmail) {
+    if (!existsSync(join(repoPath, ".git")))
+        return null;
+    const author = authorEmail ?? git(repoPath, ["config", "user.email"]);
+    if (!author)
+        return null;
+    const log = git(repoPath, ["log", `--author=${author}`, "--format=%aI", "--no-merges"]);
+    if (!log)
+        return null;
+    const dates = log.split("\n");
+    const manifests = {};
+    for (const name of ["package.json", "requirements.txt", "pyproject.toml", "Cargo.toml", "go.mod"]) {
+        const p = join(repoPath, name);
+        if (existsSync(p))
+            manifests[name] = readFileSync(p, "utf-8");
+    }
+    return {
+        repo: basename(repoPath),
+        path: repoPath,
+        commits: dates.length,
+        firstCommit: dates[dates.length - 1],
+        lastCommit: dates[0],
+        frameworks: detectFrameworks(manifests),
+    };
+}
+/** A path is either a repo or a directory of repos — resolve to repo summaries. */
+export function scanRepos(path, authorEmail) {
+    const direct = summarizeRepo(path, authorEmail);
+    if (direct)
+        return [direct];
+    return readdirSync(path, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => { try {
+        return summarizeRepo(join(path, d.name), authorEmail);
+    }
+    catch {
+        return null;
+    } })
+        .filter((s) => s !== null);
+}
+export function gitEvents(summaries) {
+    const batch = uuidv7();
+    const events = [];
+    const activity = (commits) => Math.min(Math.log2(commits + 1) / 8, 1);
+    for (const s of summaries) {
+        events.push(newEvent("signal.topic", "import:git", {
+            topic: s.repo,
+            weight: Math.max(activity(s.commits), 0.1),
+            intent: "building",
+            sentiment: "neutral",
+            depth: s.commits > 50 ? "deep" : s.commits > 10 ? "moderate" : "mention",
+            category: "technology",
+            entities: s.frameworks.slice(0, 10),
+        }, { kind: "git", repo: s.repo, batch }, s.lastCommit));
+        for (const fw of s.frameworks) {
+            events.push(newEvent("signal.skill", "import:git", {
+                skill: fw,
+                domain: FRAMEWORKS[fw] ?? "other",
+                proficiency: activity(s.commits),
+                basis: `repo-activity:${s.repo}`,
+            }, { kind: "git", repo: s.repo, batch }, s.lastCommit));
+        }
+    }
+    events.push(newEvent("system.import", "system", {
+        importer: "git",
+        batch,
+        events: events.length,
+    }, { kind: "import", batch, file: summaries.map((s) => s.repo).join(",") }));
+    return { events, batch };
+}

package/build/src/lifecycle.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Daemon lifecycle — pidfile, detached start/stop, and macOS launchd autostart.
+ * The pidfile is advisory: a stale one (dead pid) is detected and cleaned up.
+ */
+export declare const LOG_FILE: string;
+/** Returns the running daemon's pid, cleaning up a stale pidfile if found. */
+export declare function runningPid(): number | null;
+export declare function writePidFile(): void;
+export declare function removePidFile(): void;
+export declare function startDetached(cliPath: string, port: number): Promise<number>;
+export declare function stopDaemon(): Promise<number | null>;
+export declare function autostartInstalled(): boolean;
+export declare function installAutostart(cliPath: string, port: number): string;
+export declare function removeAutostart(): boolean;

package/build/src/lifecycle.js

@@ -0,0 +1,119 @@
+/**
+ * Daemon lifecycle — pidfile, detached start/stop, and macOS launchd autostart.
+ * The pidfile is advisory: a stale one (dead pid) is detected and cleaned up.
+ */
+import { execFileSync, spawn } from "node:child_process";
+import { existsSync, mkdirSync, openSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { DATA_DIR } from "./paths.js";
+const PID_FILE = join(DATA_DIR, "daemon.pid");
+export const LOG_FILE = join(DATA_DIR, "daemon.log");
+const PLIST_LABEL = "com.persnally.daemon";
+const PLIST_PATH = join(homedir(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Returns the running daemon's pid, cleaning up a stale pidfile if found. */
+export function runningPid() {
+    if (!existsSync(PID_FILE))
+        return null;
+    const pid = Number(readFileSync(PID_FILE, "utf-8").trim());
+    if (Number.isInteger(pid) && pid > 0 && alive(pid))
+        return pid;
+    unlinkSync(PID_FILE);
+    return null;
+}
+export function writePidFile() {
+    mkdirSync(DATA_DIR, { recursive: true });
+    writeFileSync(PID_FILE, String(process.pid));
+}
+export function removePidFile() {
+    try {
+        if (Number(readFileSync(PID_FILE, "utf-8").trim()) === process.pid)
+            unlinkSync(PID_FILE);
+    }
+    catch { /* already gone */ }
+}
+export async function startDetached(cliPath, port) {
+    mkdirSync(DATA_DIR, { recursive: true });
+    const log = openSync(LOG_FILE, "a");
+    const child = spawn(process.execPath, [cliPath, "serve", "--port", String(port)], {
+        detached: true,
+        stdio: ["ignore", log, log],
+        env: process.env,
+    });
+    child.unref();
+    for (let i = 0; i < 30; i++) {
+        await sleep(100);
+        try {
+            const r = await fetch(`http://127.0.0.1:${port}/health`);
+            if (r.ok)
+                return child.pid;
+        }
+        catch { /* not up yet */ }
+    }
+    throw new Error(`daemon did not become healthy — check ${LOG_FILE}`);
+}
+export async function stopDaemon() {
+    const pid = runningPid();
+    if (!pid)
+        return null;
+    process.kill(pid, "SIGTERM");
+    for (let i = 0; i < 50; i++) {
+        await sleep(100);
+        if (!alive(pid))
+            return pid;
+    }
+    throw new Error(`daemon (pid ${pid}) did not exit within 5s`);
+}
+export function autostartInstalled() {
+    return existsSync(PLIST_PATH);
+}
+export function installAutostart(cliPath, port) {
+    if (process.platform !== "darwin")
+        throw new Error("autostart is macOS-only for now (launchd)");
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${PLIST_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${process.execPath}</string>
+    <string>${cliPath}</string>
+    <string>serve</string>
+    <string>--port</string>
+    <string>${port}</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${LOG_FILE}</string>
+  <key>StandardErrorPath</key><string>${LOG_FILE}</string>
+</dict>
+</plist>
+`;
+    mkdirSync(join(homedir(), "Library", "LaunchAgents"), { recursive: true });
+    writeFileSync(PLIST_PATH, plist);
+    execFileSync("launchctl", ["load", "-w", PLIST_PATH]);
+    return PLIST_PATH;
+}
+export function removeAutostart() {
+    if (!existsSync(PLIST_PATH))
+        return false;
+    try {
+        execFileSync("launchctl", ["unload", "-w", PLIST_PATH]);
+    }
+    catch { /* not loaded */ }
+    rmSync(PLIST_PATH);
+    return true;
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}

package/build/src/llm.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Structured extraction shared by importers and profile synthesis.
+ * Uses output_config structured outputs (works on every current model,
+ * including Fable 5 where forced tool_choice is not supported).
+ */
+import { z } from "zod";
+export declare const DEFAULT_EXTRACT_MODEL: string;
+export declare const DEFAULT_PROFILE_MODEL: string;
+export type LlmExtract = (opts: {
+    model: string;
+    instruction: string;
+    schema: z.ZodType;
+    content: string;
+    maxTokens?: number;
+}) => Promise<unknown>;
+/** Default extractor backed by the Anthropic API; injectable for tests. */
+export declare const anthropicExtract: LlmExtract;
+export declare const ollamaExtract: LlmExtract;
+export interface ChosenExtractor {
+    extract: LlmExtract;
+    model: string;
+    label: string;
+}
+/** Anthropic key wins (quality); otherwise local Ollama (privacy, zero setup); otherwise guide the user. */
+export declare function chooseExtractor(purpose?: "extract" | "profile"): Promise<ChosenExtractor>;

package/build/src/llm.js

@@ -0,0 +1,76 @@
+/**
+ * Structured extraction shared by importers and profile synthesis.
+ * Uses output_config structured outputs (works on every current model,
+ * including Fable 5 where forced tool_choice is not supported).
+ */
+import Anthropic from "@anthropic-ai/sdk";
+import { zodOutputFormat } from "@anthropic-ai/sdk/helpers/zod";
+import { z } from "zod";
+export const DEFAULT_EXTRACT_MODEL = process.env.PERSNALLY_MODEL ?? "claude-haiku-4-5";
+export const DEFAULT_PROFILE_MODEL = process.env.PERSNALLY_PROFILE_MODEL ?? "claude-fable-5";
+/** Default extractor backed by the Anthropic API; injectable for tests. */
+export const anthropicExtract = async ({ model, instruction, schema, content, maxTokens }) => {
+    const client = new Anthropic();
+    const response = await client.messages.parse({
+        model,
+        max_tokens: maxTokens ?? 4000,
+        system: instruction,
+        output_config: { format: zodOutputFormat(schema) },
+        messages: [{ role: "user", content }],
+    });
+    if (response.stop_reason === "refusal") {
+        throw new Error("Extraction request was refused by the model's safety classifiers");
+    }
+    if (response.parsed_output == null) {
+        throw new Error("Extraction returned no parseable output");
+    }
+    return response.parsed_output;
+};
+// ── Local extraction via Ollama: zero key, zero cloud ───────
+const OLLAMA_URL = process.env.PERSNALLY_OLLAMA_URL ?? "http://127.0.0.1:11434";
+const LOCAL_MODEL_PREFERENCE = ["qwen2.5:14b", "qwen2.5:7b", "llama3.1:8b", "llama3.2", "qwen2.5:1.5b"];
+export const ollamaExtract = async ({ model, instruction, schema, content }) => {
+    const r = await fetch(`${OLLAMA_URL}/api/chat`, {
+        method: "POST",
+        body: JSON.stringify({
+            model,
+            stream: false,
+            format: z.toJSONSchema(schema),
+            messages: [
+                { role: "system", content: instruction },
+                { role: "user", content },
+            ],
+        }),
+    });
+    if (!r.ok)
+        throw new Error(`ollama: ${r.status} ${await r.text()}`);
+    const body = (await r.json());
+    return schema.parse(JSON.parse(body.message?.content ?? "{}"));
+};
+async function localModel() {
+    if (process.env.PERSNALLY_LOCAL_MODEL)
+        return process.env.PERSNALLY_LOCAL_MODEL;
+    try {
+        const r = await fetch(`${OLLAMA_URL}/api/tags`, { signal: AbortSignal.timeout(1500) });
+        const tags = (await r.json()).models?.map((m) => m.name) ?? [];
+        return LOCAL_MODEL_PREFERENCE.find((p) => tags.some((t) => t === p || t === `${p}:latest`)) ?? tags[0] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Anthropic key wins (quality); otherwise local Ollama (privacy, zero setup); otherwise guide the user. */
+export async function chooseExtractor(purpose = "extract") {
+    if (process.env.ANTHROPIC_API_KEY) {
+        const model = purpose === "profile" ? DEFAULT_PROFILE_MODEL : DEFAULT_EXTRACT_MODEL;
+        return { extract: anthropicExtract, model, label: `${model} (Anthropic API)` };
+    }
+    const model = await localModel();
+    if (model) {
+        return { extract: ollamaExtract, model, label: `${model} (local via Ollama — nothing leaves this machine)` };
+    }
+    throw new Error("No extraction engine available. Either:\n" +
+        "  - persnallyd config set-key <sk-ant-…>   (Anthropic API, best quality), or\n" +
+        "  - install Ollama and `ollama pull llama3.2`   (fully local, no key), or\n" +
+        "  - start key-free with: persnallyd import git <path>");
+}

package/build/src/mcp/daemon-client.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Thin HTTP client for persnallyd — the daemon is the single source of truth;
+ * this MCP server is just a protocol adapter in front of it.
+ */
+export declare const DAEMON_HINT = "persnallyd is not running. Start it with `persnallyd serve` (or install: npm i -g persnallyd), then retry.";
+export declare class DaemonUnreachable extends Error {
+    constructor();
+}
+export declare function daemonGet<T>(path: string): Promise<T | null>;
+export declare function daemonPost<T>(path: string, body: unknown): Promise<T>;
+export declare function daemonDelete<T>(path: string): Promise<T>;

package/build/src/mcp/daemon-client.js

@@ -0,0 +1,42 @@
+/**
+ * Thin HTTP client for persnallyd — the daemon is the single source of truth;
+ * this MCP server is just a protocol adapter in front of it.
+ */
+const BASE = process.env.PERSNALLYD_URL ?? "http://127.0.0.1:4983";
+export const DAEMON_HINT = "persnallyd is not running. Start it with `persnallyd serve` (or install: npm i -g persnallyd), then retry.";
+export class DaemonUnreachable extends Error {
+    constructor() { super(DAEMON_HINT); }
+}
+async function request(path, init) {
+    try {
+        return await fetch(BASE + path, init);
+    }
+    catch {
+        throw new DaemonUnreachable();
+    }
+}
+export async function daemonGet(path) {
+    const r = await request(path);
+    // 404 = not present yet; 403 = scoped out for this client. Both mean "no data", not an error.
+    if (r.status === 404 || r.status === 403)
+        return null;
+    if (!r.ok)
+        throw new Error(`daemon ${path}: ${r.status} ${await r.text()}`);
+    return r.json();
+}
+export async function daemonPost(path, body) {
+    const r = await request(path, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    if (!r.ok)
+        throw new Error(`daemon ${path}: ${r.status} ${await r.text()}`);
+    return r.json();
+}
+export async function daemonDelete(path) {
+    const r = await request(path, { method: "DELETE" });
+    if (!r.ok)
+        throw new Error(`daemon ${path}: ${r.status} ${await r.text()}`);
+    return r.json();
+}

package/build/src/mcp/index.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * Persnally MCP server — the protocol adapter between AI clients and persnallyd.
+ *
+ * The daemon owns all state (invariant: one write path, one source of truth);
+ * this server translates MCP tool calls into daemon HTTP calls. Claude IS the
+ * NLP engine: it fills persnally_track's structured schema from conversation
+ * context, so signal extraction costs zero extra inference.
+ */
+export {};

package/build/src/mcp/index.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+/**
+ * Persnally MCP server — the protocol adapter between AI clients and persnallyd.
+ *
+ * The daemon owns all state (invariant: one write path, one source of truth);
+ * this server translates MCP tool calls into daemon HTTP calls. Claude IS the
+ * NLP engine: it fills persnally_track's structured schema from conversation
+ * context, so signal extraction costs zero extra inference.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { DAEMON_HINT, DaemonUnreachable, daemonDelete, daemonGet, daemonPost } from "./daemon-client.js";
+import { migrateV1Graph } from "./migrate-v1.js";
+import { getClient, logEvent, setClient } from "./telemetry.js";
+const server = new McpServer({ name: "persnally", version: "2.0.0" });
+function text(s) {
+    return { content: [{ type: "text", text: s }] };
+}
+async function guarded(fn) {
+    try {
+        return await fn();
+    }
+    catch (e) {
+        return text(e instanceof DaemonUnreachable ? DAEMON_HINT : `Persnally error: ${e instanceof Error ? e.message : e}`);
+    }
+}
+/** Event sources must match ^mcp:[a-z0-9._-]+$ — slugify whatever name the client reports. */
+function clientSlug() {
+    return getClient().toLowerCase().replace(/[^a-z0-9._-]/g, "-");
+}
+/** The north-star metric (context reads/user/week) is measured from these events.
+    Recording must never break the read itself — failures only log to stderr. */
+async function recordRead(scope, purpose, items) {
+    const client = clientSlug();
+    try {
+        await daemonPost("/events", [{
+                type: "context.read",
+                source: `mcp:${client}`,
+                payload: { scope, client_purpose: purpose ?? "", items },
+                provenance: { kind: "mcp", client },
+            }]);
+    }
+    catch (e) {
+        console.error("persnally: context.read not recorded:", e instanceof Error ? e.message : e);
+    }
+}
+// ── persnally_track — write path ────────────────────────────
+server.tool("persnally_track", `Track topics and interests from the current conversation to build the user's personal context.
+
+Call this when the user discusses topics they care about — and when they make a decision, accept or reject an option, or express a clear preference, capture that as its own signal rather than folding it into a broader topic.
+
+GUIDELINES:
+- Extract 1-5 signals per conversation, focused on what the user is ACTIVELY engaged with
+- Weight = how central to the conversation (0.1 brief, 1.0 main focus)
+- Depth: "mention" | "moderate" | "deep" (extensive discussion or problem-solving)
+- Sentiment: "negative" means frustration or dislike (deprioritizes, never boosts)
+- Entities are specific names: "Next.js" not "web framework"
+
+The user opted in. Only structured signals are stored, locally, never raw messages.`, {
+    topics: z.array(z.object({
+        topic: z.string().describe("The topic, decision, or preference (e.g. 'Rust async programming', 'chose SQLite over Postgres')"),
+        weight: z.number().min(0).max(1),
+        intent: z.enum(["learning", "building", "researching", "deciding", "discussing", "debugging"]),
+        sentiment: z.enum(["positive", "negative", "neutral"]),
+        depth: z.enum(["mention", "moderate", "deep"]),
+        category: z.enum(["technology", "business", "finance", "career", "health", "science", "creative", "education", "lifestyle", "news", "other"]),
+        entities: z.array(z.string()),
+    })).min(1),
+}, async ({ topics }) => guarded(async () => {
+    logEvent("tool_call", { tool: "persnally_track", topics: topics.length });
+    const client = clientSlug();
+    const events = topics.map((t) => ({
+        type: "signal.topic",
+        source: `mcp:${client}`,
+        payload: t,
+        provenance: { kind: "mcp", client },
+    }));
+    await daemonPost("/events", events);
+    return text(`Recorded ${topics.length} signal(s): ${topics.map((t) => t.topic).join(", ")}.`);
+}));
+// ── persnally_context — read path (the Phase 2 core) ────────
+server.tool("persnally_context", `Get the user's personal context: who they are, what they're working on, and their current interests.
+
+Call this at the START of a conversation (or when personalization would improve your answer) so your responses fit this specific user instead of a generic one.`, {
+    detail: z.enum(["brief", "full"]).optional().default("brief"),
+    purpose: z.string().max(200).optional().describe("Why context is being read right now, in a short phrase (e.g. 'tailor architecture advice')"),
+}, async ({ detail, purpose }) => guarded(async () => {
+    logEvent("tool_call", { tool: "persnally_context", detail });
+    const client = encodeURIComponent(getClient());
+    const [profile, topics] = await Promise.all([
+        daemonGet(`/profile?client=${client}`),
+        daemonGet(`/topics?limit=${detail === "full" ? 25 : 10}&client=${client}`),
+    ]);
+    if (!profile && !topics?.length) {
+        return text("No context yet — the user hasn't imported data or tracked any signals.");
+    }
+    let out = "";
+    let items = topics?.length ?? 0;
+    if (profile) {
+        out += `# About this user\n${profile.headline}\n\n`;
+        const sections = detail === "full" ? profile.sections : profile.sections.slice(0, 3);
+        items += sections.length;
+        out += sections.map((s) => `## ${s.title}\n${s.body}`).join("\n\n");
+    }
+    if (topics?.length) {
+        out += `\n\n# Current interests (decay-weighted)\n`;
+        out += topics.map((t) => `- ${t.topic} (${t.category}, ${t.dominant_intent}, weight ${t.weight.toFixed(2)})`).join("\n");
+    }
+    await recordRead(detail, purpose, items);
+    return text(out);
+}));
+// ── persnally_interests — transparency view ─────────────────
+server.tool("persnally_interests", `Show the user their own tracked interest profile — what Persnally has learned. Use when the user asks what Persnally knows about them.`, {}, async () => guarded(async () => {
+    logEvent("tool_call", { tool: "persnally_interests" });
+    const [stats, topics] = await Promise.all([
+        daemonGet("/stats"),
+        daemonGet("/topics?limit=20"),
+    ]);
+    if (!topics?.length)
+        return text("Nothing tracked yet. Chat naturally, or import your AI history with `persnallyd import`.");
+    let out = `## Your interest profile\n${stats?.total ?? 0} events, ${topics.length} top topics. Dashboard: http://127.0.0.1:4983\n\n`;
+    for (const t of topics) {
+        const sentiment = t.sentiment_balance > 0.2 ? "+" : t.sentiment_balance < -0.2 ? "−" : "·";
+        out += `- ${t.topic} — ${t.weight.toFixed(2)} (${t.category}, ${t.dominant_intent}, ${sentiment}, ${t.signals}×)\n`;
+    }
+    return text(out);
+}));
+// ── persnally_forget — privacy control ──────────────────────
+server.tool("persnally_forget", `Hard-delete a topic (and everything derived from it) from the user's context, or wipe all data. Privacy control — always honor it.`, {
+    topic: z.string().optional().describe("Topic to remove. Omit with clear_all=true to wipe everything."),
+    clear_all: z.boolean().optional().default(false),
+}, async ({ topic, clear_all }) => guarded(async () => {
+    logEvent("tool_call", { tool: "persnally_forget", clear_all });
+    if (clear_all) {
+        await daemonDelete("/events?confirm=all");
+        return text("All Persnally data deleted. The store is empty.");
+    }
+    if (!topic)
+        return text("Name a topic to forget, or set clear_all.");
+    const r = await daemonDelete(`/topics/${encodeURIComponent(topic)}`);
+    return text(r.deleted ? `Deleted ${r.deleted} event(s) for "${topic}", including derived data.` : `"${topic}" not found.`);
+}));
+// ── start ───────────────────────────────────────────────────
+async function main() {
+    const transport = new StdioServerTransport();
+    server.server.oninitialized = () => {
+        setClient(server.server.getClientVersion()?.name);
+        logEvent("session_start");
+        migrateV1Graph()
+            .then((n) => { if (n > 0)
+            logEvent("v1_migration", { nodes: n }); })
+            .catch(() => { });
+    };
+    await server.connect(transport);
+    console.error("Persnally MCP server v2 running (daemon-backed)");
+}
+main().catch(console.error);

package/build/src/mcp/migrate-v1.d.ts

@@ -0,0 +1,6 @@
+/**
+ * One-time migration of the v1 aggregated interest graph into the event store.
+ * v1 nodes are lossy aggregates, so each becomes a single representative
+ * signal.topic event; the original file is renamed, never deleted.
+ */
+export declare function migrateV1Graph(): Promise<number>;

package/build/src/mcp/migrate-v1.js

@@ -0,0 +1,48 @@
+/**
+ * One-time migration of the v1 aggregated interest graph into the event store.
+ * v1 nodes are lossy aggregates, so each becomes a single representative
+ * signal.topic event; the original file is renamed, never deleted.
+ */
+import { existsSync, readFileSync, renameSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { daemonPost } from "./daemon-client.js";
+const GRAPH_FILE = join(homedir(), ".persnally", "interest-graph.json");
+const INTENTS = new Set(["learning", "building", "researching", "deciding", "discussing", "debugging"]);
+const CATEGORIES = new Set([
+    "technology", "business", "finance", "career", "health",
+    "science", "creative", "education", "lifestyle", "news", "other",
+]);
+export async function migrateV1Graph() {
+    if (!existsSync(GRAPH_FILE))
+        return 0;
+    let nodes;
+    try {
+        nodes = JSON.parse(readFileSync(GRAPH_FILE, "utf-8")).nodes ?? {};
+    }
+    catch {
+        return 0;
+    }
+    const entries = Object.values(nodes);
+    if (entries.length > 0) {
+        const batch = `v1-migration-${Date.now()}`;
+        const events = entries.map((n) => ({
+            type: "signal.topic",
+            source: "system",
+            ts: new Date(n.last_seen).toISOString(),
+            payload: {
+                topic: n.topic,
+                weight: Math.min(Math.max(n.current_weight, 0.05), 1),
+                intent: INTENTS.has(n.dominant_intent) ? n.dominant_intent : "discussing",
+                sentiment: n.sentiment_balance > 0.2 ? "positive" : n.sentiment_balance < -0.2 ? "negative" : "neutral",
+                depth: n.avg_depth >= 0.8 ? "deep" : n.avg_depth >= 0.45 ? "moderate" : "mention",
+                category: CATEGORIES.has(n.category) ? n.category : "other",
+                entities: (n.entities ?? []).slice(0, 20),
+            },
+            provenance: { kind: "import", batch, file: "interest-graph.json" },
+        }));
+        await daemonPost("/events", events);
+    }
+    renameSync(GRAPH_FILE, GRAPH_FILE + ".v1-migrated");
+    return entries.length;
+}

package/build/src/mcp/telemetry.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ */
+export declare function setClient(name: string | undefined): void;
+export declare function getClient(): string;
+export declare function logEvent(event: string, data?: Record<string, unknown>): void;