persnally 2.3.0 → 2.3.2

package/build/src/cli.js

@@ -13,7 +13,7 @@ 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 { autoImportNewSessions, 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";
@@ -373,6 +373,11 @@ async function main() {
                     out.push(`- ${t.topic} (${t.category}, ${t.dominant_intent}, weight ${t.weight.toFixed(2)})`);
                 }
             }
+            // Hook-only: ask Claude to call persnally_track once at session end so
+            // live capture actually accrues. Not shown in plain `context` output.
+            if (hook) {
+                out.push("", "# Persnally — end-of-session", "When this session ends, call persnally_track with 1–3 topics it focused on (weight, intent, depth, category). Skip only if nothing substantial was discussed.");
+            }
             // Recording must never break the injection itself (mirrors MCP recordRead).
             try {
                 store.append([newEvent("context.read", "cli", { scope: full ? "full" : "brief", client_purpose: hook ? "session-start hook" : "cli context read", items }, { kind: "local", surface: "cli" })]);
@@ -479,6 +484,8 @@ async function main() {
             process.on("uncaughtException", (e) => { console.error("uncaughtException:", e); process.exit(1); });
             console.error(`persnallyd v${VERSION} listening on 127.0.0.1:${port}`);
             console.error(`Dashboard: http://127.0.0.1:${port}`);
+            // Catch up on chats since the daemon last ran; the timer takes it from here.
+            void autoImportNewSessions(store);
             return;
         }
         default:

package/build/src/daemon.d.ts

@@ -7,3 +7,10 @@ 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;
+/**
+ * Ingest Claude Code sessions created since the last pass — the daemon's
+ * automatic capture of new chats (no user action, no per-session hook). A
+ * key-less, Ollama-less machine has no extractor: skip rather than block.
+ * Never throws — capture must not take the daemon down.
+ */
+export declare function autoImportNewSessions(store: EventStore): Promise<void>;

package/build/src/daemon.js

@@ -8,6 +8,7 @@ import { loadConfig } from "./config.js";
 import { runConsolidation, shouldRunNow } from "./consolidate.js";
 import { allowedCategories, loadScopes } from "./permissions.js";
 import { newEvent, validateEvent } from "./events.js";
+import { importNewClaudeCodeSessions } from "./importers/claude-code.js";
 import { chooseExtractor } from "./llm.js";
 import { synthesizeProfile } from "./profile.js";
 export const DEFAULT_PORT = 4983;
@@ -131,8 +132,9 @@ export function startDaemon(store, port = DEFAULT_PORT) {
         }
     });
     server.listen(port, "127.0.0.1");
-    // Nightly reflection: check every 30 min, run once per day at/after the consolidation hour.
+    // Every 30 min: pick up new Claude Code chats, then run the once-a-day reflection.
     const timer = setInterval(async () => {
+        await autoImportNewSessions(store);
         const lastRun = loadConfig().last_consolidation;
         if (!shouldRunNow(typeof lastRun === "string" ? lastRun : undefined, new Date()))
             return;
@@ -149,6 +151,27 @@ export function startDaemon(store, port = DEFAULT_PORT) {
     server.on("close", () => clearInterval(timer));
     return server;
 }
+/**
+ * Ingest Claude Code sessions created since the last pass — the daemon's
+ * automatic capture of new chats (no user action, no per-session hook). A
+ * key-less, Ollama-less machine has no extractor: skip rather than block.
+ * Never throws — capture must not take the daemon down.
+ */
+export async function autoImportNewSessions(store) {
+    try {
+        const engine = await chooseExtractor("extract").catch(() => null);
+        if (!engine)
+            return;
+        const r = await importNewClaudeCodeSessions(store, engine.extract, engine.model);
+        if (r.events) {
+            store.rebuild();
+            console.error(`auto-import: ${r.newSessions} new Claude Code session(s) → ${r.events} events`);
+        }
+    }
+    catch (e) {
+        console.error("auto-import failed:", e instanceof Error ? e.message : e);
+    }
+}
 let cachedHtml;
 function dashboardHtml() {
     cachedHtml ??= readFileSync(new URL("./dashboard.html", import.meta.url), "utf-8");

package/build/src/importers/claude-code.d.ts

@@ -4,6 +4,7 @@
  * (Phase 0 finding), and available immediately with no export wait.
  */
 import { type LlmExtract } from "../llm.js";
+import type { EventStore } from "../store.js";
 import { type ImportResult, type ParsedExport } from "./extract.js";
 export declare const DEFAULT_TRANSCRIPTS_DIR: string;
 export declare const DEFAULT_MAX_SESSIONS = 200;
@@ -14,3 +15,16 @@ export interface ClaudeCodeParse {
 }
 export declare function parseClaudeCodeTranscripts(root?: string, maxSessions?: number): ClaudeCodeParse;
 export declare function extractClaudeCodeEvents(parsed: ParsedExport, extract?: LlmExtract, model?: string, file?: string): Promise<ImportResult>;
+export interface IncrementalImport {
+    newSessions: number;
+    events: number;
+    skipped: number;
+}
+/**
+ * Import only the Claude Code sessions not already in the store — the path the
+ * daemon runs on its loop so new chats accrue without re-extracting old ones.
+ * Sessions are matched by the conversation_uuid recorded in each topic's
+ * provenance; a session that yields zero topics leaves no marker and may be
+ * retried, which is cheap and rare (a real session produces topics).
+ */
+export declare function importNewClaudeCodeSessions(store: EventStore, extract: LlmExtract, model?: string, root?: string): Promise<IncrementalImport>;

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

@@ -97,3 +97,32 @@ function humanText(content) {
 export async function extractClaudeCodeEvents(parsed, extract = anthropicExtract, model = DEFAULT_EXTRACT_MODEL, file = DEFAULT_TRANSCRIPTS_DIR) {
     return extractEvents(parsed, { source: "import:claude-code", importer: "claude-code", file }, extract, model);
 }
+/**
+ * Import only the Claude Code sessions not already in the store — the path the
+ * daemon runs on its loop so new chats accrue without re-extracting old ones.
+ * Sessions are matched by the conversation_uuid recorded in each topic's
+ * provenance; a session that yields zero topics leaves no marker and may be
+ * retried, which is cheap and rare (a real session produces topics).
+ */
+export async function importNewClaudeCodeSessions(store, extract, model = DEFAULT_EXTRACT_MODEL, root = DEFAULT_TRANSCRIPTS_DIR) {
+    if (!existsSync(root))
+        return { newSessions: 0, events: 0, skipped: 0 };
+    const { parsed } = parseClaudeCodeTranscripts(root);
+    const seen = importedConversationUuids(store);
+    const fresh = parsed.conversations.filter((c) => !seen.has(c.uuid));
+    const skipped = parsed.conversations.length - fresh.length;
+    if (!fresh.length)
+        return { newSessions: 0, events: 0, skipped };
+    const { events } = await extractClaudeCodeEvents({ ...parsed, conversations: fresh }, extract, model, root);
+    store.append(events);
+    return { newSessions: fresh.length, events: events.length, skipped };
+}
+function importedConversationUuids(store) {
+    const uuids = new Set();
+    for (const e of store.query({ source: "import:claude-code", limit: 1_000_000 })) {
+        const uuid = e.provenance.conversation_uuid;
+        if (uuid)
+            uuids.add(uuid);
+    }
+    return uuids;
+}

package/build/src/importers/extract.js

@@ -18,19 +18,27 @@ export async function extractEvents(parsed, opts, extract = anthropicExtract, mo
         if (!convo.userMessages.length)
             continue;
         const joined = convo.userMessages.join("\n");
-        voiceCorpus.push(...proseLines(joined));
+        voiceCorpus.push(...proseLines(joined)); // prose feeds the deterministic voice fingerprint even if topic extraction fails
         const text = stripNoise(joined).slice(0, MAX_CONVO_CHARS); // strip pasted paths/URLs/logs before the LLM sees it
         if (!text)
             continue;
-        const result = await extract({
-            model,
-            instruction: "Extract 1-5 topic signals from this conversation's user messages. Weight = centrality, depth = engagement level, sentiment = user's attitude toward the topic. Capture decisions and rejected options as their own signals.",
-            schema: topicsExtraction,
-            content: `Conversation title: ${convo.name}\n\nUser messages:\n${text}`,
-        });
-        const { topics } = topicsExtraction.parse(result);
-        for (const t of topics) {
-            events.push(newEvent("signal.topic", opts.source, t, { kind: "import", batch, file: opts.file, conversation_uuid: convo.uuid }, safeIso(convo.created_at)));
+        try {
+            const result = await extract({
+                model,
+                instruction: "Extract 1-5 topic signals from this conversation's user messages. Weight = centrality, depth = engagement level, sentiment = user's attitude toward the topic. Capture decisions and rejected options as their own signals.",
+                schema: topicsExtraction,
+                content: `Conversation title: ${convo.name}\n\nUser messages:\n${text}`,
+            });
+            const { topics } = topicsExtraction.parse(result);
+            for (const t of topics) {
+                events.push(newEvent("signal.topic", opts.source, t, { kind: "import", batch, file: opts.file, conversation_uuid: convo.uuid }, safeIso(convo.created_at)));
+            }
+        }
+        catch (e) {
+            // One malformed extraction (e.g. the model returns an out-of-enum value)
+            // must not abort a whole multi-conversation import. Skip it — leaving no
+            // conversation_uuid marker, so the next pass retries it — and keep the rest.
+            console.error(`extract: skipped "${convo.name}" — ${(e instanceof Error ? e.message : String(e)).split("\n")[0]}`);
         }
     }
     if (parsed.memoryText.trim() || parsed.projects.length) {
@@ -38,15 +46,21 @@ export async function extractEvents(parsed, opts, extract = anthropicExtract, mo
             parsed.memoryText.trim() && `Assistant's accumulated memory of the user:\n${parsed.memoryText}`,
             parsed.projects.length && `User-created projects:\n${parsed.projects.map((p) => `- ${p.name}: ${p.description}`).join("\n")}`,
         ].filter(Boolean).join("\n\n");
-        const result = await extract({
-            model,
-            instruction: "Extract structured assertions about this person: facts, preferences, behaviors, skills, and context. Confidence reflects how directly the source supports the claim.",
-            schema: assertionsExtraction,
-            content: context,
-        });
-        const { assertions } = assertionsExtraction.parse(result);
-        for (const a of assertions) {
-            events.push(newEvent("signal.assertion", opts.source, a, { kind: "import", batch, file: opts.file }));
+        try {
+            const result = await extract({
+                model,
+                instruction: "Extract structured assertions about this person: facts, preferences, behaviors, skills, and context. Confidence reflects how directly the source supports the claim.",
+                schema: assertionsExtraction,
+                content: context,
+            });
+            const { assertions } = assertionsExtraction.parse(result);
+            for (const a of assertions) {
+                events.push(newEvent("signal.assertion", opts.source, a, { kind: "import", batch, file: opts.file }));
+            }
+        }
+        catch (e) {
+            // A malformed assertions response shouldn't discard the topics already gathered.
+            console.error(`extract: skipped memory/projects assertions — ${(e instanceof Error ? e.message : String(e)).split("\n")[0]}`);
         }
     }
     // Deterministic voice fingerprint over the user's own prose — no LLM, no tokens.

package/package.json

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