personal-ai 0.1.0 → 0.2.0

package/dist/entry.mjs

@@ -10,9 +10,9 @@ import { google } from "googleapis";
 import open from "open";
 import chalk from "chalk";
 import ora from "ora";
+import { execFile } from "node:child_process";
 import JSON5 from "json5";
 import { z } from "zod";
-import { execFile } from "node:child_process";
 import matter from "gray-matter";
 import OpenAI from "openai";
 import { minimatch } from "minimatch";
@@ -21,6 +21,23 @@ import { Agent } from "@mariozechner/pi-agent-core";
 import { getModel } from "@mariozechner/pi-ai";
 import { Type } from "@sinclair/typebox";
 
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
 //#region src/config/paths.ts
 /** Root data directory for pai */
 function getPaiHome() {
@@ -32,6 +49,20 @@ function getRawDir() {
 function getVaultDir() {
 	return path.join(getPaiHome(), "vault");
 }
+function getMemoryDir() {
+	return path.join(getPaiHome(), "memory");
+}
+function getWeeklyDir() {
+	return path.join(getMemoryDir(), "weekly");
+}
+/** Get the journal file path for a given date (YYYY-MM-DD) */
+function getJournalPath(date) {
+	return path.join(getMemoryDir(), `${date}.md`);
+}
+/** Get today's date as YYYY-MM-DD */
+function getTodayDate() {
+	return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+}
 function getSkillsDir() {
 	return path.join(getPaiHome(), "skills", "profiles");
 }
@@ -54,6 +85,10 @@ function getProfilePath() {
 
 //#endregion
 //#region src/auth/encryption.ts
+var encryption_exports = /* @__PURE__ */ __exportAll({
+	Encryption: () => Encryption,
+	encryption: () => encryption
+});
 const ALGORITHM = "aes-256-gcm";
 const KEY_LENGTH = 32;
 const IV_LENGTH = 16;
@@ -150,13 +185,17 @@ function bold(message) {
 
 //#endregion
 //#region src/auth/google-oauth.ts
+var google_oauth_exports = /* @__PURE__ */ __exportAll({
+	GoogleOAuth: () => GoogleOAuth,
+	googleOAuth: () => googleOAuth
+});
 const SCOPES = [
 	"https://www.googleapis.com/auth/gmail.readonly",
 	"https://www.googleapis.com/auth/gmail.send",
 	"https://www.googleapis.com/auth/calendar.readonly"
 ];
 const REDIRECT_URI = "http://localhost:8888/callback";
-const CALLBACK_TIMEOUT_MS = 120 * 1e3;
+const CALLBACK_TIMEOUT_MS = 300 * 1e3;
 /**
 * Embedded OAuth client credentials for Desktop/CLI app.
 * Google explicitly states that for "installed" (desktop) applications,
@@ -276,6 +315,12 @@ var GoogleOAuth = class {
 		if (!this.oauth2Client) throw new Error("OAuth client not initialized");
 		return this.oauth2Client;
 	}
+	/** Returns true if user has valid credentials (access_token or refresh_token). */
+	isAuthenticated() {
+		if (!this.oauth2Client) return false;
+		const creds = this.oauth2Client.credentials;
+		return Boolean(creds.access_token || creds.refresh_token);
+	}
 	async ensureAuthenticated() {
 		if (!this.oauth2Client || !this.oauth2Client.credentials.access_token) throw new Error("Not authenticated. Run: pai auth google");
 		const now = Date.now();
@@ -505,6 +550,14 @@ function updateRawFrontmatter(fileContent, updates) {
 
 //#endregion
 //#region src/raw/add.ts
+var add_exports = /* @__PURE__ */ __exportAll({
+	addConnectorEntry: () => addConnectorEntry,
+	addFile: () => addFile,
+	addText: () => addText,
+	addUrl: () => addUrl,
+	listAll: () => listAll,
+	listPending: () => listPending
+});
 /** Add plain text content to raw/local/ */
 async function addText(content, source = "local") {
 	const title = extractTitle$1(content);
@@ -1529,10 +1582,40 @@ async function rebuildProfile(opts) {
 
 //#endregion
 //#region src/cli/register.init.ts
-/** Create directory structure, write default configs, register QMD, scan & compile profile. */
+/** Try to install QMD globally via npm */
+async function installQmd() {
+	const spin = spinner("Installing QMD (search engine)...");
+	return new Promise((resolve) => {
+		execFile("npm", [
+			"install",
+			"-g",
+			"https://github.com/tobi/qmd"
+		], {
+			encoding: "utf-8",
+			timeout: 12e4
+		}, (err) => {
+			if (err) {
+				spin.fail("QMD installation failed.");
+				warn("Install manually: npm install -g https://github.com/tobi/qmd");
+				resolve(false);
+			} else {
+				spin.succeed("QMD installed.");
+				resolve(true);
+			}
+		});
+	});
+}
+const TOTAL_STEPS = 8;
+/** Create directory structure, write default configs, register QMD, scan, profile, Google import, index. */
 async function runInit(options = {}) {
-	const { overwriteConfig = false, skipScan = false } = options;
+	const { overwriteConfig = false, skipScan = false, nonInteractive = false } = options;
 	const paiHome = getPaiHome();
+	let profileLines = 0;
+	let profileSources = 0;
+	let gmailCount = 0;
+	let calendarCount = 0;
+	let googleAuthed = false;
+	let qmdReady = false;
 	const dirs = [
 		path.join(getRawDir(), "local"),
 		path.join(getRawDir(), "web"),
@@ -1542,6 +1625,8 @@ async function runInit(options = {}) {
 		path.join(getVaultDir(), "life"),
 		path.join(getVaultDir(), "preferences"),
 		path.join(getVaultDir(), "context"),
+		getMemoryDir(),
+		getWeeklyDir(),
 		getSkillsDir(),
 		getConfigDir()
 	];
@@ -1574,7 +1659,10 @@ async function runInit(options = {}) {
 			success("Created preferences.md — edit to customize AI behavior.");
 		}
 	}
-	if (await isQmdAvailable()) {
+	success(`[1/${TOTAL_STEPS}] Creating directories & config...`);
+	qmdReady = await isQmdAvailable();
+	if (!qmdReady) qmdReady = await installQmd();
+	if (qmdReady) {
 		try {
 			await execQmd([
 				"collection",
@@ -1603,44 +1691,124 @@ async function runInit(options = {}) {
 		} catch {
 			warn("QMD collection 'vault' may already exist, skipping.");
 		}
-	} else {
-		warn("QMD not found. Install with: npm install -g https://github.com/tobi/qmd");
-		warn("Search features won't work until QMD is installed.");
 	}
-	if (!skipScan) {
+	if (qmdReady) success(`[2/${TOTAL_STEPS}] Search engine (QMD) ready.`);
+	else warn(`[2/${TOTAL_STEPS}] Search engine (QMD) not available; built-in search will be used.`);
+	if (skipScan) {
 		log("");
+		info("Directory structure:");
+		log(`  ${paiHome}/profile.md  — (skipped; run pai profile --rebuild)`);
+		log(`  ${paiHome}/raw/        — raw data input`);
+		log(`  ${paiHome}/vault/      — PINData knowledge store`);
+		log(`  ${paiHome}/memory/     — daily journal & digests`);
+		log(`  ${paiHome}/config/     — configuration`);
+		info("Run \"pai profile --rebuild\" to scan and build your profile.");
+		return;
+	}
+	try {
 		const { profilePath, results } = await rebuildProfile({ verbose: true });
-		success(`Profile compiled → ${profilePath}`);
-		const sectionCount = results.length;
-		log("");
-		info(`Profile built from ${sectionCount} data sources:`);
-		for (const r of results) {
-			const lineCount = r.content.split("\n").length;
-			log(`  ${bold(r.id)} — ${r.title} (${lineCount} lines)`);
+		profileSources = results.length;
+		try {
+			profileLines = (await fs.readFile(profilePath, "utf-8")).split("\n").length;
+		} catch {
+			profileLines = 0;
 		}
+		success(`[3/${TOTAL_STEPS}] Scanning your machine (${profileSources} sources)...`);
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		warn(`[3/${TOTAL_STEPS}] Scan failed: ${msg}`);
 	}
+	success(`[4/${TOTAL_STEPS}] Compiling profile...`);
+	if (!nonInteractive) try {
+		const { encryption } = await Promise.resolve().then(() => encryption_exports);
+		const { googleOAuth } = await Promise.resolve().then(() => google_oauth_exports);
+		await encryption.loadKey();
+		await googleOAuth.init();
+		if (googleOAuth.isAuthenticated()) {
+			googleAuthed = true;
+			success(`[5/${TOTAL_STEPS}] Connecting Google account... (already connected)`);
+		} else {
+			await googleOAuth.authorize();
+			googleAuthed = true;
+			success(`[5/${TOTAL_STEPS}] Connecting Google account...`);
+		}
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		warn(`[5/${TOTAL_STEPS}] Google auth skipped: ${msg}`);
+		warn("Run \"pai auth google\" later to connect Gmail and Calendar.");
+	}
+	else info(`[5/${TOTAL_STEPS}] Connecting Google account... (skipped, non-interactive)`);
+	if (googleAuthed) {
+		const spinGmail = spinner(`[6/${TOTAL_STEPS}] Importing Gmail (latest 100)...`);
+		try {
+			const { syncGmail } = await import("./gmail-BhGX6az1.mjs");
+			const { addConnectorEntry } = await Promise.resolve().then(() => add_exports);
+			const entries = await syncGmail({
+				days: 365,
+				maxResults: 100
+			});
+			for (const entry of entries) {
+				const status = await addConnectorEntry("gmail", entry);
+				if (status === "created" || status === "updated") gmailCount++;
+			}
+			spinGmail.succeed(`[6/${TOTAL_STEPS}] Importing Gmail... ${gmailCount} message(s)`);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			spinGmail.fail(`[6/${TOTAL_STEPS}] Gmail import failed: ${msg}`);
+		}
+	} else info(`[6/${TOTAL_STEPS}] Importing Gmail... (skipped, no Google auth)`);
+	if (googleAuthed) {
+		const spinCal = spinner(`[7/${TOTAL_STEPS}] Importing Calendar...`);
+		try {
+			const { syncCalendar } = await import("./calendar-DGJSyErS.mjs");
+			const { addConnectorEntry } = await Promise.resolve().then(() => add_exports);
+			const entries = await syncCalendar({
+				lookbackDays: 30,
+				lookforwardDays: 90
+			});
+			for (const entry of entries) {
+				const status = await addConnectorEntry("calendar", entry);
+				if (status === "created" || status === "updated") calendarCount++;
+			}
+			spinCal.succeed(`[7/${TOTAL_STEPS}] Importing Calendar... ${calendarCount} event(s)`);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			spinCal.fail(`[7/${TOTAL_STEPS}] Calendar import failed: ${msg}`);
+		}
+	} else info(`[7/${TOTAL_STEPS}] Importing Calendar... (skipped, no Google auth)`);
+	if (qmdReady) try {
+		const { updateIndex } = await Promise.resolve().then(() => search_exports);
+		await updateIndex();
+		success(`[8/${TOTAL_STEPS}] Indexing for search...`);
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		warn(`[8/${TOTAL_STEPS}] Indexing failed: ${msg}. Built-in search still works.`);
+	}
+	else info(`[8/${TOTAL_STEPS}] Indexing for search... (skipped, QMD not available)`);
 	log("");
-	info("Directory structure:");
-	log(`  ${paiHome}/profile.md  — ${skipScan ? "(skipped scan)" : "your personal profile"}`);
-	log(`  ${paiHome}/raw/        — raw data input`);
-	log(`  ${paiHome}/vault/      — distilled knowledge`);
-	log(`  ${paiHome}/config/     — configuration`);
+	success("Setup complete!");
+	log(`  Profile:    ${paiHome}/profile.md (${profileLines} lines, ${profileSources} sources)`);
+	const rawCount = gmailCount + calendarCount;
+	if (rawCount > 0) log(`  Raw data:   ${rawCount} file(s) (${gmailCount} gmail, ${calendarCount} calendar)`);
+	else log(`  Raw data:   ${paiHome}/raw/`);
+	log(`  Search:     ${qmdReady ? "QMD hybrid ready" : "built-in keyword (install QMD for semantic)"}`);
+	log(`  Google:     ${googleAuthed ? "connected" : "not connected"}`);
 	log("");
-	if (skipScan) info("Run \"pai profile --rebuild\" to scan and build your profile.");
-	else {
-		info("Run \"pai distribute\" to deploy your profile to Cursor/agents.");
-		info("Run \"pai profile\" to view your profile anytime.");
-	}
+	info("Next:");
+	log("  pai profile              # View your profile");
+	log("  pai distribute           # Deploy to Cursor/Claude");
+	log("  pai ask \"question\"       # Ask about yourself");
 }
 function registerInitCommand(program) {
-	program.command("init").description("Initialize pai: create dirs, scan local machine, compile profile").option("--skip-scan", "Skip local machine scan (for CI/testing)").action(async (opts) => {
+	program.command("init").description("Initialize pai: create dirs, scan, profile, Google import, index (full pipeline)").option("--skip-scan", "Skip scan and steps 3-8 (CI/testing)").option("--non-interactive", "Skip Google OAuth (for agents; no browser)").action(async (opts) => {
 		const paiHome = getPaiHome();
 		const spin = spinner(`Initializing pai at ${paiHome}...`);
 		try {
 			spin.succeed(`Initializing pai at ${paiHome}`);
 			await runInit({
 				overwriteConfig: false,
-				skipScan: opts.skipScan
+				skipScan: opts.skipScan,
+				nonInteractive: opts.nonInteractive
 			});
 		} catch (err) {
 			spin.fail("Initialization failed");
@@ -1805,239 +1973,442 @@ async function llmCall(prompt, system, model) {
 }
 
 //#endregion
-//#region src/prompts/triage.ts
-/** Build system prompt for the triage step */
-function triageSystemPrompt() {
-	return `You are a personal knowledge management assistant.
-Your job is to evaluate raw input and extract ALL distinct pieces of personal context worth preserving.
+//#region src/prompts/extract.ts
+/** Build system prompt for the PINData extract step (replaces triage + distill) */
+function extractSystemPrompt() {
+	return `Extract PINData entries from the input. Each entry is ONE atomic piece of personal knowledge.
 
-CRITICAL: One raw input often contains MULTIPLE types of data. You MUST split them into separate entries routed to different vault files.
+Entry types:
+- fact: concrete data point (name, number, date, account, version, error, relationship)
+- pref: implied choice or habit (tool preference, workflow pattern, interest signal)
+- decision: explicit decision with reasoning
+- entity: person, organization, or project with attributes
+- event: time-bound occurrence (meeting, deployment, payment, conference)
 
-Two kinds of valuable content:
+Topic routing (pick the best fit):
+- context/identity — user's name, email, linked accounts
+- context/projects — project/repo/app names, deployments, tech stack
+- context/services — services/tools used, account IDs, subscriptions
+- preferences/tools — tool choices and why (e.g. Vercel for hosting, Airtable for PM)
+- preferences/workflow — work habits, communication style, patterns
+- work/activity — tasks, assignments, colleagues, meetings
+- work/finance — invoices, payments, amounts, subscriptions
+- life/interests — interests, events, communities, conferences
+- coding/lessons — coding lessons, debugging insights, tech decisions
 
-1) EXPERIENTIAL: concrete lessons, preferences, tips, or experiences.
-2) SYSTEM CONTEXT: data from system/connector scans — identity, environment, habits, preferences.
+Rules:
+- Each entry.content = ONE concrete fact with names/numbers/dates. Never generic advice.
+- Return [] (empty array) if input is pure marketing/spam with zero personal signal.
+- Prefer multiple small entries over one big entry.
+- Do NOT extract generic platitudes like "monitor deployments regularly".
 
-Routing targets:
-- vault/context/identity.md — name, email, role, languages, locale, timezone
-- vault/context/active-projects.md — repos, cloud infra, SSH hosts
-- vault/preferences/tools.md — tech stack, IDEs, runtimes, package managers
-- vault/preferences/workflow.md — shell habits, git config, aliases, dev workflow
-- vault/life/interests.md — interests, domains of focus, bookmarks, browsing patterns
-- vault/life/lifestyle.md — calendar, apps, music, media, daily routines
-- vault/coding/*.md — coding lessons (use existing or suggest new)
-- vault/work/*.md — work-related lessons and context
+Examples:
 
-Do NOT mark as valuable: generic news, ads, or content with no personal signal.
+Input: "Vercel: Failed deployment for pin-sandman on team pinai"
+Output: [
+  {"type":"fact","content":"pin-sandman: Vercel production deployment failed, team pinai","topic":"context/projects","tags":["vercel","pin-sandman"]},
+  {"type":"pref","content":"Vercel: used for production deployment","topic":"preferences/tools","tags":["vercel"]}
+]
 
-Respond ONLY with valid JSON (no markdown fences):
-{
-  "valuable": true/false,
-  "entries": [
-    { "targetFile": "vault/context/identity.md", "extract": "name, email, role, languages" },
-    { "targetFile": "vault/preferences/tools.md", "extract": "IDE, runtimes, package managers" }
-  ],
-  "reason": "brief explanation"
-}
+Input: "50% off all shoes this weekend only!"
+Output: []
 
-Rules:
-- entries array can have 1-6 items — split aggressively by topic
-- Each entry.extract is a SHORT directive telling the distill step WHAT to pull for that target
-- If not valuable, entries should be empty []
-- Use existing vault files from the list when available`;
+Respond with valid JSON array only (no markdown fences).`;
 }
-/** Build user prompt for triage */
-function triageUserPrompt(rawContent, vaultFiles) {
-	return `Evaluate this raw input and decide if it's worth distilling:
+/** Build user prompt for extract */
+function extractUserPrompt(rawContent, source) {
+	return `Extract PINData entries from this input:
 
----RAW CONTENT---
+---INPUT---
 ${rawContent}
----END RAW CONTENT---
-${vaultFiles.length > 0 ? `\nExisting vault files:\n${vaultFiles.map((f) => `- ${f}`).join("\n")}` : "\nNo existing vault files yet."}
+---END INPUT---
+${source ? `\n(Source: ${source})` : ""}
+Respond with JSON array only.`;
+}
+/** Build system prompt for the daily digest */
+function digestSystemPrompt() {
+	return `Summarize the day's journal entries and extracted knowledge into 3-5 key bullet points.
+
+Rules:
+- Each bullet = one concrete takeaway (what happened, what was decided, what matters)
+- Include names, projects, and specific details — never vague
+- If there are action items or follow-ups, list them
+- Keep it under 200 words total
+- Output plain markdown bullets only, no JSON`;
+}
+/** Build user prompt for digest */
+function digestUserPrompt(journalContent, newPinData, date) {
+	return `Summarize this day (${date}):
+
+---JOURNAL---
+${journalContent || "(no journal entries)"}
+---END JOURNAL---
+
+---NEW KNOWLEDGE EXTRACTED---
+${newPinData || "(no new entries)"}
+---END KNOWLEDGE---
 
-Route to context/, preferences/, life/, coding/, or work/ as appropriate. Respond with JSON only.`;
+Write 3-5 bullet points summarizing the day.`;
 }
 
 //#endregion
-//#region src/distill/triage.ts
-/** Run triage on a raw file to determine if it's worth distilling */
-async function triageRawFile(rawContent, vaultFiles) {
-	const system = triageSystemPrompt();
-	const response = await llmCall(triageUserPrompt(rawContent, vaultFiles), system);
+//#region src/distill/extract.ts
+const VALID_TYPES = new Set([
+	"fact",
+	"pref",
+	"decision",
+	"entity",
+	"event"
+]);
+/** Extract PINData entries from raw/journal content via a single LLM call */
+async function extractPinData(content, source) {
+	const system = extractSystemPrompt();
+	const response = await llmCall(extractUserPrompt(content, source), system);
 	try {
 		const cleaned = response.replace(/```json?\n?/g, "").replace(/```/g, "").trim();
 		const raw = JSON.parse(cleaned);
-		let entries = [];
-		if (Array.isArray(raw.entries)) entries = raw.entries.filter((e) => typeof e.targetFile === "string" && typeof e.extract === "string").map((e) => ({
-			targetFile: e.targetFile,
-			extract: e.extract
-		}));
-		if (entries.length === 0 && typeof raw.targetFile === "string" && raw.targetFile) entries = [{
-			targetFile: raw.targetFile,
-			extract: "all relevant content"
-		}];
+		let rawEntries;
+		if (Array.isArray(raw)) rawEntries = raw;
+		else if (raw && typeof raw === "object" && "entries" in raw && Array.isArray(raw.entries)) rawEntries = raw.entries;
+		else return {
+			entries: [],
+			summary: ""
+		};
+		const entries = [];
+		for (const item of rawEntries) {
+			if (!item || typeof item !== "object") continue;
+			const obj = item;
+			const type = obj.type;
+			const content = obj.content;
+			const topic = obj.topic;
+			if (!type || !content || !topic) continue;
+			if (!VALID_TYPES.has(type)) continue;
+			entries.push({
+				type,
+				content: content.trim(),
+				topic: topic.trim(),
+				tags: Array.isArray(obj.tags) ? obj.tags.filter((t) => typeof t === "string") : void 0
+			});
+		}
 		return {
-			valuable: Boolean(raw.valuable),
 			entries,
-			reason: raw.reason ?? ""
+			summary: entries.length > 0 ? entries.slice(0, 3).map((e) => e.content).join("; ") : "no extractable signal"
 		};
 	} catch {
 		return {
-			valuable: false,
 			entries: [],
-			reason: `Failed to parse triage response: ${response.slice(0, 100)}`
+			summary: `Failed to parse extract response: ${response.slice(0, 100)}`
 		};
 	}
 }
 
 //#endregion
-//#region src/prompts/distill.ts
-/** Build system prompt for the distill & merge step */
-function distillSystemPrompt() {
-	return `You are a personal knowledge distillation assistant.
-Your job is to extract and merge valuable personal context from raw input into a vault document.
-
-Two modes:
-
-A) EXPERIENTIAL content (lessons, tips, experiences):
-- Extract ONLY conclusions and actionable knowledge — never copy raw text verbatim
-- If a similar experience already exists, increment its verification count
-- Each bullet: (source, date | ref: raw/path)
-
-B) SYSTEM CONTEXT content (identity, environment, habits, bookmarks, etc.):
-- Do NOT dump raw lists verbatim (e.g. every package path or every bookmark folder)
-- Synthesize into a compact, HIGH-DENSITY profile:
-  - Identity: name, role, languages, locale, timezone — one line each
-  - Tools: summarize tech stack concisely (e.g. "Full-stack: Node/Python/Go/Rust, IDEs: Cursor+Android Studio")
-  - Workflow: summarize habits (e.g. "Heavy git user (4762 commands), frequent claude CLI, command-line focused")
-  - Life: summarize calendar themes, main apps, browsing focus — with concrete data
-  - Interests: summarize bookmark categories AND top domains as interest tags (e.g. "AI/LLM, GIS, iOS, Python, Web3")
-  - Projects: summarize active areas with names (e.g. "PINAI (PIN-APP-IOS, PIN-AGENT-WEB), consulting, agent-market")
-
-CRITICAL RULES:
-- NEVER write "未提供", "未指定", "Not specified", "Unknown" — if data is not in the raw input, simply OMIT that field
-- Only include sections and fields that have ACTUAL data from the raw input
-- Do NOT create empty placeholder sections. If an H2 section would be empty, skip it entirely
-- Each vault file handles ONE topic — only include relevant data from the raw input
-- Keep information density HIGH: pack maximum facts per line
-- Maintain H2 (##) section structure
-- Keep each H2 section between 200-800 tokens
-- Preserve all existing vault content — only add or update, never remove
-- Output the COMPLETE updated vault file content (not just the changes)
-- End each new bullet with source ref: (source, date | ref: raw/path/to/file.md)`;
-}
-/** Build user prompt for distill & merge */
-function distillUserPrompt(rawContent, rawFilePath, existingVaultContent, extractDirective) {
-	return `Distill the following raw input and merge into the vault document:
-
----RAW CONTENT (from: ${rawFilePath})---
-${rawContent}
----END RAW CONTENT---
-
-${existingVaultContent ? `---EXISTING VAULT DOCUMENT---\n${existingVaultContent}\n---END VAULT DOCUMENT---` : "This is a NEW vault document. Create it with appropriate H1 title and H2 sections."}
-${extractDirective ? `\nFOCUS: Only extract data related to: ${extractDirective}. Ignore unrelated content in the raw input.` : ""}
-Output the COMPLETE updated vault file content.
-Rules: synthesize into high-density profile. NEVER write "未提供"/"Not specified"/"Unknown" — omit fields with no data instead. Only include sections with actual data.`;
+//#region src/vault/writer.ts
+/** Format a PINData entry as a markdown bullet line */
+function formatEntry(entry, date, ref) {
+	const parts = [];
+	parts.push(date);
+	if (ref) parts.push(`ref:${ref}`);
+	const meta = parts.join(" | ");
+	return `- [${entry.type}] ${entry.content} (${meta})`;
+}
+/** Parse a PINData line back into structured data */
+function parsePinDataLine(line) {
+	const match = line.match(/^- \[(\w+)\] (.+?) \((\d{4}-\d{2}-\d{2})([^)]*)\)$/);
+	if (!match) return null;
+	const verifiedMatch = (match[4] ?? "").match(/verified:(\d+)/);
+	return {
+		type: match[1],
+		content: match[2],
+		date: match[3],
+		verified: verifiedMatch ? parseInt(verifiedMatch[1], 10) : void 0
+	};
+}
+/** Check if two PINData entries are semantically duplicate (same type + similar content) */
+function isDuplicate(existingContent, newEntry) {
+	const lines = existingContent.split("\n");
+	const newLower = newEntry.content.toLowerCase();
+	const newTokens = new Set(newLower.split(/[\s:,;]+/).filter((t) => t.length > 2));
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (!line.startsWith(`- [${newEntry.type}]`)) continue;
+		const parsed = parsePinDataLine(line);
+		if (!parsed) continue;
+		const existLower = parsed.content.toLowerCase();
+		const existTokens = new Set(existLower.split(/[\s:,;]+/).filter((t) => t.length > 2));
+		const intersection = [...newTokens].filter((t) => existTokens.has(t));
+		const union = new Set([...newTokens, ...existTokens]);
+		if ((union.size > 0 ? intersection.length / union.size : 0) >= .6) return {
+			lineIndex: i,
+			line
+		};
+	}
+	return null;
 }
-
-//#endregion
-//#region src/distill/merge.ts
 /**
-* Distill raw content and merge into a vault file.
-* Creates the vault file if it doesn't exist.
-* @param extractDirective - Optional hint telling LLM what to extract from raw content for this target
+* Append PINData entries to the appropriate vault files.
+* - Routes each entry to vault/{topic}.md based on entry.topic
+* - Creates file + H1 header if new
+* - Deduplicates: if similar entry exists, bumps verified count + updates date
+* Returns number of new entries added and duplicates updated.
 */
-async function distillAndMerge(rawContent, rawFilePath, targetFile, extractDirective) {
+async function appendPinData(entries, options = {}) {
 	const vaultDir = getVaultDir();
-	const relativePath = targetFile.replace(/^vault\//, "");
-	const fullPath = path.join(vaultDir, relativePath);
-	let existingContent = null;
-	try {
-		existingContent = await fs.readFile(fullPath, "utf-8");
-	} catch {}
-	const system = distillSystemPrompt();
-	const updatedContent = await llmCall(distillUserPrompt(rawContent, rawFilePath, existingContent, extractDirective), system);
-	await fs.mkdir(path.dirname(fullPath), { recursive: true });
-	await fs.writeFile(fullPath, updatedContent.trim() + "\n", "utf-8");
-	return fullPath;
+	const date = options.date ?? (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	let added = 0;
+	let updated = 0;
+	const byTopic = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const topic = entry.topic;
+		if (!byTopic.has(topic)) byTopic.set(topic, []);
+		byTopic.get(topic).push(entry);
+	}
+	for (const [topic, topicEntries] of byTopic) {
+		const filePath = path.join(vaultDir, `${topic}.md`);
+		await fs.mkdir(path.dirname(filePath), { recursive: true });
+		let content;
+		try {
+			content = await fs.readFile(filePath, "utf-8");
+		} catch {
+			content = `# ${topic.split("/").pop().replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase())}\n`;
+		}
+		for (const entry of topicEntries) {
+			const dup = isDuplicate(content, entry);
+			if (dup) {
+				const newVerified = (parsePinDataLine(dup.line)?.verified ?? 1) + 1;
+				const updatedLine = `- [${entry.type}] ${entry.content} (${date} | verified:${newVerified})`;
+				const lines = content.split("\n");
+				lines[dup.lineIndex] = updatedLine;
+				content = lines.join("\n");
+				updated++;
+			} else {
+				const line = formatEntry(entry, date, options.ref);
+				content = content.trimEnd() + "\n" + line + "\n";
+				added++;
+			}
+		}
+		await fs.writeFile(filePath, content, "utf-8");
+	}
+	return {
+		added,
+		updated
+	};
 }
-
-//#endregion
-//#region src/distill/index.ts
-/** List all existing vault files (relative paths like "coding/python.md") */
-async function listVaultFiles() {
+/** List all PINData entries across all vault files */
+async function listVaultEntries() {
 	const vaultDir = getVaultDir();
-	const files = [];
+	const results = [];
 	async function walk(dir) {
 		try {
 			const entries = await fs.readdir(dir, { withFileTypes: true });
 			for (const entry of entries) {
 				const fullPath = path.join(dir, entry.name);
 				if (entry.isDirectory()) await walk(fullPath);
-				else if (entry.name.endsWith(".md")) files.push(path.relative(vaultDir, fullPath));
+				else if (entry.name.endsWith(".md")) {
+					const topic = path.relative(vaultDir, fullPath).replace(/\.md$/, "");
+					const content = await fs.readFile(fullPath, "utf-8");
+					for (const line of content.split("\n")) if (line.startsWith("- [")) {
+						const parsed = parsePinDataLine(line);
+						results.push({
+							topic,
+							line,
+							parsed
+						});
+					}
+				}
 			}
 		} catch {}
 	}
 	await walk(vaultDir);
-	return files;
+	return results;
+}
+
+//#endregion
+//#region src/memory/journal.ts
+/** Append a log entry to today's journal file (memory/YYYY-MM-DD.md) */
+async function appendJournal(text, date) {
+	const targetDate = date ?? getTodayDate();
+	const filePath = getJournalPath(targetDate);
+	await fs.mkdir(getMemoryDir(), { recursive: true });
+	const entry = `- ${(/* @__PURE__ */ new Date()).toTimeString().slice(0, 5)} ${text}\n`;
+	let existed = false;
+	let existingContent = "";
+	try {
+		existingContent = await fs.readFile(filePath, "utf-8");
+		existed = true;
+	} catch {}
+	if (!existed) {
+		const header = `# ${targetDate}\n\n`;
+		await fs.writeFile(filePath, header + entry, "utf-8");
+	} else {
+		const markerIdx = existingContent.indexOf("\n<!-- extracted -->");
+		const digestIdx = existingContent.indexOf("\n## Digest");
+		const insertIdx = Math.min(markerIdx >= 0 ? markerIdx : Infinity, digestIdx >= 0 ? digestIdx : Infinity);
+		if (insertIdx < Infinity) {
+			const before = existingContent.slice(0, insertIdx).trimEnd();
+			const after = existingContent.slice(insertIdx).replace("<!-- extracted -->", "").trimStart();
+			const newContent = before + "\n" + entry + (after ? "\n" + after : "") + "\n";
+			await fs.writeFile(filePath, newContent, "utf-8");
+		} else await fs.appendFile(filePath, entry, "utf-8");
+	}
+	return {
+		path: filePath,
+		entryCount: ((await fs.readFile(filePath, "utf-8")).match(/^- \d{2}:\d{2} /gm) || []).length
+	};
 }
-/** Run the full distill pipeline on all pending raw files */
+/** Read a journal file's content. Returns null if not found. */
+async function readJournal(date) {
+	const filePath = getJournalPath(date ?? getTodayDate());
+	try {
+		return await fs.readFile(filePath, "utf-8");
+	} catch {
+		return null;
+	}
+}
+/** List all journal dates (YYYY-MM-DD) sorted descending */
+async function listJournalDates() {
+	const memDir = getMemoryDir();
+	try {
+		return (await fs.readdir(memDir)).filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f)).map((f) => f.replace(".md", "")).sort().reverse();
+	} catch {
+		return [];
+	}
+}
+/** Get status of a journal: entry count and whether it has a digest */
+async function getJournalStatus(date) {
+	const content = await readJournal(date);
+	if (!content) return null;
+	return {
+		entries: (content.match(/^- \d{2}:\d{2} /gm) || []).length,
+		hasDigest: content.includes("## Digest")
+	};
+}
+/** Find journal dates with missing entries in the last N days */
+async function findGaps(days = 30) {
+	const existing = new Set(await listJournalDates());
+	const gaps = [];
+	const now = /* @__PURE__ */ new Date();
+	for (let i = 0; i < days; i++) {
+		const d = new Date(now);
+		d.setDate(d.getDate() - i);
+		const dateStr = d.toISOString().split("T")[0];
+		if (!existing.has(dateStr)) gaps.push(dateStr);
+	}
+	return gaps;
+}
+/** Append a digest section to a journal file */
+async function appendDigest(digest, date) {
+	const targetDate = date ?? getTodayDate();
+	const filePath = getJournalPath(targetDate);
+	let content;
+	try {
+		content = await fs.readFile(filePath, "utf-8");
+	} catch {
+		content = `# ${targetDate}\n\n`;
+	}
+	const digestIndex = content.indexOf("\n## Digest");
+	if (digestIndex !== -1) content = content.slice(0, digestIndex);
+	const digestSection = `\n## Digest\n\n${digest.trim()}\n`;
+	await fs.mkdir(path.dirname(filePath), { recursive: true });
+	await fs.writeFile(filePath, content.trimEnd() + "\n" + digestSection, "utf-8");
+	return filePath;
+}
+
+//#endregion
+//#region src/distill/index.ts
+/**
+* Run the PINData extract pipeline on pending raw files + unprocessed journals.
+* Flow: raw/journal content → 1 LLM extract call → PINData[] → code-append to vault
+*/
 async function distillPipeline(options = {}) {
 	const result = {
 		processed: 0,
-		valuable: 0,
+		extracted: 0,
 		discarded: 0,
 		errors: []
 	};
-	let pendingFiles;
-	if (options.singleFile) pendingFiles = [options.singleFile];
-	else pendingFiles = await listPending();
-	if (pendingFiles.length === 0) {
-		info("No pending raw files to process.");
+	const inputs = [];
+	if (options.singleFile) {
+		const { content } = parseFrontmatter(await fs.readFile(options.singleFile, "utf-8"));
+		inputs.push({
+			label: path.basename(options.singleFile),
+			content,
+			rawPath: options.singleFile,
+			source: options.singleFile
+		});
+	} else if (!options.today) {
+		const pendingFiles = await listPending();
+		for (const filePath of pendingFiles) {
+			const { content } = parseFrontmatter(await fs.readFile(filePath, "utf-8"));
+			inputs.push({
+				label: path.basename(filePath),
+				content,
+				rawPath: filePath,
+				source: filePath
+			});
+		}
+	}
+	if (!options.singleFile) {
+		const todayDate = getTodayDate();
+		const journal = await readJournal(todayDate);
+		if (journal && journal.trim().length > 0) {
+			if (!journal.includes("<!-- extracted -->")) inputs.push({
+				label: `journal/${todayDate}`,
+				content: journal,
+				source: `memory/${todayDate}.md`
+			});
+		}
+	}
+	if (inputs.length === 0) {
+		info("No pending raw files or journal entries to process.");
 		return result;
 	}
-	info(`Found ${pendingFiles.length} pending file(s) to process.`);
-	const vaultFilesList = (await listVaultFiles()).map((f) => `vault/${f}`);
-	for (const filePath of pendingFiles) {
-		const spin = spinner(`Processing ${path.basename(filePath)}...`);
+	info(`Found ${inputs.length} input(s) to process.`);
+	for (const input of inputs) {
+		const spin = spinner(`Extracting ${input.label}...`);
 		try {
-			const rawFileContent = await fs.readFile(filePath, "utf-8");
-			const { content } = parseFrontmatter(rawFileContent);
-			const triage = await triageRawFile(content, vaultFilesList);
+			const extracted = await extractPinData(input.content, input.source);
 			result.processed++;
-			if (!triage.valuable || triage.entries.length === 0) {
-				spin.succeed(`Discarded: ${path.basename(filePath)} — ${triage.reason}`);
+			if (extracted.entries.length === 0) {
+				spin.succeed(`Skipped: ${input.label} — ${extracted.summary}`);
 				result.discarded++;
-				if (!options.dryRun) {
-					const updated = updateRawFrontmatter(rawFileContent, { status: "discarded" });
-					await fs.writeFile(filePath, updated, "utf-8");
+				if (input.rawPath && !options.dryRun) {
+					const updated = updateRawFrontmatter(await fs.readFile(input.rawPath, "utf-8"), { status: "discarded" });
+					await fs.writeFile(input.rawPath, updated, "utf-8");
 				}
 				continue;
 			}
-			const targets = triage.entries.map((e) => e.targetFile);
 			if (options.dryRun) {
-				spin.succeed(`[DRY RUN] Would distill ${path.basename(filePath)} → ${targets.join(", ")}`);
-				result.valuable++;
+				const topics = [...new Set(extracted.entries.map((e) => e.topic))];
+				spin.succeed(`[DRY RUN] ${input.label} → ${extracted.entries.length} entries → ${topics.join(", ")}`);
+				result.extracted += extracted.entries.length;
 				continue;
 			}
-			const mergedPaths = [];
-			for (const entry of triage.entries) {
-				const targetFile = entry.targetFile || "vault/context/misc.md";
-				const vaultPath = await distillAndMerge(content, filePath, targetFile, entry.extract);
-				mergedPaths.push(vaultPath);
-				if (!vaultFilesList.includes(targetFile)) vaultFilesList.push(targetFile);
-			}
-			result.valuable++;
-			const updated = updateRawFrontmatter(rawFileContent, {
-				status: "processed",
-				distilled_to: mergedPaths.map((p) => path.relative(path.dirname(filePath).replace(/\/raw\/.*/, "/raw"), p)).join(", ")
+			const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+			const { added, updated } = await appendPinData(extracted.entries, {
+				date,
+				ref: input.source
 			});
-			await fs.writeFile(filePath, updated, "utf-8");
-			spin.succeed(`Distilled ${path.basename(filePath)} → ${targets.join(", ")} (${triage.entries.length} entries)`);
+			result.extracted += extracted.entries.length;
+			const topics = [...new Set(extracted.entries.map((e) => e.topic))];
+			if (input.rawPath) {
+				const updatedRaw = updateRawFrontmatter(await fs.readFile(input.rawPath, "utf-8"), {
+					status: "processed",
+					distilled_to: topics.join(", ")
+				});
+				await fs.writeFile(input.rawPath, updatedRaw, "utf-8");
+			}
+			if (!input.rawPath && input.source.startsWith("memory/")) {
+				const journalPath = path.join(getPaiHome(), input.source);
+				try {
+					if (!(await fs.readFile(journalPath, "utf-8")).includes("<!-- extracted -->")) await fs.appendFile(journalPath, "\n<!-- extracted -->\n", "utf-8");
+				} catch {}
+			}
+			spin.succeed(`Extracted ${input.label} → ${added} new, ${updated} updated → ${topics.join(", ")}`);
 		} catch (err) {
 			const msg = err instanceof Error ? err.message : String(err);
-			spin.fail(`Error processing ${path.basename(filePath)}: ${msg}`);
-			result.errors.push(`${filePath}: ${msg}`);
+			spin.fail(`Error processing ${input.label}: ${msg}`);
+			result.errors.push(`${input.label}: ${msg}`);
 		}
 	}
 	return result;
@@ -2046,23 +2417,24 @@ async function distillPipeline(options = {}) {
 //#endregion
 //#region src/cli/register.distill.ts
 function registerDistillCommand(program) {
-	program.command("distill").description("Distill pending raw files into vault knowledge").option("--file <path>", "Process a single raw file").option("--dry-run", "Preview what would be distilled without writing").action(async (opts) => {
+	program.command("distill").description("Extract PINData from pending raw files and journal into vault").option("--file <path>", "Process a single raw file").option("--today", "Only process today's journal").option("--dry-run", "Preview what would be extracted without writing").action(async (opts) => {
 		try {
 			const result = await distillPipeline({
 				singleFile: opts.file,
+				today: opts.today,
 				dryRun: opts.dryRun
 			});
 			log("");
 			log(bold("Distill summary:"));
 			log(`  Processed:  ${result.processed}`);
-			log(`  Valuable:   ${result.valuable}`);
+			log(`  Extracted:  ${result.extracted} PINData entries`);
 			log(`  Discarded:  ${result.discarded}`);
 			if (result.errors.length > 0) {
 				log(`  Errors:     ${result.errors.length}`);
 				for (const e of result.errors) error(`    ${e}`);
 			}
 			log("");
-			if (result.valuable > 0 && !opts.dryRun) info("Vault updated. Run \"pai generate\" to update SKILL.md profiles.");
+			if (result.extracted > 0 && !opts.dryRun) info("Vault updated with PINData entries. Run \"pai generate\" to update SKILL.md profiles.");
 		} catch (err) {
 			const msg = err instanceof Error ? err.message : String(err);
 			error(`Distill failed: ${msg}`);
@@ -2075,44 +2447,61 @@ function registerDistillCommand(program) {
 //#region src/prompts/generate.ts
 /** Build system prompt for SKILL.md generation */
 function generateSystemPrompt() {
-	return `You are generating a concise SKILL.md personal context file for an AI agent.
-This file helps the agent understand the user's background, preferences, and experiences.
+	return `You generate a SKILL.md — a minimal, high-density context file for an AI agent to understand the user.
+Every line MUST be useful to an AI agent. If a line wouldn't change how an agent responds, delete it.
 
-Rules:
-- Be extremely concise — every line must carry HIGH information density
-- Pack maximum concrete facts per bullet (names, numbers, specific tools)
-- Prioritize experiences with higher verification counts when present
-- Use bullet points for each piece of context
-- Follow the exact section structure provided
-- Do NOT include generic advice — only user-specific context
-- NEVER write filler like "未提供", "Not specified" or vague statements
-- Write in the same language as the source content
-
-When vault content includes identity/tools/workflow/interests data:
-- "Who I Am": real name, email, languages with specifics, locale, timezone, tech identity
-- "Preferences": specific tools by name, workflow patterns with data (e.g. "git: 4762 commands"), communication style
-- "Hard-won Lessons": only include if genuine lessons exist; otherwise omit or make it 1-2 lines
-- "Current Work": specific project names, focus areas, active repos — be concrete`;
+COMPRESSION RULES:
+- Identity: pack into 2-3 lines max (name | email | role | languages | timezone — merge onto fewer lines)
+- Preferences: write as "prefers X for Y" not just "uses X". State the WHY or CONTEXT.
+  GOOD: "Deploys on Vercel (team pinai), manages tasks in Airtable, meetings via Zoom (paid)"
+  BAD:  "Tools: Vercel, Zoom, Docker, npm, Airtable" (just a list, no context)
+- Interests: compress bookmarks/domains/events into TAGS, not raw lists
+  GOOD: "Interests: AI/LLM, Web3 (ETHDenver 2026), GIS, iOS, prediction markets (Kalshi)"
+  BAD:  "Bookmarks: Favorites Bar 106项, Read 78项, Tools 67项..." (raw data dump)
+- Current Work: what are they ACTIVELY building? Project names + what they do, not directory paths
+  GOOD: "Building personal-ai (v0.1.0, npm published), PINAI ecosystem (PIN-APP-IOS, pin-sandman on Vercel)"
+  BAD:  "Recent Working Directories: ..: 8次, backend: 2次"
+- Lessons: ONLY copy verbatim lessons that exist in vault/coding/ or vault/work/ files.
+  NEVER INVENT OR PARAPHRASE lessons. If the vault has no explicit lesson, write "None recorded yet."
+  A deployment failure is a FACT (goes in Current Work), NOT a lesson.
+  GOOD: "FastAPI CORS: must explicitly list allowed_origins, wildcard doesn't work with credentials"
+  BAD:  "生产环境部署失败可能导致项目延误" ← THIS IS INVENTED, NEVER DO THIS
+  BAD:  "及时关注部署通知有助于快速定位问题" ← THIS IS GENERIC ADVICE, NEVER DO THIS
+- Financial/services: compress into 1-2 lines
+  GOOD: "Paid services: Zoom (acct 5144380543), BytePlus (acct 3000767749, ~200 USD credits)"
+- Team: mention key collaborators briefly
+  GOOD: "Works with Ethan Liu (pinai team) on Prediction project via Airtable"
+
+ANTI-PATTERNS — never do these:
+- Raw data dumps (bookmark counts, domain visit counts, directory lists)
+- Generic advice disguised as lessons
+- Separate lines for each identity field (merge them)
+- Lists of tool names without context on how/why they're used
+- "Account Activities" as a separate section (fold into Preferences or Current Work)`;
 }
 /** Build user prompt for SKILL.md generation */
 function generateUserPrompt(profileName, vaultContents, maxLines) {
-	return `Generate a SKILL.md profile called "${profileName}" from the following vault content.
-Maximum ${maxLines} lines total.
+	return `Generate SKILL.md "${profileName}" from vault content. Max ${maxLines} lines.
 
-Required sections:
+Sections:
 # Personal Context — ${profileName}
-
-## Who I Am
-## Preferences
-## Hard-won Lessons
-## Current Work
+## Who I Am        (2-4 lines: identity, languages, timezone — packed dense)
+## Preferences     (tool choices WITH context, workflow habits, communication style)
+## Interests       (compressed tags from bookmarks/domains/events, NOT raw lists)
+## Current Work    (active projects with names, what they do, team members)
+## Paid Services   (services with account IDs, amounts — 1-3 lines)
+## Hard-won Lessons (ONLY real lessons from vault, or 1 line "None yet")
 
 ---VAULT CONTENT---
 ${vaultContents}
 ---END VAULT CONTENT---
 
-Generate the SKILL.md now. Stay within ${maxLines} lines.
-IMPORTANT: include ALL concrete facts from the vault — names, numbers, tools, project names, bookmark categories, browsing domains. Do not summarize away specific data. Never write filler or "未提供".`;
+CRITICAL: Compress, don't dump. Every line must be useful to an AI agent.
+- Merge identity fields onto fewer lines (name | email | timezone on one line)
+- Write preferences as "prefers X for Y" not bare lists
+- Convert bookmark counts and domain visits into interest TAGS
+- Never write generic advice as lessons
+- Never write raw data (dir paths, bookmark counts, visit numbers)`;
 }
 
 //#endregion
@@ -2218,17 +2607,25 @@ function registerGenerateCommand(program) {
 
 //#endregion
 //#region src/search/index.ts
+var search_exports = /* @__PURE__ */ __exportAll({
+	search: () => search,
+	updateIndex: () => updateIndex
+});
 /**
-* Hybrid search via QMD.
+* Search with automatic fallback:
+* 1. QMD available → use QMD (query/search/vsearch modes)
+* 2. QMD not available → built-in grep search (keyword matching, no install needed)
+*
+* QMD modes:
 * - "query"   (default): BM25 + vector + expansion + reranking (~5s, best quality)
-* - "search":            BM25 keyword + rg grep fallback (~50ms, fast)
-* - "vsearch":           Vector similarity only (~2s, good for semantic)
+* - "search":            BM25 keyword (~50ms, fast)
+* - "vsearch":           Vector similarity only (~2s, semantic)
 *
 * For "search" (fast) mode, QMD BM25 doesn't support CJK tokenization,
-* so we supplement with ripgrep to cover Chinese/Japanese/Korean.
+* so we supplement with grep to cover Chinese/Japanese/Korean.
 */
 async function search(query, collection = "vault", n = 5, mode = "query") {
-	if (!await isQmdAvailable()) throw new Error("QMD is not installed. Install with: npm install -g https://github.com/tobi/qmd");
+	if (!await isQmdAvailable()) return builtinSearch(query, collection, n);
 	let results = parseSearchResults(await execQmd([
 		mode,
 		query,
@@ -2241,6 +2638,57 @@ async function search(query, collection = "vault", n = 5, mode = "query") {
 	if (mode === "search" && results.length === 0 && hasCjk(query)) results = await grepFallback(query, collection, n);
 	return results;
 }
+/**
+* Built-in keyword search — zero external dependencies.
+* Reads markdown files and does case-insensitive substring matching.
+* Good enough for small-medium collections (< 10k files).
+*/
+async function builtinSearch(query, collection, n) {
+	const baseDir = collection === "raw" ? getRawDir() : getVaultDir();
+	const grepResults = await grepFallback(query, collection, n);
+	if (grepResults.length > 0) return grepResults;
+	return nodeFsSearch(query, baseDir, collection, n);
+}
+/**
+* Pure Node.js file search — absolute zero dependencies.
+* Recursively reads .md files and matches query as case-insensitive substring.
+*/
+async function nodeFsSearch(query, baseDir, collection, n) {
+	const results = [];
+	const queryLower = query.toLowerCase();
+	async function walk(dir) {
+		let entries;
+		try {
+			entries = await fs.readdir(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (results.length >= n) return;
+			const full = path.join(dir, entry.name);
+			if (entry.isDirectory()) await walk(full);
+			else if (entry.name.endsWith(".md")) try {
+				const content = await fs.readFile(full, "utf-8");
+				const idx = content.toLowerCase().indexOf(queryLower);
+				if (idx !== -1) {
+					const snippetStart = Math.max(0, idx - 40);
+					const snippetEnd = Math.min(content.length, idx + query.length + 120);
+					const snippet = content.slice(snippetStart, snippetEnd).replace(/\n/g, " ").trim();
+					const titleMatch = content.match(/^#\s+(.+)/m);
+					const relative = path.relative(baseDir, full);
+					results.push({
+						file: `${collection}/${relative}`,
+						title: titleMatch?.[1]?.trim() ?? path.basename(full, ".md"),
+						snippet,
+						score: 1
+					});
+				}
+			} catch {}
+		}
+	}
+	await walk(baseDir);
+	return results;
+}
 /** Parse QMD JSON search output into SearchResult[] */
 function parseSearchResults(stdout) {
 	try {
@@ -2318,6 +2766,7 @@ async function grepFallback(query, collection, n) {
 }
 /** Update QMD index: runs `qmd update` + `qmd embed` */
 async function updateIndex() {
+	if (!await isQmdAvailable()) throw new Error("QMD is not installed. Built-in search works without indexing.\nFor better search quality, install QMD: npm install -g https://github.com/tobi/qmd");
 	await execQmd(["update"]);
 	await execQmd(["embed"]);
 }
@@ -2400,7 +2849,7 @@ function registerImportCommand(program) {
 	program.command("import").description("Import data from connector or directory (use --source mac for system scan)").requiredOption("--source <source>", "Data source (mac, gmail, calendar, twitter, etc.)").option("--path <dir>", "Path to data directory or file (not needed for mac, gmail, calendar)").option("--dry-run", "Preview what would be imported without writing").option("--days <n>", "For gmail/calendar: last N days to fetch (default 30)", "30").option("--query <q>", "For gmail: Gmail search query (e.g. is:important)").action(async (opts) => {
 		try {
 			if (opts.source === "mac") {
-				const { scanMac } = await import("./mac-C9SDXZGK.mjs");
+				const { scanMac } = await import("./mac-vynpftec.mjs");
 				const result = await scanMac({ dryRun: opts.dryRun });
 				if (opts.dryRun) return;
 				log("");
@@ -2410,7 +2859,7 @@ function registerImportCommand(program) {
 				return;
 			}
 			if (opts.source === "gmail") {
-				const { syncGmail } = await import("./gmail-B9ja9sKN.mjs");
+				const { syncGmail } = await import("./gmail-BhGX6az1.mjs");
 				const parsedDays = parseInt(opts.days ?? "30", 10);
 				const days = Number.isNaN(parsedDays) ? 30 : parsedDays;
 				const doSync = () => syncGmail({
@@ -2454,7 +2903,7 @@ function registerImportCommand(program) {
 				return;
 			}
 			if (opts.source === "calendar") {
-				const { syncCalendar } = await import("./calendar-BHcM4wfQ.mjs");
+				const { syncCalendar } = await import("./calendar-DGJSyErS.mjs");
 				const parsedDays = parseInt(opts.days ?? "30", 10);
 				const days = Number.isNaN(parsedDays) ? 30 : parsedDays;
 				const doSync = () => syncCalendar({
@@ -2606,22 +3055,22 @@ function askConfirm(question) {
 	});
 }
 function registerResetCommand(program) {
-	program.command("reset").description("Remove all pai data and re-initialize (clean slate for testing)").option("--force", "Skip confirmation prompt").action(async (opts) => {
+	program.command("reset").description("Clear all pai data (remove ~/.pai directory)").option("--force", "Skip confirmation prompt").action(async (opts) => {
 		const paiHome = getPaiHome();
 		if (!opts.force) {
-			if (!await askConfirm(`Remove ALL data at ${paiHome} and re-initialize? [y/N] `)) {
+			if (!await askConfirm(`Remove ALL data at ${paiHome}? [y/N] `)) {
 				info("Reset cancelled.");
 				return;
 			}
 		}
-		const spin = spinner(`Resetting pai at ${paiHome}...`);
+		const spin = spinner(`Clearing pai data at ${paiHome}...`);
 		try {
 			await fs.rm(paiHome, {
 				recursive: true,
 				force: true
 			});
-			await runInit({ overwriteConfig: true });
-			spin.succeed(`pai reset complete. Fresh state at ${paiHome}`);
+			spin.succeed(`Cleared ${paiHome}`);
+			info("Run \"pai init\" to set up again.");
 		} catch (err) {
 			spin.fail("Reset failed");
 			const msg = err instanceof Error ? err.message : String(err);
@@ -3802,6 +4251,116 @@ function registerProfileCommand(program) {
 	});
 }
 
+//#endregion
+//#region src/cli/register.log.ts
+function registerLogCommand(program) {
+	program.command("log [text...]").description("Quick-log to today's journal (memory/YYYY-MM-DD.md)").option("--clip", "Read from clipboard (macOS pbpaste)").option("--show", "Show today's journal").option("--date <date>", "Target date (YYYY-MM-DD), default today").action(async (textParts, opts) => {
+		try {
+			const date = opts.date ?? getTodayDate();
+			if (opts.show) {
+				const content = await readJournal(date);
+				if (!content) {
+					info(`No journal for ${date}.`);
+					return;
+				}
+				log(content);
+				const status = await getJournalStatus(date);
+				if (status) log(dim(`(${status.entries} entries${status.hasDigest ? ", has digest" : ""})`));
+				return;
+			}
+			let text = textParts.join(" ").trim();
+			if (opts.clip || !text) {
+				if (opts.clip) {
+					const { execFile } = await import("node:child_process");
+					const { promisify } = await import("node:util");
+					const execFileP = promisify(execFile);
+					try {
+						const { stdout } = await execFileP("pbpaste");
+						text = stdout.trim();
+					} catch {
+						error("Failed to read clipboard. Is pbpaste available?");
+						process.exit(1);
+					}
+				}
+				if (!text) {
+					error("Usage: pai log \"your note\" or pai log --clip");
+					process.exit(1);
+				}
+			}
+			const { path: journalPath, entryCount } = await appendJournal(text, date);
+			success(`Logged to ${date} (entry #${entryCount})`);
+			log(dim(`  ${journalPath}`));
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			error(`Log failed: ${msg}`);
+			process.exit(1);
+		}
+	});
+}
+
+//#endregion
+//#region src/cli/register.digest.ts
+function registerDigestCommand(program) {
+	program.command("digest").description("Generate daily AI digest for a journal day").option("--date <date>", "Target date (YYYY-MM-DD), default today").option("--dry-run", "Preview digest without writing").action(async (opts) => {
+		try {
+			const date = opts.date ?? getTodayDate();
+			const journal = await readJournal(date);
+			if (!journal) {
+				info(`No journal for ${date}. Use "pai log" to add entries first.`);
+				return;
+			}
+			const spin = spinner(`Generating digest for ${date}...`);
+			const todayEntries = (await listVaultEntries()).filter((e) => e.parsed?.date === date).map((e) => e.line);
+			const pinDataText = todayEntries.length > 0 ? todayEntries.join("\n") : "";
+			const system = digestSystemPrompt();
+			const digest = await llmCall(digestUserPrompt(journal, pinDataText, date), system);
+			if (opts.dryRun) {
+				spin.succeed(`[DRY RUN] Digest for ${date}:`);
+				log("");
+				log(digest);
+				return;
+			}
+			const journalPath = await appendDigest(digest, date);
+			spin.succeed(`Digest written for ${date}`);
+			log("");
+			log(digest);
+			log("");
+			log(dim(`  ${journalPath}`));
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			error(`Digest failed: ${msg}`);
+			process.exit(1);
+		}
+	});
+}
+
+//#endregion
+//#region src/cli/register.gaps.ts
+function registerGapsCommand(program) {
+	program.command("gaps").description("Check for missing journal entries in the last N days").option("--days <n>", "Number of days to check", "7").action(async (opts) => {
+		try {
+			const days = parseInt(opts.days, 10);
+			if (isNaN(days) || days < 1) {
+				error("--days must be a positive number.");
+				process.exit(1);
+			}
+			const gaps = await findGaps(days);
+			if (gaps.length === 0) {
+				success(`No gaps in the last ${days} day(s). All journals present.`);
+				return;
+			}
+			warn(`Found ${gaps.length} missing journal(s) in the last ${days} days:`);
+			for (const date of gaps) log(`  ${date}`);
+			log("");
+			info("Use \"pai log --date YYYY-MM-DD 'note'\" to backfill.");
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			error(`Gaps check failed: ${msg}`);
+			process.exit(1);
+		}
+	});
+}
+
 //#endregion
 //#region src/cli/command-registry.ts
 const commandRegistry = [
@@ -3821,6 +4380,10 @@ const commandRegistry = [
 		id: "add",
 		register: (p) => registerAddCommand(p)
 	},
+	{
+		id: "log",
+		register: (p) => registerLogCommand(p)
+	},
 	{
 		id: "profile",
 		register: (p) => registerProfileCommand(p)
@@ -3829,6 +4392,14 @@ const commandRegistry = [
 		id: "distill",
 		register: (p) => registerDistillCommand(p)
 	},
+	{
+		id: "digest",
+		register: (p) => registerDigestCommand(p)
+	},
+	{
+		id: "gaps",
+		register: (p) => registerGapsCommand(p)
+	},
 	{
 		id: "generate",
 		register: (p) => registerGenerateCommand(p)