persnally 2.0.0

package/LICENSE

@@ -0,0 +1,110 @@
+# Functional Source License, Version 1.1, MIT Future License
+
+## Abbreviation
+
+FSL-1.1-MIT
+
+## Notice
+
+Copyright 2026 Persnally
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the MIT license that is effective on the second anniversary of the date we make
+the Software available. On or after that date, you may use the Software under
+the MIT license, in which case the following will apply:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,96 @@
+# Persnally
+
+[![CI](https://github.com/sidpan2011/persnally/actions/workflows/ci.yml/badge.svg)](https://github.com/sidpan2011/persnally/actions/workflows/ci.yml)
+
+**So every AI finally knows you.**
+
+Persnally is a local-first personal context engine. It learns who you are from your AI activity — your Claude and ChatGPT history, your code — and serves that context to every AI tool you use, so they stop treating you like a stranger.
+
+Your context lives on your machine. Not in our cloud, not in any model vendor's silo. You can read every byte, see why it believes each thing, and delete any of it.
+
+> **The giants build the intelligence. Persnally makes it yours.**
+
+## Why
+
+Every AI you use is brilliant and amnesiac. ChatGPT doesn't know what you told Claude. Your coding agent doesn't know your stack or your tolerances. Each one relearns you from zero, every session — or interrupts you to ask.
+
+The fix isn't a better model. It's a layer underneath all of them that holds *you*: your interests, your projects, how you decide, what you're avoiding. The model vendors won't build this — they can't share your context with each other, and their business is keeping you inside their walls. So it has to be neutral, and it has to be yours.
+
+## The five-minute wow
+
+```bash
+npm install -g persnally
+persnallyd start                      # the local daemon
+persnallyd import claude ~/Downloads/<your-claude-export>
+persnallyd import git ~/Projects      # offline, no API needed
+persnallyd profile                    # synthesize who you are
+open http://127.0.0.1:4983            # see it, with evidence for every claim
+```
+
+Export your data ([claude.ai](https://claude.com) / [chatgpt.com](https://chatgpt.com) → Settings → Data export), point Persnally at it, and read a description of yourself that's sharper than your own bio — every sentence traceable to the conversations it came from.
+
+## How it works
+
+```
+  Your AI clients (Claude, Cursor, agents…)        Importers (claude · chatgpt · git)
+        │  MCP: context out, signals in                  │  your history → events
+        ▼                                                ▼
+  ┌──────────────────────── persnallyd (local daemon) ────────────────────────┐
+  │  Append-only event log (SQLite) — the single source of truth              │
+  │      → extractors (decay-weighted interests, assertions, skills)          │
+  │      → derived views (always re-derivable, every claim cites its events)  │
+  └───────────────────────────────┬───────────────────────────────────────────┘
+              loopback only ·  dashboard · CLI · MCP server
+```
+
+- **Event-sourced.** Everything is an append-only event; the profile and interest graph are *derived views* you can rebuild or delete at will.
+- **Provenance-complete.** Every claim in your profile links to the exact events behind it — the dashboard's "why does it think this?" is a real answer, not a guess.
+- **Truly deletable.** `persnallyd forget <topic>` hard-deletes the events *and* everything derived from them. No tombstones, no residue.
+- **Deterministic reads.** Serving context to an AI never calls a model — it's instant, free, and works offline. Models run only at import and synthesis.
+
+## Make your AI tools use it
+
+Add the MCP server to any client (Claude Desktop, Cursor, Claude Code). It exposes four tools backed by the daemon:
+
+| Tool | What it does |
+|------|-------------|
+| `persnally_context` | Returns who you are + current interests, for the AI to use |
+| `persnally_track` | Records signals from the conversation (topics, decisions, preferences) |
+| `persnally_interests` | Shows you your own tracked profile |
+| `persnally_forget` | Deletes a topic, or wipes everything |
+
+```jsonc
+// e.g. Claude Desktop — claude_desktop_config.json
+{ "mcpServers": { "persnally": { "command": "persnally-mcp" } } }
+```
+
+## Your data, your rules
+
+- **Local-first.** State lives in `~/.persnally`. Nothing leaves your machine except, at import/synthesis, the text you choose to send to your own LLM for extraction (bring your own key).
+- **Structured signals only.** Raw conversations are never stored — only `{ topic, weight, intent, sentiment, category, … }` and provenance pointers.
+- **Inspectable & deletable.** The dashboard shows everything; the delete button means it.
+- **Source-available.** Read the engine, audit the claims, run it yourself.
+
+## CLI
+
+```
+persnallyd start | stop | status        # daemon lifecycle
+persnallyd autostart [--remove]          # run at login (macOS)
+persnallyd import claude|chatgpt|git <path>
+persnallyd profile                       # synthesize the profile
+persnallyd show [topics|events|profile]
+persnallyd forget <topic> | --all | --batch <id>
+persnallyd config set-key <sk-ant-…>     # key for the background daemon
+```
+
+## Status
+
+Early and moving fast — see [ROADMAP.md](./ROADMAP.md). Today: import from Claude/ChatGPT/git, a decay-weighted interest graph, an evidence-linked profile, a local dashboard, and the MCP layer that serves it all. Next: cross-tool context everywhere, then a behavior model that can answer *what would I do here?*
+
+## License
+
+[FSL-1.1-MIT](./LICENSE) — read it, audit it, run it, fork it for anything except reselling it as a competing service. Every release automatically becomes plain MIT two years after it ships. The [event schema](./docs/EVENT_SCHEMA.md) and MCP interface are an open spec — build against them freely.
+
+## Contributing
+
+Issues and PRs welcome. The codebase holds itself to a high bar — see [CONTRIBUTING.md](./CONTRIBUTING.md).

package/build/src/cli.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * persnallyd CLI — the developer's window into the daemon.
+ * Merges into the `persnally` npm identity at Phase 1 launch.
+ */
+export {};

package/build/src/cli.js

@@ -0,0 +1,404 @@
+#!/usr/bin/env node
+/**
+ * persnallyd CLI — the developer's window into the daemon.
+ * Merges into the `persnally` npm identity at Phase 1 launch.
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { applyApiKey, configPath, loadConfig, saveConfig } from "./config.js";
+import { CLIENTS, connectAll, connectClient } from "./connect.js";
+import { runConsolidation } from "./consolidate.js";
+import { chooseExtractor } from "./llm.js";
+import { CATEGORIES, clearScope, loadScopes, setScope } from "./permissions.js";
+import { alreadyImported, DENSITY_QUESTIONS, detectExports, eventsFromAnswers, isThin, markImported } from "./setup.js";
+import { DEFAULT_PORT, startDaemon, VERSION } from "./daemon.js";
+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 { autostartInstalled, installAutostart, LOG_FILE, removeAutostart, removePidFile, runningPid, startDetached, stopDaemon, writePidFile, } from "./lifecycle.js";
+import { renderProfile, synthesizeProfile } from "./profile.js";
+import { DEFAULT_DB_PATH, EventStore } from "./store.js";
+const USAGE = `persnallyd ${VERSION} — so every AI finally knows you
+
+Usage:
+  persnallyd setup                  One command: find exports, import, synthesize, connect, open
+  persnallyd connect [client|--all] Add Persnally to claude-code | claude-desktop | cursor
+  persnallyd scope <client> <categories|--clear>   Limit what a client can read (e.g. scope cursor technology,career)
+  persnallyd scope                  Show all client scopes
+  persnallyd init                   Create the local store (~/.persnally/persnally.db)
+  persnallyd import claude <dir>    Import a Claude data export (needs ANTHROPIC_API_KEY)
+  persnallyd import claude-code [dir]  Import Claude Code session transcripts (default ~/.claude/projects)
+  persnallyd import chatgpt <path>  Import a ChatGPT export dir or conversations.json (needs ANTHROPIC_API_KEY)
+  persnallyd import git <path> [--author <email>]   Import repo activity (offline, no LLM); path = repo or folder of repos
+  persnallyd profile                Synthesize your profile from the store
+  persnallyd consolidate            Reflect now: refresh decay, add behavior patterns, re-synthesize
+  persnallyd show [topics|events|profile]   Show topics (default), recent events, or the profile
+  persnallyd forget <topic>         Hard-delete a topic and everything derived from it
+  persnallyd forget --all           Delete all data
+  persnallyd forget --batch <id>    Undo one import batch
+  persnallyd status                 Store stats and daemon health
+  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})
+  persnallyd autostart [--remove]   Start the daemon at login and keep it alive (macOS)
+  persnallyd config set-key <key>   Store the Anthropic API key (owner-only file) for the daemon
+  persnallyd config                 Show config (key masked)
+`;
+function parsePort(args) {
+    const i = args.indexOf("--port");
+    return i > -1 && args[i + 1] ? Number(args[i + 1]) : DEFAULT_PORT;
+}
+async function main() {
+    const [cmd, ...args] = process.argv.slice(2);
+    applyApiKey();
+    switch (cmd) {
+        case "setup": {
+            const port = parsePort(args);
+            console.log("Persnally setup — so every AI finally knows you.\n");
+            // 1. Extraction engine (optional — git-only works without one)
+            let engine = null;
+            try {
+                engine = await chooseExtractor("extract");
+                console.log(`✓ Extraction engine: ${engine.label}`);
+            }
+            catch {
+                console.log("· No extraction engine (no API key, no Ollama) — conversation imports skipped, git still works.");
+            }
+            // 2. Daemon
+            if (!runningPid()) {
+                await startDetached(process.argv[1], port);
+                console.log(`✓ Daemon started (http://127.0.0.1:${port})`);
+            }
+            else {
+                console.log("✓ Daemon already running");
+            }
+            // 3. Conversation exports from ~/Downloads (zipped or unzipped)
+            const store = new EventStore();
+            let imported = 0;
+            for (const found of detectExports()) {
+                if (alreadyImported(found.origin)) {
+                    console.log(`· Skipping ${found.origin} (already imported)`);
+                }
+                else if (engine) {
+                    console.log(`→ Importing ${found.kind} export: ${found.origin}`);
+                    const parsed = found.kind === "claude" ? parseClaudeExport(found.path) : parseChatGPTExport(found.path);
+                    const result = found.kind === "claude"
+                        ? await extractClaudeEvents(parsed, engine.extract, engine.model)
+                        : await extractChatGPTEvents(parsed, engine.extract, engine.model);
+                    store.append(result.events);
+                    markImported(found.origin);
+                    imported += result.events.length;
+                    console.log(`  ✓ ${result.events.length} events`);
+                }
+                if (found.cleanup)
+                    rmSync(found.cleanup, { recursive: true, force: true });
+            }
+            // 3b. Claude Code transcripts — local, no export wait. Capped at the 50 most
+            // recent sessions so setup stays fast; full history via `import claude-code`.
+            if (engine && existsSync(DEFAULT_TRANSCRIPTS_DIR) && !alreadyImported(DEFAULT_TRANSCRIPTS_DIR)) {
+                const { parsed, sessionsFound, sessionsDropped } = parseClaudeCodeTranscripts(DEFAULT_TRANSCRIPTS_DIR, 50);
+                if (parsed.conversations.length) {
+                    console.log(`→ Importing Claude Code transcripts: ${parsed.conversations.length} session(s)` +
+                        (sessionsDropped ? ` (most recent of ${sessionsFound} — full history: persnallyd import claude-code)` : ""));
+                    const result = await extractClaudeCodeEvents(parsed, engine.extract, engine.model);
+                    store.append(result.events);
+                    markImported(DEFAULT_TRANSCRIPTS_DIR);
+                    imported += result.events.length;
+                    console.log(`  ✓ ${result.events.length} events`);
+                }
+            }
+            // 4. Git activity from ~/Projects
+            const projects = join(homedir(), "Projects");
+            if (existsSync(projects) && !alreadyImported(projects)) {
+                const summaries = scanRepos(projects);
+                if (summaries.length) {
+                    const { events } = gitEvents(summaries);
+                    store.append(events);
+                    markImported(projects);
+                    imported += events.length;
+                    console.log(`✓ Imported ${summaries.length} git repo(s) from ~/Projects (${events.length} events, fully offline)`);
+                }
+            }
+            store.rebuild();
+            // 4b. Density floor — if everything is still thin, two questions beat an empty mirror
+            const signalCount = store.stats().byType["signal.topic"] ?? 0;
+            if (isThin(signalCount) && process.stdin.isTTY) {
+                console.log("\nYour history is light — two quick questions so Persnally starts with something real:");
+                const { createInterface } = await import("node:readline/promises");
+                const rl = createInterface({ input: process.stdin, output: process.stdout });
+                const answers = [];
+                for (const q of DENSITY_QUESTIONS)
+                    answers.push(await rl.question(`  ${q}\n  > `));
+                rl.close();
+                const seeds = await eventsFromAnswers(answers, engine);
+                if (seeds.length) {
+                    store.append(seeds);
+                    store.rebuild();
+                    imported += seeds.length;
+                    console.log(`  ✓ Seeded ${seeds.length} signal(s) from your answers`);
+                }
+            }
+            // 5. Profile
+            if (engine && store.stats().total > 0) {
+                console.log("→ Synthesizing your profile…");
+                const profileEngine = await chooseExtractor("profile");
+                await synthesizeProfile(store, profileEngine.extract, profileEngine.model);
+                console.log("  ✓ Profile ready");
+            }
+            store.close();
+            // 6. AI clients
+            for (const { client, file } of connectAll()) {
+                console.log(file ? `✓ Connected ${client}` : `· ${client} not installed — skipped`);
+            }
+            console.log(`\nDone${imported ? ` — ${imported} events imported` : ""}. Dashboard: http://127.0.0.1:${port}`);
+            if (process.platform === "darwin" && process.stdout.isTTY) {
+                try {
+                    execFileSync("open", [`http://127.0.0.1:${port}`]);
+                }
+                catch { /* non-fatal */ }
+            }
+            return;
+        }
+        case "scope": {
+            const [client, spec] = args;
+            if (!client) {
+                const scopes = loadScopes();
+                const entries = Object.entries(scopes);
+                if (!entries.length) {
+                    console.log("No client scopes — every connected client sees everything.");
+                    return;
+                }
+                for (const [c, cats] of entries)
+                    console.log(`${c}: ${cats.join(", ")}`);
+                return;
+            }
+            if (!spec)
+                return die("usage: persnallyd scope <client> <cat1,cat2|--clear>");
+            if (spec === "--clear") {
+                console.log(clearScope(client) ? `Cleared scope for ${client} — it now sees everything.` : `${client} had no scope.`);
+                return;
+            }
+            const cats = spec.split(",").map((c) => c.trim()).filter(Boolean);
+            const invalid = cats.filter((c) => !CATEGORIES.includes(c));
+            if (invalid.length)
+                return die(`unknown categor${invalid.length > 1 ? "ies" : "y"}: ${invalid.join(", ")}\nvalid: ${CATEGORIES.join(", ")}`);
+            setScope(client, cats);
+            console.log(`${client} can now read only: ${cats.join(", ")}. Restart that client to apply.`);
+            return;
+        }
+        case "connect": {
+            const target = args[0] === "--all" || !args[0] ? null : args[0];
+            if (target && !CLIENTS.includes(target))
+                return die(`unknown client — use ${CLIENTS.join(" | ")} | --all`);
+            const results = target ? [{ client: target, file: connectClient(target) }] : connectAll();
+            for (const { client, file } of results) {
+                console.log(file ? `Connected ${client} (${file})` : `${client} not installed — skipped`);
+            }
+            return;
+        }
+        case "config": {
+            if (args[0] === "set-key") {
+                if (!args[1]?.startsWith("sk-ant-"))
+                    return die("expected an Anthropic key (sk-ant-...)");
+                saveConfig({ anthropic_api_key: args[1] });
+                console.log(`Key saved to ${configPath()} (mode 600). Restart the daemon to apply: persnallyd stop`);
+                return;
+            }
+            const cfg = loadConfig();
+            const key = typeof cfg.anthropic_api_key === "string" ? cfg.anthropic_api_key : "";
+            console.log(`Config: ${configPath()}`);
+            console.log(`anthropic_api_key: ${key ? key.slice(0, 12) + "…" + key.slice(-4) : "(not set)"}`);
+            return;
+        }
+        case "init": {
+            const store = new EventStore();
+            store.close();
+            console.log(`Initialized ${DEFAULT_DB_PATH}`);
+            return;
+        }
+        case "import": {
+            const [kind, path] = args;
+            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") {
+                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));
+            }
+            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));
+            }
+            else {
+                return die(`unknown import source "${kind}" — use claude, claude-code, chatgpt, or git`);
+            }
+            const store = new EventStore();
+            store.append(events);
+            store.rebuild();
+            store.close();
+            console.log(`Imported ${events.length} events (batch ${batch}).`);
+            console.log(`Undo with: persnallyd forget --batch ${batch}`);
+            return;
+        }
+        case "consolidate": {
+            const engine = await chooseExtractor("extract").catch(() => null);
+            const store = new EventStore();
+            const r = await runConsolidation(store, engine);
+            store.close();
+            console.log(`Consolidation: ${r.newSignals} new signal(s) since last run, ${r.assertions} behavior assertion(s) added, profile ${r.profileRefreshed ? "refreshed" : "unchanged"}.`);
+            return;
+        }
+        case "profile": {
+            const engine = await chooseExtractor("profile");
+            const store = new EventStore();
+            console.error(`Synthesizing profile with ${engine.label}...`);
+            const profile = await synthesizeProfile(store, engine.extract, engine.model);
+            store.close();
+            console.log(renderProfile(profile));
+            return;
+        }
+        case "show": {
+            const store = new EventStore();
+            if (args[0] === "profile") {
+                const p = store.getProfile();
+                console.log(p ? renderProfile(p) : "No profile yet. Run: persnallyd profile");
+            }
+            else if (args[0] === "events") {
+                for (const e of store.query({ limit: 20 })) {
+                    console.log(`${e.ts}  ${e.type.padEnd(18)} ${e.source.padEnd(16)} ${summarize(e.payload)}`);
+                }
+            }
+            else {
+                const topics = store.topics(25);
+                if (!topics.length)
+                    console.log("No topics yet. Run an import or connect an MCP client.");
+                for (const t of topics) {
+                    console.log(`${t.weight.toFixed(2).padStart(6)}  ${t.topic} (${t.category}, ${t.signals} signals)`);
+                }
+            }
+            store.close();
+            return;
+        }
+        case "forget": {
+            const store = new EventStore();
+            if (args[0] === "--all") {
+                store.forgetAll();
+                console.log("All data deleted.");
+            }
+            else if (args[0] === "--batch" && args[1]) {
+                console.log(`Deleted ${store.forgetBatch(args[1])} events from batch ${args[1]}.`);
+            }
+            else if (args[0]) {
+                console.log(`Deleted ${store.forgetTopic(args[0])} events for "${args[0]}".`);
+            }
+            else {
+                die("usage: persnallyd forget <topic> | --all | --batch <id>");
+            }
+            store.close();
+            return;
+        }
+        case "status": {
+            const store = new EventStore();
+            const s = store.stats();
+            store.close();
+            console.log(`Store: ${DEFAULT_DB_PATH}`);
+            console.log(`Events: ${s.total} (${s.first ?? "—"} → ${s.last ?? "—"})`);
+            for (const [t, n] of Object.entries(s.byType))
+                console.log(`  ${t}: ${n}`);
+            const pid = runningPid();
+            console.log(pid ? `Daemon: running (pid ${pid})` : "Daemon: not running");
+            console.log(`Autostart: ${autostartInstalled() ? "installed" : "not installed"}`);
+            return;
+        }
+        case "start": {
+            const existing = runningPid();
+            if (existing)
+                return die(`daemon already running (pid ${existing})`);
+            const pid = await startDetached(process.argv[1], parsePort(args));
+            console.log(`persnallyd started (pid ${pid}). Dashboard: http://127.0.0.1:${parsePort(args)}`);
+            console.log(`Logs: ${LOG_FILE}`);
+            return;
+        }
+        case "stop": {
+            if (autostartInstalled()) {
+                console.error("Note: autostart is installed — launchd will restart the daemon. Use `persnallyd autostart --remove` to stop it permanently.");
+            }
+            const pid = await stopDaemon();
+            console.log(pid ? `Stopped daemon (pid ${pid}).` : "Daemon was not running.");
+            return;
+        }
+        case "autostart": {
+            if (args[0] === "--remove") {
+                console.log(removeAutostart() ? "Autostart removed; daemon stopped." : "Autostart was not installed.");
+                return;
+            }
+            // A running daemon holds the pidfile and would put launchd in a retry loop — hand over first.
+            const stopped = await stopDaemon();
+            if (stopped)
+                console.log(`Stopped existing daemon (pid ${stopped}) — launchd takes over.`);
+            const plist = installAutostart(process.argv[1], parsePort(args));
+            console.log(`Autostart installed (${plist}). The daemon now runs at login and restarts if it exits.`);
+            return;
+        }
+        case "serve": {
+            const existing = runningPid();
+            if (existing)
+                return die(`daemon already running (pid ${existing}) — stop it first`);
+            const port = parsePort(args);
+            const store = new EventStore();
+            const server = startDaemon(store, port);
+            server.on("error", (e) => {
+                die(e.code === "EADDRINUSE" ? `port ${port} is already in use` : e.message);
+            });
+            writePidFile();
+            const shutdown = () => {
+                server.close();
+                store.close();
+                removePidFile();
+                process.exit(0);
+            };
+            process.on("SIGTERM", shutdown);
+            process.on("SIGINT", shutdown);
+            console.error(`persnallyd v${VERSION} listening on 127.0.0.1:${port}`);
+            console.error(`Dashboard: http://127.0.0.1:${port}`);
+            return;
+        }
+        default:
+            console.log(USAGE);
+            process.exitCode = cmd ? 1 : 0;
+    }
+}
+function summarize(payload) {
+    const s = JSON.stringify(payload);
+    return s.length > 80 ? s.slice(0, 77) + "..." : s;
+}
+function die(msg) {
+    console.error(msg);
+    process.exit(1);
+}
+main().catch((e) => die(e instanceof Error ? e.message : String(e)));

package/build/src/config.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Daemon config at ~/.persnally/config.json — most importantly the Anthropic
+ * key, so the launchd-run daemon (no shell env) can synthesize. Unknown fields
+ * are preserved (the file predates v2). Saved with owner-only permissions.
+ */
+export declare function loadConfig(): Record<string, unknown>;
+export declare function saveConfig(updates: Record<string, unknown>): void;
+/** Env wins over config; sets process.env so the Anthropic SDK picks it up. */
+export declare function applyApiKey(): boolean;
+export declare function configPath(): string;

package/build/src/config.js

@@ -0,0 +1,42 @@
+/**
+ * Daemon config at ~/.persnally/config.json — most importantly the Anthropic
+ * key, so the launchd-run daemon (no shell env) can synthesize. Unknown fields
+ * are preserved (the file predates v2). Saved with owner-only permissions.
+ */
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { DATA_DIR } from "./paths.js";
+// Resolved at call time so PERSNALLY_DIR overrides work in-process (tests), not just for subprocesses.
+function configFile() {
+    return join(process.env.PERSNALLY_DIR ?? DATA_DIR, "config.json");
+}
+export function loadConfig() {
+    try {
+        return JSON.parse(readFileSync(configFile(), "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function saveConfig(updates) {
+    const file = configFile();
+    mkdirSync(dirname(file), { recursive: true });
+    const merged = { ...loadConfig(), ...updates };
+    writeFileSync(file, JSON.stringify(merged, null, 2) + "\n");
+    chmodSync(file, 0o600);
+}
+/** Env wins over config; sets process.env so the Anthropic SDK picks it up. */
+export function applyApiKey() {
+    if (process.env.ANTHROPIC_API_KEY)
+        return true;
+    const key = loadConfig().anthropic_api_key;
+    if (typeof key === "string" && key.startsWith("sk-ant-")) {
+        process.env.ANTHROPIC_API_KEY = key;
+        return true;
+    }
+    return false;
+}
+export function configPath() {
+    const file = configFile();
+    return existsSync(file) ? file : `${file} (not created yet)`;
+}