personal-ai 0.1.0

package/dist/entry.mjs

@@ -0,0 +1,3891 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import http from "node:http";
+import { URL } from "node:url";
+import { google } from "googleapis";
+import open from "open";
+import chalk from "chalk";
+import ora from "ora";
+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";
+import readline from "node:readline";
+import { Agent } from "@mariozechner/pi-agent-core";
+import { getModel } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+
+//#region src/config/paths.ts
+/** Root data directory for pai */
+function getPaiHome() {
+	return process.env.PAI_HOME ?? path.join(os.homedir(), ".pai");
+}
+function getRawDir() {
+	return path.join(getPaiHome(), "raw");
+}
+function getVaultDir() {
+	return path.join(getPaiHome(), "vault");
+}
+function getSkillsDir() {
+	return path.join(getPaiHome(), "skills", "profiles");
+}
+function getConfigDir() {
+	return path.join(getPaiHome(), "config");
+}
+function getConfigPath() {
+	return path.join(getConfigDir(), "pai.json5");
+}
+function getProfilesPath() {
+	return path.join(getConfigDir(), "profiles.json5");
+}
+function getPreferencesPath() {
+	return path.join(getConfigDir(), "preferences.md");
+}
+/** Compiled user profile — the core output of pai */
+function getProfilePath() {
+	return path.join(getPaiHome(), "profile.md");
+}
+
+//#endregion
+//#region src/auth/encryption.ts
+const ALGORITHM = "aes-256-gcm";
+const KEY_LENGTH = 32;
+const IV_LENGTH = 16;
+var Encryption = class {
+	keyPath;
+	key = null;
+	constructor() {
+		this.keyPath = path.join(getPaiHome(), ".encryption-key");
+	}
+	async generateKey() {
+		const key = crypto.randomBytes(KEY_LENGTH);
+		await fs.mkdir(path.dirname(this.keyPath), { recursive: true });
+		await fs.writeFile(this.keyPath, key.toString("hex"), { mode: 384 });
+		this.key = key;
+	}
+	async loadKey() {
+		try {
+			const keyHex = await fs.readFile(this.keyPath, "utf-8");
+			this.key = Buffer.from(keyHex.trim(), "hex");
+		} catch (err) {
+			if (err.code === "ENOENT") await this.generateKey();
+			else throw err;
+		}
+	}
+	ensureKey() {
+		if (!this.key) throw new Error("Encryption key not loaded. Call loadKey() first.");
+		return this.key;
+	}
+	encrypt(data) {
+		const key = this.ensureKey();
+		const iv = crypto.randomBytes(IV_LENGTH);
+		const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+		let encrypted = cipher.update(data, "utf8", "hex");
+		encrypted += cipher.final("hex");
+		const authTag = cipher.getAuthTag();
+		return iv.toString("hex") + ":" + authTag.toString("hex") + ":" + encrypted;
+	}
+	decrypt(encryptedData) {
+		const key = this.ensureKey();
+		const parts = encryptedData.split(":");
+		if (parts.length !== 3) throw new Error("Invalid encrypted data format");
+		const iv = Buffer.from(parts[0], "hex");
+		const authTag = Buffer.from(parts[1], "hex");
+		const encrypted = parts[2];
+		const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+		decipher.setAuthTag(authTag);
+		let decrypted = decipher.update(encrypted, "hex", "utf8");
+		decrypted += decipher.final("utf8");
+		return decrypted;
+	}
+	async encryptFile(filePath, data) {
+		const jsonData = JSON.stringify(data, null, 2);
+		const encrypted = this.encrypt(jsonData);
+		await fs.mkdir(path.dirname(filePath), { recursive: true });
+		await fs.writeFile(filePath, encrypted, { mode: 384 });
+	}
+	async decryptFile(filePath) {
+		const encrypted = await fs.readFile(filePath, "utf-8");
+		const decrypted = this.decrypt(encrypted);
+		return JSON.parse(decrypted);
+	}
+};
+const encryption = new Encryption();
+
+//#endregion
+//#region src/utils/console.ts
+function log(message) {
+	console.log(message);
+}
+function info(message) {
+	console.log(chalk.blue("ℹ"), message);
+}
+function success(message) {
+	console.log(chalk.green("✓"), message);
+}
+function warn(message) {
+	console.warn(chalk.yellow("⚠"), message);
+}
+function error(message) {
+	console.error(chalk.red("✗"), message);
+}
+function spinner(text) {
+	return ora({
+		text,
+		color: "cyan"
+	}).start();
+}
+function dim(message) {
+	return chalk.dim(message);
+}
+function bold(message) {
+	return chalk.bold(message);
+}
+
+//#endregion
+//#region src/auth/google-oauth.ts
+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;
+/**
+* Embedded OAuth client credentials for Desktop/CLI app.
+* Google explicitly states that for "installed" (desktop) applications,
+* the client_secret is NOT treated as a secret.
+* Users can override by placing their own client_secret.json in ~/.pai/credentials/.
+*/
+const DEFAULT_CLIENT_SECRETS = { installed: {
+	client_id: "973253759191-ihev26p7n9t1faksavdei36fbii46js7.apps.googleusercontent.com",
+	project_id: "pinai-428200",
+	auth_uri: "https://accounts.google.com/o/oauth2/auth",
+	token_uri: "https://oauth2.googleapis.com/token",
+	auth_provider_x509_cert_url: "https://www.googleapis.com/oauth2/v1/certs",
+	client_secret: "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",
+	redirect_uris: ["http://localhost"]
+} };
+var GoogleOAuth = class {
+	oauth2Client = null;
+	credentialsPath;
+	clientSecretsPath;
+	constructor() {
+		const baseDir = path.join(getPaiHome(), "credentials");
+		this.credentialsPath = path.join(baseDir, "google-oauth.json.enc");
+		this.clientSecretsPath = path.join(baseDir, "client_secret.json");
+	}
+	async init() {
+		let clientSecrets = null;
+		try {
+			const content = await fs.readFile(this.clientSecretsPath, "utf-8");
+			clientSecrets = JSON.parse(content);
+		} catch {
+			const fromCwd = path.join(process.cwd(), "credentials", "client_secret.json");
+			try {
+				const content = await fs.readFile(fromCwd, "utf-8");
+				clientSecrets = JSON.parse(content);
+				await fs.mkdir(path.dirname(this.clientSecretsPath), { recursive: true });
+				await fs.copyFile(fromCwd, this.clientSecretsPath);
+				info(`Copied credentials from ${fromCwd} to ~/.pai/credentials/`);
+			} catch {}
+		}
+		if (!clientSecrets) clientSecrets = DEFAULT_CLIENT_SECRETS;
+		try {
+			const { client_id, client_secret } = clientSecrets.installed ?? clientSecrets.web ?? {};
+			if (!client_id || !client_secret) throw new Error("Missing client_id or client_secret in client_secret.json");
+			this.oauth2Client = new google.auth.OAuth2(client_id, client_secret, REDIRECT_URI);
+			await this.loadCredentials();
+		} catch {
+			warn("OAuth client initialization failed. Run: pai auth google");
+		}
+	}
+	async loadCredentials() {
+		try {
+			await encryption.loadKey();
+			const credentials = await encryption.decryptFile(this.credentialsPath);
+			this.oauth2Client.setCredentials(credentials);
+			this.oauth2Client.on("tokens", (tokens) => {
+				if (tokens && typeof tokens === "object" && "refresh_token" in tokens && tokens.refresh_token) this.saveCredentials(tokens);
+			});
+		} catch {}
+	}
+	async saveCredentials(credentials) {
+		await encryption.loadKey();
+		await encryption.encryptFile(this.credentialsPath, credentials);
+	}
+	async authorize() {
+		if (!this.oauth2Client) throw new Error("OAuth client not initialized. Place client_secret.json in ~/.pai/credentials/ and run again.");
+		const state = crypto.randomBytes(16).toString("hex");
+		const authUrl = this.oauth2Client.generateAuthUrl({
+			access_type: "offline",
+			scope: SCOPES,
+			prompt: "consent",
+			state
+		});
+		log("\nPlease visit this URL to authorize the application:\n");
+		log(authUrl);
+		log("\nOpening browser...\n");
+		await open(authUrl);
+		const code = await this.startCallbackServer(state);
+		const { tokens } = await this.oauth2Client.getToken(code);
+		this.oauth2Client.setCredentials(tokens);
+		await this.saveCredentials(tokens);
+		success("Google OAuth authorization successful.");
+	}
+	startCallbackServer(expectedState) {
+		return new Promise((resolve, reject) => {
+			const server = http.createServer((req, res) => {
+				if (req.url?.startsWith("/callback")) {
+					const url = new URL(req.url ?? "", `http://${req.headers.host}`);
+					const code = url.searchParams.get("code");
+					const state = url.searchParams.get("state");
+					if (code && state === expectedState) {
+						res.writeHead(200, { "Content-Type": "text/html" });
+						res.end("<html><body><h1>Authorization Successful!</h1><p>You can close this window and return to the terminal.</p></body></html>");
+						server.close();
+						resolve(code);
+					} else {
+						res.writeHead(400, { "Content-Type": "text/plain" });
+						res.end("Authorization failed: Invalid callback parameters");
+						server.close();
+						reject(/* @__PURE__ */ new Error("Authorization failed: invalid callback parameters"));
+					}
+				}
+			});
+			server.listen(8888, () => {});
+			server.on("error", (err) => {
+				reject(err);
+			});
+			const timeout = setTimeout(() => {
+				server.close();
+				reject(/* @__PURE__ */ new Error("Authorization timed out. Please retry: pai auth google"));
+			}, CALLBACK_TIMEOUT_MS);
+			server.on("close", () => {
+				clearTimeout(timeout);
+			});
+		});
+	}
+	getClient() {
+		if (!this.oauth2Client) throw new Error("OAuth client not initialized");
+		return this.oauth2Client;
+	}
+	async ensureAuthenticated() {
+		if (!this.oauth2Client || !this.oauth2Client.credentials.access_token) throw new Error("Not authenticated. Run: pai auth google");
+		const now = Date.now();
+		const expiry = this.oauth2Client.credentials.expiry_date;
+		if (expiry != null && expiry < now) await this.oauth2Client.refreshAccessToken();
+	}
+};
+const googleOAuth = new GoogleOAuth();
+
+//#endregion
+//#region src/cli/register.auth.ts
+function registerAuthCommand(program) {
+	program.command("auth").description("Authenticate with Google (for gmail/calendar connectors)").argument("<provider>", "Provider (google)").action(async (provider) => {
+		if (provider !== "google") {
+			error("Only \"google\" provider is supported.");
+			process.exit(1);
+		}
+		try {
+			await encryption.loadKey();
+			await googleOAuth.init();
+			await googleOAuth.authorize();
+			success("Authentication successful.");
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			error(`Authentication failed: ${msg}`);
+			process.exit(1);
+		}
+	});
+}
+
+//#endregion
+//#region src/config/defaults.ts
+/** Default content for pai.json5 */
+const DEFAULT_CONFIG = `{
+  // pai configuration
+  version: "0.1",
+
+  qmd: {
+    rawCollection: "raw",
+    vaultCollection: "vault",
+  },
+
+  llm: {
+    apiKeyEnv: "OPENAI_API_KEY",
+    baseUrl: "",            // leave empty for OpenAI, or set for compatible services
+    cheapModel: "gpt-4o-mini",
+    expensiveModel: "gpt-4o",
+  },
+
+  scraper: {
+    timeout: 30000,
+  },
+
+  vault: {
+    maxFileTokens: 4000,
+    warnFileTokens: 3000,
+  },
+}
+`;
+/** Default content for preferences.md — injected into ALL LLM calls */
+const DEFAULT_PREFERENCES = `# User Preferences
+
+These preferences are automatically included in every AI operation (triage, distill, generate).
+Edit this file directly — changes take effect on the next pai command.
+
+## Language
+
+- My native language is: 中文 (Chinese)
+- All distilled knowledge and vault content should prefer: 中文
+- Raw data should be preserved in its original language
+- SKILL.md profiles should be written in the same language as the vault content
+
+## Output Style
+
+- Be concise and actionable — no filler
+- Use bullet points for experience entries
+- Preserve technical terms in English (e.g. API, CORS, TypeScript)
+`;
+/** Default content for profiles.json5 */
+const DEFAULT_PROFILES = `{
+  profiles: {
+    "coding-assistant": {
+      scope: [
+        "vault/coding/**",
+        "vault/preferences/**",
+        "vault/context/**",
+      ],
+      maxLines: 60,
+    },
+
+    "full-context": {
+      scope: ["vault/**"],
+      maxLines: 120,
+    },
+
+    "life-assistant": {
+      scope: [
+        "vault/life/**",
+        "vault/work/**",
+        "vault/preferences/**",
+        "vault/context/**",
+      ],
+      maxLines: 60,
+    },
+  },
+}
+`;
+
+//#endregion
+//#region src/config/schema.ts
+const QmdConfigSchema = z.object({
+	rawCollection: z.string().default("raw"),
+	vaultCollection: z.string().default("vault")
+});
+const LlmConfigSchema = z.object({
+	apiKeyEnv: z.string().default("OPENAI_API_KEY"),
+	baseUrl: z.string().optional(),
+	cheapModel: z.string().default("gpt-4o-mini"),
+	expensiveModel: z.string().default("gpt-4o")
+});
+const ScraperConfigSchema = z.object({ timeout: z.number().default(3e4) });
+const VaultConfigSchema = z.object({
+	maxFileTokens: z.number().default(4e3),
+	warnFileTokens: z.number().default(3e3)
+});
+const PaiConfigSchema = z.object({
+	version: z.string().default("0.1"),
+	qmd: QmdConfigSchema.default(() => QmdConfigSchema.parse({})),
+	llm: LlmConfigSchema.default(() => LlmConfigSchema.parse({})),
+	scraper: ScraperConfigSchema.default(() => ScraperConfigSchema.parse({})),
+	vault: VaultConfigSchema.default(() => VaultConfigSchema.parse({}))
+}).strict();
+
+//#endregion
+//#region src/config/io.ts
+/** Load and validate pai.json5 config */
+async function loadConfig() {
+	const configPath = getConfigPath();
+	try {
+		const raw = await fs.readFile(configPath, "utf-8");
+		const parsed = JSON5.parse(raw);
+		return PaiConfigSchema.parse(parsed);
+	} catch (err) {
+		if (err.code === "ENOENT") return PaiConfigSchema.parse({});
+		throw err;
+	}
+}
+/** Load profiles.json5 */
+async function loadProfiles() {
+	const profilesPath = getProfilesPath();
+	try {
+		const raw = await fs.readFile(profilesPath, "utf-8");
+		return JSON5.parse(raw);
+	} catch (err) {
+		if (err.code === "ENOENT") return { profiles: {} };
+		throw err;
+	}
+}
+/** Write config file (with JSON5 formatting) */
+async function saveConfig(filePath, content) {
+	await fs.writeFile(filePath, content, "utf-8");
+}
+
+//#endregion
+//#region src/utils/process.ts
+/** Execute QMD CLI command and return stdout */
+async function execQmd(args) {
+	return new Promise((resolve, reject) => {
+		execFile("qmd", args, {
+			encoding: "utf-8",
+			timeout: 6e4
+		}, (err, stdout, stderr) => {
+			if (err) {
+				const msg = stderr?.trim() || err.message;
+				reject(/* @__PURE__ */ new Error(`qmd ${args[0]} failed: ${msg}`));
+			} else resolve(stdout);
+		});
+	});
+}
+/** Check if QMD is available on PATH */
+async function isQmdAvailable() {
+	try {
+		await execQmd(["status"]);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/utils/slug.ts
+/** Generate a URL-safe slug from a title string */
+function generateSlug(title) {
+	return title.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
+}
+/** Generate a timestamped filename: YYYY-MM-DDTHH-MM-{slug}.md */
+function generateRawFilename(title) {
+	return `${(/* @__PURE__ */ new Date()).toISOString().replace(/:\d{2}\.\d{3}Z$/, "").replace(/:/g, "-")}-${generateSlug(title) || "untitled"}.md`;
+}
+
+//#endregion
+//#region src/utils/frontmatter.ts
+/** Parse a markdown file with frontmatter */
+function parseFrontmatter(content) {
+	const result = matter(content);
+	return {
+		data: result.data,
+		content: result.content
+	};
+}
+/** Stringify data + content into a frontmatter markdown string */
+function stringifyFrontmatter(data, content) {
+	return matter.stringify(content, data);
+}
+/** Create a raw file with proper frontmatter */
+function createRawFile(frontmatter, title, body) {
+	return stringifyFrontmatter(frontmatter, `\n# ${title}\n\n${body}\n`);
+}
+/** Update frontmatter fields in a raw file */
+function updateRawFrontmatter(fileContent, updates) {
+	const { data, content } = parseFrontmatter(fileContent);
+	return stringifyFrontmatter({
+		...data,
+		...updates
+	}, content);
+}
+
+//#endregion
+//#region src/raw/add.ts
+/** Add plain text content to raw/local/ */
+async function addText(content, source = "local") {
+	const title = extractTitle$1(content);
+	const filename = generateRawFilename(title);
+	const dir = path.join(getRawDir(), "local");
+	await fs.mkdir(dir, { recursive: true });
+	const fileContent = createRawFile({
+		source,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		status: "pending"
+	}, title, content);
+	const filePath = path.join(dir, filename);
+	await fs.writeFile(filePath, fileContent, "utf-8");
+	return filePath;
+}
+/** Add a local file's content to raw/local/ */
+async function addFile(filePath, source = "local") {
+	const content = await fs.readFile(filePath, "utf-8");
+	const basename = path.basename(filePath, path.extname(filePath));
+	const filename = generateRawFilename(basename);
+	const dir = path.join(getRawDir(), "local");
+	await fs.mkdir(dir, { recursive: true });
+	const fileContent = createRawFile({
+		source,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		status: "pending"
+	}, basename, content);
+	const outPath = path.join(dir, filename);
+	await fs.writeFile(outPath, fileContent, "utf-8");
+	return outPath;
+}
+/** Add URL-scraped content to raw/web/ */
+async function addUrl(url, title, markdown) {
+	const filename = generateRawFilename(title);
+	const dir = path.join(getRawDir(), "web");
+	await fs.mkdir(dir, { recursive: true });
+	const fileContent = createRawFile({
+		source: "web",
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		url,
+		status: "pending"
+	}, title, markdown);
+	const filePath = path.join(dir, filename);
+	await fs.writeFile(filePath, fileContent, "utf-8");
+	return filePath;
+}
+/**
+* Add or update a connector-scanned entry to raw/connector/{name}/.
+* Uses scan_id in frontmatter for dedup:
+*   - If no existing file with same scan_id → create new
+*   - If existing file with same content body → skip ("skipped")
+*   - If existing file with different content → overwrite ("updated")
+* Returns "created" | "updated" | "skipped".
+*/
+async function addConnectorEntry(connectorName, entry) {
+	const dir = path.join(getRawDir(), "connector", connectorName);
+	await fs.mkdir(dir, { recursive: true });
+	const scanId = `${connectorName}/${entry.id}`;
+	const existingPath = await findByScanId(dir, scanId);
+	const fm = {
+		source: `connector/${connectorName}`,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		status: "pending",
+		scan_id: scanId
+	};
+	if (existingPath) {
+		const { content: oldBody } = parseFrontmatter(await fs.readFile(existingPath, "utf-8"));
+		const newBody = `\n# ${entry.title}\n\n${entry.content}\n`;
+		if (oldBody.trim() === newBody.trim()) return "skipped";
+		const fileContent = createRawFile(fm, entry.title, entry.content);
+		await fs.writeFile(existingPath, fileContent, "utf-8");
+		return "updated";
+	}
+	const filename = generateRawFilename(entry.id);
+	const fileContent = createRawFile(fm, entry.title, entry.content);
+	const filePath = path.join(dir, filename);
+	await fs.writeFile(filePath, fileContent, "utf-8");
+	return "created";
+}
+/** Find a raw file in a directory whose frontmatter scan_id matches */
+async function findByScanId(dir, scanId) {
+	try {
+		const entries = await fs.readdir(dir);
+		for (const name of entries) {
+			if (!name.endsWith(".md")) continue;
+			const filePath = path.join(dir, name);
+			const content = await fs.readFile(filePath, "utf-8");
+			if (content.includes(`scan_id: ${scanId}`) || content.includes(`scan_id: '${scanId}'`)) return filePath;
+		}
+	} catch {}
+	return null;
+}
+/** List all pending raw files (status: pending) */
+async function listPending() {
+	const rawDir = getRawDir();
+	const pending = [];
+	for (const sub of [
+		"local",
+		"web",
+		"connector"
+	]) {
+		const dir = path.join(rawDir, sub);
+		try {
+			const entries = await walkDir(dir);
+			for (const entry of entries) if (entry.endsWith(".md")) {
+				if ((await fs.readFile(entry, "utf-8")).includes("status: pending")) pending.push(entry);
+			}
+		} catch {}
+	}
+	return pending;
+}
+/** List all raw files regardless of status */
+async function listAll() {
+	const rawDir = getRawDir();
+	const files = [];
+	for (const sub of [
+		"local",
+		"web",
+		"connector"
+	]) {
+		const dir = path.join(rawDir, sub);
+		try {
+			const entries = await walkDir(dir);
+			files.push(...entries.filter((e) => e.endsWith(".md")));
+		} catch {}
+	}
+	return files;
+}
+/** Recursively walk a directory and return file paths */
+async function walkDir(dir) {
+	const results = [];
+	try {
+		const entries = await fs.readdir(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = path.join(dir, entry.name);
+			if (entry.isDirectory()) results.push(...await walkDir(fullPath));
+			else results.push(fullPath);
+		}
+	} catch {}
+	return results;
+}
+/** Extract a title from content (first line or first N words) */
+function extractTitle$1(content) {
+	const cleaned = (content.split("\n")[0]?.trim() ?? "").replace(/^#+\s*/, "");
+	if (cleaned.length > 0 && cleaned.length <= 100) return cleaned;
+	return content.split(/\s+/).slice(0, 8).join(" ").slice(0, 100) || "untitled";
+}
+
+//#endregion
+//#region src/profile/compile.ts
+const PROFILE_SECTIONS = [
+	{
+		heading: "Identity",
+		collectors: ["identity-profile", "github-profile"]
+	},
+	{
+		heading: "Environment & Tools",
+		collectors: ["dev-environment", "dev-preferences"]
+	},
+	{
+		heading: "Work Style & Habits",
+		collectors: ["shell-habits", "coding-rules"]
+	},
+	{
+		heading: "Active Projects & Recent Focus",
+		collectors: ["active-projects", "recent-focus"]
+	},
+	{
+		heading: "Digital Footprint",
+		collectors: [
+			"browser-bookmarks",
+			"browser-domains",
+			"productivity-setup"
+		]
+	},
+	{
+		heading: "Registry & Cloud Accounts",
+		collectors: ["social-profiles"]
+	},
+	{
+		heading: "Context",
+		collectors: ["calendar-context", "file-organization"]
+	}
+];
+/**
+* Compile CollectorResult[] into a structured profile markdown string.
+* No LLM involved — pure formatting.
+*/
+function compileProfile(results) {
+	const index = /* @__PURE__ */ new Map();
+	for (const r of results) index.set(r.id, r);
+	const sections = ["# Personal Profile", ""];
+	for (const section of PROFILE_SECTIONS) {
+		const parts = [];
+		for (const cid of section.collectors) {
+			const result = index.get(cid);
+			if (result?.content?.trim()) parts.push(result.content.trim());
+		}
+		if (parts.length === 0) continue;
+		sections.push(`## ${section.heading}`, "");
+		sections.push(parts.join("\n\n"));
+		sections.push("");
+	}
+	const coveredIds = new Set(PROFILE_SECTIONS.flatMap((s) => s.collectors));
+	const extras = [];
+	for (const r of results) if (!coveredIds.has(r.id) && r.content?.trim()) extras.push(`## ${r.title}`, "", r.content.trim(), "");
+	if (extras.length > 0) sections.push(...extras);
+	sections.push("---");
+	sections.push(`Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+	sections.push("");
+	return sections.join("\n");
+}
+
+//#endregion
+//#region src/connectors/sanitize.ts
+/**
+* Security sanitization utilities for connector-scanned content.
+* Strips secrets, credentials, and sensitive paths before writing to raw layer.
+*/
+/** Pattern matching shell export lines containing secrets */
+const SECRET_EXPORT_RE = /^(\s*export\s+)\w*(KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL|PASSWD)\w*\s*=.*/i;
+/** Pattern matching lines that look like inline secret assignments (no export) */
+const SECRET_ASSIGN_RE = /^\s*\w*(KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL|PASSWD)\w*\s*=\s*["']?\S+/i;
+/**
+* Strip secret export/assignment lines from shell config content.
+* Preserves comments and non-secret lines intact.
+*/
+function stripSecretExports(content) {
+	return content.split("\n").map((line) => {
+		if (SECRET_EXPORT_RE.test(line) || SECRET_ASSIGN_RE.test(line)) return "# [REDACTED by pai — secret removed]";
+		return line;
+	}).join("\n");
+}
+/**
+* Strip [credential] sections from git config content.
+* Removes the section header and all lines until the next section.
+*/
+function stripGitCredentials(content) {
+	const lines = content.split("\n");
+	const result = [];
+	let inCredentialSection = false;
+	for (const line of lines) {
+		if (/^\s*\[credential/i.test(line)) {
+			inCredentialSection = true;
+			result.push("# [REDACTED by pai — credential section removed]");
+			continue;
+		}
+		if (inCredentialSection && /^\s*\[/.test(line)) inCredentialSection = false;
+		if (!inCredentialSection) result.push(line);
+	}
+	return result.join("\n");
+}
+/**
+* Strip IdentityFile lines from SSH config.
+* Keeps Host, HostName, User, Port — removes key paths.
+*/
+function stripSshIdentityFiles(content) {
+	return content.split("\n").map((line) => {
+		if (/^\s*IdentityFile\s/i.test(line)) return "  # [REDACTED by pai — IdentityFile removed]";
+		return line;
+	}).join("\n");
+}
+
+//#endregion
+//#region src/connectors/mac/collectors.ts
+/**
+* Mac system context collectors.
+* Each collector gathers a specific category of personalized context
+* from the local macOS environment and returns a CollectorResult.
+*/
+/** Run a shell command and return stdout (empty string on failure) */
+async function exec(cmd, args) {
+	return new Promise((resolve) => {
+		execFile(cmd, args, {
+			encoding: "utf-8",
+			timeout: 15e3
+		}, (err, stdout) => {
+			resolve(err ? "" : stdout.trim());
+		});
+	});
+}
+/** Read a file, return empty string on failure */
+async function readSafe(filePath) {
+	try {
+		return await fs.readFile(filePath, "utf-8");
+	} catch {
+		return "";
+	}
+}
+/** Check if path exists */
+async function exists(p) {
+	try {
+		await fs.access(p);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Run osascript and return output */
+async function osascript(script) {
+	return exec("osascript", ["-e", script]);
+}
+/** Run defaults read and return output */
+async function defaultsRead(...args) {
+	return exec("defaults", ["read", ...args]);
+}
+const HOME = os.homedir();
+async function collectIdentityProfile() {
+	const lines = ["## User Identity"];
+	const username = await exec("id", ["-un"]);
+	if (username) lines.push(`- macOS Username: ${username}`);
+	const nameMatch = (await exec("dscl", [
+		".",
+		"-read",
+		`/Users/${username}`,
+		"RealName"
+	])).split("\n").find((l) => l.trim() && !l.includes("RealName"));
+	if (nameMatch?.trim()) lines.push(`- Real Name (local): ${nameMatch.trim()}`);
+	const mobileMe = await defaultsRead("MobileMeAccounts");
+	const appleIdMatch = mobileMe.match(/AccountID\s*=\s*"?([^";\n]+)/);
+	const displayNameMatch = mobileMe.match(/DisplayName\s*=\s*"?([^";\n]+)/);
+	if (displayNameMatch) lines.push(`- Apple ID Display Name: ${displayNameMatch[1].trim()}`);
+	if (appleIdMatch) lines.push(`- Apple ID: ${appleIdMatch[1].trim()}`);
+	const computerName = await exec("scutil", ["--get", "ComputerName"]);
+	if (computerName) lines.push(`- Computer Name: ${computerName}`);
+	const gitName = await exec("git", [
+		"config",
+		"--global",
+		"user.name"
+	]);
+	const gitEmail = await exec("git", [
+		"config",
+		"--global",
+		"user.email"
+	]);
+	if (gitName) lines.push(`- Git Name: ${gitName}`);
+	if (gitEmail) lines.push(`- Git Email: ${gitEmail}`);
+	lines.push("", "## Locale & Language");
+	const langList = (await defaultsRead("NSGlobalDomain", "AppleLanguages")).match(/"([^"]+)"/g)?.map((s) => s.replace(/"/g, "")) ?? [];
+	if (langList.length > 0) lines.push(`- Languages: ${langList.join(", ")}`);
+	const locale = await defaultsRead("NSGlobalDomain", "AppleLocale");
+	if (locale) lines.push(`- Locale: ${locale}`);
+	const inputSources = await defaultsRead("com.apple.HIToolbox", "AppleSelectedInputSources");
+	const inputMethods = inputSources.match(/"Input Mode"\s*=\s*"([^"]+)"/g) ?? [];
+	const bundleIds = inputSources.match(/"Bundle ID"\s*=\s*"([^"]+)"/g) ?? [];
+	const inputs = [...inputMethods, ...bundleIds].map((s) => s.replace(/.*"([^"]+)"$/, "$1")).filter((s) => !s.includes("PressAndHold"));
+	if (inputs.length > 0) lines.push(`- Input Methods: ${inputs.join(", ")}`);
+	const appearance = await defaultsRead("-g", "AppleInterfaceStyle");
+	lines.push(`- System Appearance: ${appearance || "Light"}`);
+	const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+	lines.push(`- Timezone: ${tz}`);
+	return {
+		id: "identity-profile",
+		title: "Mac User Identity Profile",
+		content: lines.join("\n")
+	};
+}
+async function collectCalendarContext() {
+	let calNames = [];
+	const raw = await osascript("tell application \"Calendar\" to get name of every calendar");
+	if (raw) calNames = raw.split(", ").map((s) => s.trim()).filter(Boolean);
+	const lines = [
+		"## Calendar Subscriptions",
+		"",
+		`Total calendars: ${calNames.length}`,
+		"",
+		...calNames.map((name) => `- ${name}`)
+	];
+	return {
+		id: "calendar-context",
+		title: "Calendar Context",
+		content: calNames.length > 0 ? lines.join("\n") : "No calendar data accessible (Calendar app may not be running)."
+	};
+}
+async function collectFileOrganization() {
+	const lines = [];
+	const docsDir = path.join(HOME, "Documents");
+	try {
+		const dirs = (await fs.readdir(docsDir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+		lines.push("## Documents Folders", "", ...dirs.map((d) => `- ${d}`));
+	} catch {
+		lines.push("## Documents Folders", "", "(not accessible)");
+	}
+	const desktopDir = path.join(HOME, "Desktop");
+	try {
+		const entries = await fs.readdir(desktopDir);
+		lines.push("", "## Desktop Items", "", ...entries.slice(0, 20).map((e) => `- ${e}`));
+		if (entries.length > 20) lines.push(`- ... and ${entries.length - 20} more`);
+	} catch {
+		lines.push("", "## Desktop Items", "", "(not accessible)");
+	}
+	const dlDir = path.join(HOME, "Downloads");
+	try {
+		const entries = await fs.readdir(dlDir);
+		lines.push("", "## Recent Downloads (latest 15 by name)", "", ...entries.slice(0, 15).map((e) => `- ${e}`));
+	} catch {
+		lines.push("", "## Recent Downloads", "", "(not accessible)");
+	}
+	return {
+		id: "file-organization",
+		title: "File Organization Structure",
+		content: lines.join("\n")
+	};
+}
+async function collectDevEnvironment() {
+	const lines = ["## Runtime Versions"];
+	for (const [name, cmd, args] of [
+		[
+			"Node.js",
+			"node",
+			["--version"]
+		],
+		[
+			"Python",
+			"python3",
+			["--version"]
+		],
+		[
+			"Go",
+			"go",
+			["version"]
+		],
+		[
+			"Rust",
+			"rustc",
+			["--version"]
+		],
+		[
+			"Java",
+			"java",
+			["--version"]
+		]
+	]) {
+		const ver = await exec(cmd, args);
+		if (ver) {
+			const first = ver.split("\n")[0] ?? ver;
+			lines.push(`- ${name}: ${first}`);
+		}
+	}
+	lines.push("", "## Package Managers");
+	for (const pm of [
+		"brew",
+		"pnpm",
+		"npm",
+		"pip3",
+		"cargo"
+	]) {
+		const which = await exec("which", [pm]);
+		if (which) lines.push(`- ${pm}: ${which}`);
+	}
+	const docker = await exec("docker", ["--version"]);
+	if (docker) lines.push("", "## Docker", "", `- ${docker}`);
+	lines.push("", "## Shell");
+	const shell = process.env.SHELL ?? "";
+	lines.push(`- Shell: ${shell}`);
+	const zshrc = await readSafe(path.join(HOME, ".zshrc"));
+	const themeMatch = zshrc.match(/^ZSH_THEME="?([^"\n]+)/m);
+	const pluginsMatch = zshrc.match(/^plugins=\(([^)]+)\)/m);
+	if (themeMatch) lines.push(`- Oh-My-Zsh Theme: ${themeMatch[1]}`);
+	if (pluginsMatch) lines.push(`- Oh-My-Zsh Plugins: ${pluginsMatch[1].trim()}`);
+	const npmGlobal = await exec("npm", [
+		"list",
+		"-g",
+		"--depth=0"
+	]);
+	if (npmGlobal) {
+		const pkgs = npmGlobal.split("\n").filter((l) => l.startsWith("├") || l.startsWith("└")).map((l) => l.replace(/^[├└─┬│\s]+/, "").trim()).filter(Boolean);
+		if (pkgs.length > 0) lines.push("", "## Global npm Packages", "", ...pkgs.map((p) => `- ${p}`));
+	}
+	const casks = await exec("brew", ["list", "--cask"]);
+	if (casks) {
+		const caskList = casks.split("\n").filter(Boolean);
+		lines.push("", "## Homebrew Casks", "", ...caskList.map((c) => `- ${c}`));
+	}
+	return {
+		id: "dev-environment",
+		title: "Development Environment",
+		content: lines.join("\n")
+	};
+}
+async function collectDevPreferences() {
+	const lines = [];
+	const zshrc = await readSafe(path.join(HOME, ".zshrc"));
+	if (zshrc) {
+		const sanitized = stripSecretExports(zshrc);
+		const aliases = sanitized.split("\n").filter((l) => l.match(/^\s*alias\s/));
+		if (aliases.length > 0) lines.push("## Shell Aliases", "", ...aliases);
+		const pathLines = sanitized.split("\n").filter((l) => l.match(/^\s*export\s+PATH/) && !l.includes("REDACTED"));
+		if (pathLines.length > 0) lines.push("", "## PATH Additions", "", ...pathLines);
+	}
+	const gitconfig = await readSafe(path.join(HOME, ".gitconfig"));
+	if (gitconfig) {
+		const sanitized = stripGitCredentials(gitconfig);
+		lines.push("", "## Git Config", "", "```", sanitized.trim(), "```");
+	}
+	const gitAliases = await exec("git", [
+		"config",
+		"--global",
+		"--get-regexp",
+		"alias"
+	]);
+	if (gitAliases) lines.push("", "## Git Aliases", "", ...gitAliases.split("\n").map((l) => `- ${l}`));
+	const defaultBranch = await exec("git", [
+		"config",
+		"--global",
+		"init.defaultBranch"
+	]);
+	if (defaultBranch) lines.push("", `## Default Git Branch: ${defaultBranch}`);
+	const extDir = path.join(HOME, ".cursor", "extensions");
+	try {
+		const exts = (await fs.readdir(extDir)).filter((e) => !e.startsWith(".") && e !== "extensions.json");
+		if (exts.length > 0) lines.push("", "## Cursor Extensions", "", ...exts.map((e) => `- ${e}`));
+	} catch {}
+	return {
+		id: "dev-preferences",
+		title: "Development Preferences",
+		content: lines.join("\n")
+	};
+}
+async function collectShellHabits() {
+	const raw = await readSafe(path.join(HOME, ".zsh_history"));
+	if (!raw) return {
+		id: "shell-habits",
+		title: "Shell Command Habits",
+		content: "No zsh history found."
+	};
+	const rawLines = raw.split("\n");
+	const totalEntries = rawLines.length;
+	const freq = /* @__PURE__ */ new Map();
+	for (const line of rawLines) {
+		const firstWord = line.replace(/^:\s*\d+:\d+;/, "").trim().split(/\s+/)[0];
+		if (firstWord && firstWord.length > 0 && firstWord.length < 50) freq.set(firstWord, (freq.get(firstWord) ?? 0) + 1);
+	}
+	const top30 = [...freq.entries()].sort((a, b) => b[1] - a[1]).slice(0, 30);
+	return {
+		id: "shell-habits",
+		title: "Shell Command Habits",
+		content: [
+			`Total history entries: ${totalEntries}`,
+			"",
+			"## Most Used Commands (Top 30)",
+			"",
+			...top30.map(([cmd, count]) => `- ${cmd}: ${count} times`)
+		].join("\n")
+	};
+}
+async function collectCodingRules() {
+	const sections = [];
+	const claudePaths = [path.join(HOME, "CLAUDE.md"), path.join(HOME, ".claude", "CLAUDE.md")];
+	for (const p of claudePaths) {
+		const content = await readSafe(p);
+		if (content) {
+			const relPath = p.replace(HOME, "~");
+			sections.push(`## ${relPath}`, "", content.trim(), "");
+		}
+	}
+	const cmdDir = path.join(HOME, ".claude", "commands");
+	try {
+		const mdFiles = (await fs.readdir(cmdDir)).filter((e) => e.endsWith(".md"));
+		if (mdFiles.length > 0) {
+			sections.push("## Claude Custom Commands", "");
+			for (const f of mdFiles) {
+				const content = await readSafe(path.join(cmdDir, f));
+				if (content) sections.push(`### ${f}`, "", content.trim(), "");
+			}
+		}
+	} catch {}
+	const activeRepos = await findRecentGitRepos(30);
+	const projectRules = [];
+	for (const repo of activeRepos.slice(0, 10)) for (const ruleFile of [
+		"CLAUDE.md",
+		"AGENTS.md",
+		".cursorrules"
+	]) {
+		const content = await readSafe(path.join(repo, ruleFile));
+		if (content && content.length > 10) {
+			const repoName = path.basename(repo);
+			projectRules.push(`### ${repoName}/${ruleFile}`, "", content.trim().slice(0, 2e3), "");
+		}
+	}
+	if (projectRules.length > 0) sections.push("## Project-Level Rules", "", ...projectRules);
+	const cursorRulesDir = path.join(HOME, ".cursor", "rules");
+	try {
+		const mdFiles = (await fs.readdir(cursorRulesDir)).filter((e) => e.endsWith(".md") || e.endsWith(".mdc"));
+		if (mdFiles.length > 0) {
+			sections.push("## Global Cursor Rules", "");
+			for (const f of mdFiles) {
+				const content = await readSafe(path.join(cursorRulesDir, f));
+				if (content) sections.push(`### ${f}`, "", content.trim().slice(0, 1e3), "");
+			}
+		}
+	} catch {}
+	return {
+		id: "coding-rules",
+		title: "Coding Rules and AI Agent Config",
+		content: sections.length > 0 ? sections.join("\n") : "No coding rules found."
+	};
+}
+async function collectActiveProjects() {
+	const lines = [];
+	const repos = await findRecentGitRepos(30);
+	if (repos.length > 0) {
+		lines.push("## Active Git Repositories (last 30 days)", "");
+		for (const repo of repos) {
+			const name = repo.replace(HOME, "~");
+			lines.push(`- ${name}`);
+		}
+	}
+	const sshConfig = await readSafe(path.join(HOME, ".ssh", "config"));
+	if (sshConfig) {
+		const hosts = stripSshIdentityFiles(sshConfig).split("\n").filter((l) => /^\s*Host\s/i.test(l) && !l.includes("*")).map((l) => l.replace(/^\s*Host\s+/i, "").trim());
+		if (hosts.length > 0) lines.push("", "## SSH Hosts", "", ...hosts.map((h) => `- ${h}`));
+	}
+	const cloudDir = path.join(HOME, "Library", "CloudStorage");
+	try {
+		const entries = await fs.readdir(cloudDir);
+		if (entries.length > 0) lines.push("", "## Cloud Storage", "", ...entries.map((e) => `- ${e}`));
+	} catch {}
+	return {
+		id: "active-projects",
+		title: "Active Projects and Infrastructure",
+		content: lines.join("\n")
+	};
+}
+async function collectProductivitySetup() {
+	const lines = [];
+	try {
+		const apps = (await fs.readdir("/Applications")).filter((e) => e.endsWith(".app")).map((e) => e.replace(".app", ""));
+		lines.push("## Installed Applications", "", ...apps.map((a) => `- ${a}`));
+	} catch {
+		lines.push("## Installed Applications", "", "(not accessible)");
+	}
+	const dockApps = await defaultsRead("com.apple.dock", "persistent-apps");
+	if (dockApps) {
+		const labels = [...dockApps.matchAll(/"file-label"\s*=\s*"?([^";\n}]+)/g)].map((m) => m[1].trim()).filter(Boolean);
+		if (labels.length > 0) lines.push("", "## Dock Apps (pinned)", "", ...labels.map((a) => `- ${a}`));
+	}
+	const browserMatch = (await defaultsRead("com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers")).match(/LSHandlerRoleAll\s*=\s*"([^"]+)"/);
+	if (browserMatch) {
+		const bundleId = browserMatch[1];
+		const browserName = bundleId.includes("edge") ? "Microsoft Edge" : bundleId.includes("chrome") ? "Google Chrome" : bundleId.includes("firefox") ? "Firefox" : bundleId.includes("safari") ? "Safari" : bundleId;
+		lines.push("", `## Default Browser: ${browserName}`);
+	}
+	const resolutions = [...(await exec("system_profiler", ["SPDisplaysDataType"])).matchAll(/Resolution:\s*(.+)/g)].map((m) => m[1].trim());
+	if (resolutions.length > 0) lines.push("", "## Screen Resolution", "", ...resolutions.map((r) => `- ${r}`));
+	return {
+		id: "productivity-setup",
+		title: "Productivity Setup",
+		content: lines.join("\n")
+	};
+}
+async function collectBrowserBookmarks() {
+	const raw = await readSafe(path.join(HOME, "Library", "Application Support", "Microsoft Edge", "Default", "Bookmarks"));
+	if (!raw) return {
+		id: "browser-bookmarks",
+		title: "Browser Bookmark Structure",
+		content: "No Edge bookmarks found."
+	};
+	try {
+		const data = JSON.parse(raw);
+		const folders = [];
+		let totalUrls = 0;
+		function walk(node, depth) {
+			if (node.type === "folder") {
+				const children = node.children ?? [];
+				const name = node.name ?? "";
+				if (children.length > 0) folders.push({
+					name,
+					count: children.length,
+					depth
+				});
+				for (const child of children) walk(child, depth + 1);
+			} else if (node.type === "url") totalUrls++;
+		}
+		const roots = data.roots;
+		for (const root of Object.values(roots)) if (root && typeof root === "object" && "children" in root) walk(root, 0);
+		folders.sort((a, b) => b.count - a.count);
+		return {
+			id: "browser-bookmarks",
+			title: "Browser Bookmark Structure",
+			content: [
+				`Total bookmarks: ${totalUrls}`,
+				`Total folders: ${folders.length}`,
+				"",
+				"## Top Bookmark Folders (by item count)",
+				"",
+				...folders.slice(0, 40).map((f) => `- ${"  ".repeat(Math.min(f.depth, 2))}${f.name}: ${f.count} items`)
+			].join("\n")
+		};
+	} catch {
+		return {
+			id: "browser-bookmarks",
+			title: "Browser Bookmark Structure",
+			content: "Failed to parse Edge bookmarks."
+		};
+	}
+}
+async function collectBrowserDomains() {
+	const histPath = path.join(HOME, "Library", "Application Support", "Microsoft Edge", "Default", "History");
+	if (!await exists(histPath)) return {
+		id: "browser-domains",
+		title: "Browser Top Domains (30 days)",
+		content: "No Edge history found."
+	};
+	const tmpDb = path.join(os.tmpdir(), `pai-edge-history-${Date.now()}.db`);
+	try {
+		await fs.copyFile(histPath, tmpDb);
+		const output = await exec("sqlite3", [tmpDb, `
+      SELECT
+        REPLACE(REPLACE(SUBSTR(url, 1, INSTR(SUBSTR(url, 9), '/') + 8), 'https://', ''), 'http://', '') as domain,
+        COUNT(*) as visits
+      FROM urls
+      WHERE last_visit_time > (strftime('%s', 'now', '-30 days') + 11644473600) * 1000000
+      GROUP BY domain
+      ORDER BY visits DESC
+      LIMIT 30;
+    `.trim()]);
+		if (!output) return {
+			id: "browser-domains",
+			title: "Browser Top Domains (30 days)",
+			content: "Could not query Edge history (DB may be locked)."
+		};
+		return {
+			id: "browser-domains",
+			title: "Browser Top Domains (30 days)",
+			content: [
+				"## Top 30 Domains (last 30 days)",
+				"",
+				...output.split("\n").map((line) => {
+					const [domain, visits] = line.split("|");
+					return `- ${domain}: ${visits} visits`;
+				})
+			].join("\n")
+		};
+	} finally {
+		try {
+			await fs.unlink(tmpDb);
+		} catch {}
+	}
+}
+async function collectGitHubProfile() {
+	const lines = [];
+	if (!await exec("gh", ["--version"])) return {
+		id: "github-profile",
+		title: "GitHub Profile",
+		content: "GitHub CLI (gh) not installed."
+	};
+	if (!await exec("gh", ["auth", "status"])) return {
+		id: "github-profile",
+		title: "GitHub Profile",
+		content: "GitHub CLI not authenticated. Run `gh auth login` to enable."
+	};
+	const userJson = await exec("gh", [
+		"api",
+		"user",
+		"--jq",
+		"[.login, .name, .bio, .company, .location, .blog, .public_repos, .followers, .following, .created_at] | @tsv"
+	]);
+	if (userJson) {
+		const [login, name, bio, company, location, blog, publicRepos, followers, following, createdAt] = userJson.split("	");
+		lines.push("## GitHub Profile", "");
+		if (login) lines.push(`- Username: ${login}`);
+		if (name) lines.push(`- Name: ${name}`);
+		if (bio) lines.push(`- Bio: ${bio}`);
+		if (company) lines.push(`- Company: ${company}`);
+		if (location) lines.push(`- Location: ${location}`);
+		if (blog) lines.push(`- Website: ${blog}`);
+		if (publicRepos) lines.push(`- Public Repos: ${publicRepos}`);
+		if (followers || following) lines.push(`- Followers/Following: ${followers}/${following}`);
+		if (createdAt) lines.push(`- Member since: ${createdAt}`);
+	}
+	const reposJson = await exec("gh", [
+		"repo",
+		"list",
+		"--limit",
+		"10",
+		"--sort",
+		"updated",
+		"--json",
+		"name,description,primaryLanguage,pushedAt,isPrivate",
+		"--jq",
+		".[] | [.name, .description, (.primaryLanguage.name // \"\"), .pushedAt, .isPrivate] | @tsv"
+	]);
+	if (reposJson) {
+		const repos = reposJson.split("\n").filter(Boolean);
+		if (repos.length > 0) {
+			lines.push("", "## Recent GitHub Repos (by push date)", "");
+			for (const repo of repos) {
+				const [name, desc, lang, _pushed, isPrivate] = repo.split("	");
+				const visibility = isPrivate === "true" ? "private" : "public";
+				const langTag = lang ? ` [${lang}]` : "";
+				const descTag = desc ? ` — ${desc}` : "";
+				lines.push(`- ${name}${langTag} (${visibility})${descTag}`);
+			}
+		}
+	}
+	const starsJson = await exec("gh", [
+		"api",
+		"user/starred?per_page=20&sort=created&direction=desc",
+		"--jq",
+		".[].full_name"
+	]);
+	if (starsJson) {
+		const stars = starsJson.split("\n").filter(Boolean);
+		if (stars.length > 0) {
+			lines.push("", "## Recently Starred Repos (interest signals)", "");
+			lines.push(stars.map((s) => `- ${s}`).join("\n"));
+		}
+	}
+	return {
+		id: "github-profile",
+		title: "GitHub Profile & Activity",
+		content: lines.length > 0 ? lines.join("\n") : "No GitHub data accessible."
+	};
+}
+async function collectRecentFocus() {
+	const lines = [];
+	const repos = await findRecentGitRepos(14);
+	const commitTopics = /* @__PURE__ */ new Map();
+	const recentMessages = [];
+	for (const repo of repos.slice(0, 8)) {
+		const log = await exec("git", [
+			"-C",
+			repo,
+			"log",
+			"--oneline",
+			"--since=14 days ago",
+			"--format=%s",
+			"-n",
+			"20"
+		]);
+		if (log) for (const msg of log.split("\n").filter(Boolean)) {
+			recentMessages.push(msg);
+			const type = msg.match(/^(feat|fix|refactor|test|docs|chore|perf|ci|build|style)/i);
+			if (type) {
+				const key = type[1].toLowerCase();
+				commitTopics.set(key, (commitTopics.get(key) ?? 0) + 1);
+			}
+		}
+	}
+	if (commitTopics.size > 0) {
+		const sorted = [...commitTopics.entries()].sort((a, b) => b[1] - a[1]);
+		lines.push("## Recent Commit Activity (last 2 weeks)", "");
+		lines.push(`Total commits analyzed: ${recentMessages.length}`);
+		lines.push("", "Commit types:");
+		for (const [type, count] of sorted) lines.push(`- ${type}: ${count}`);
+	}
+	if (recentMessages.length > 0) {
+		lines.push("", "## Recent Commit Messages (sample)", "");
+		const unique = [...new Set(recentMessages)].slice(0, 15);
+		for (const msg of unique) lines.push(`- ${msg}`);
+	}
+	const histRaw = await readSafe(path.join(HOME, ".zsh_history"));
+	if (histRaw) {
+		const recent = histRaw.split("\n").slice(-200);
+		const cdPaths = /* @__PURE__ */ new Map();
+		const tools = /* @__PURE__ */ new Map();
+		for (const line of recent) {
+			const cmd = line.replace(/^:\s*\d+:\d+;/, "").trim();
+			const cdMatch = cmd.match(/^cd\s+(.+)/);
+			if (cdMatch) {
+				const dest = cdMatch[1].trim().replace(/^~/, HOME);
+				cdPaths.set(dest, (cdPaths.get(dest) ?? 0) + 1);
+			}
+			const toolMatch = cmd.match(/^(docker|kubectl|terraform|aws|gcloud|firebase|vercel|netlify|npm|pnpm|yarn|bun|cargo|go|python|pip|uv)\b/);
+			if (toolMatch) tools.set(toolMatch[1], (tools.get(toolMatch[1]) ?? 0) + 1);
+		}
+		if (cdPaths.size > 0) {
+			const topDirs = [...cdPaths.entries()].sort((a, b) => b[1] - a[1]).slice(0, 8);
+			lines.push("", "## Recent Working Directories", "");
+			for (const [dir, count] of topDirs) lines.push(`- ${dir.replace(HOME, "~")}: ${count}x`);
+		}
+		if (tools.size > 0) {
+			const topTools = [...tools.entries()].sort((a, b) => b[1] - a[1]);
+			lines.push("", "## Recently Used Tools (from history)", "");
+			for (const [tool, count] of topTools) lines.push(`- ${tool}: ${count}x`);
+		}
+	}
+	return {
+		id: "recent-focus",
+		title: "Recent Focus & Activity",
+		content: lines.length > 0 ? lines.join("\n") : "No recent activity data found."
+	};
+}
+async function collectSocialProfiles() {
+	const lines = [];
+	const npmrc = await readSafe(path.join(HOME, ".npmrc"));
+	if (npmrc) {
+		const registryMatch = npmrc.match(/^registry\s*=\s*(.+)/m);
+		if (registryMatch) lines.push(`- npm registry: ${registryMatch[1].trim()}`);
+		const scopes = npmrc.match(/^@[\w-]+:registry/gm);
+		if (scopes) for (const s of scopes) lines.push(`- npm scope: ${s.split(":")[0]}`);
+	}
+	const npmUser = await exec("npm", ["whoami"]);
+	if (npmUser) lines.push(`- npm username: ${npmUser}`);
+	const pypirc = await readSafe(path.join(HOME, ".pypirc"));
+	if (pypirc) {
+		const repoMatch = pypirc.match(/repository\s*=\s*(.+)/);
+		if (repoMatch) lines.push(`- PyPI repository: ${repoMatch[1].trim()}`);
+		const usernameMatch = pypirc.match(/username\s*=\s*(.+)/);
+		if (usernameMatch) lines.push(`- PyPI username: ${usernameMatch[1].trim()}`);
+	}
+	const dockerConfig = await readSafe(path.join(HOME, ".docker", "config.json"));
+	if (dockerConfig) try {
+		const cfg = JSON.parse(dockerConfig);
+		const auths = Object.keys(cfg.auths ?? {});
+		if (auths.length > 0) lines.push(`- Docker registries: ${auths.join(", ")}`);
+	} catch {}
+	const cargoConfig = await readSafe(path.join(HOME, ".cargo", "config.toml"));
+	if (cargoConfig) {
+		const registries = cargoConfig.match(/\[registries\.(\w+)\]/g);
+		if (registries) lines.push(`- Cargo registries: ${registries.map((r) => r.replace(/\[registries\.|\]/g, "")).join(", ")}`);
+	}
+	const awsIdentity = await exec("aws", [
+		"sts",
+		"get-caller-identity",
+		"--query",
+		"Account",
+		"--output",
+		"text"
+	]);
+	if (awsIdentity) lines.push(`- AWS Account: ${awsIdentity}`);
+	const gcpProject = await exec("gcloud", [
+		"config",
+		"get-value",
+		"project"
+	]);
+	if (gcpProject && !gcpProject.includes("unset")) lines.push(`- GCP Project: ${gcpProject}`);
+	const vercelUser = await exec("vercel", ["whoami"]);
+	if (vercelUser) lines.push(`- Vercel: ${vercelUser}`);
+	return {
+		id: "social-profiles",
+		title: "Registry & Cloud Profiles",
+		content: lines.length > 0 ? [
+			"## Registry & Cloud Accounts",
+			"",
+			...lines
+		].join("\n") : "No registry or cloud profiles detected."
+	};
+}
+/** Find git repos under ~/Documents modified in the last N days */
+async function findRecentGitRepos(days) {
+	const output = await exec("find", [
+		path.join(HOME, "Documents"),
+		"-maxdepth",
+		"4",
+		"-name",
+		".git",
+		"-type",
+		"d",
+		"-mtime",
+		`-${days}`
+	]);
+	if (!output) return [];
+	return output.split("\n").filter(Boolean).map((p) => p.replace(/\/.git$/, ""));
+}
+/** All available Mac collectors in execution order */
+const ALL_COLLECTORS = [
+	collectIdentityProfile,
+	collectCalendarContext,
+	collectFileOrganization,
+	collectDevEnvironment,
+	collectDevPreferences,
+	collectShellHabits,
+	collectCodingRules,
+	collectActiveProjects,
+	collectProductivitySetup,
+	collectBrowserBookmarks,
+	collectBrowserDomains,
+	collectGitHubProfile,
+	collectRecentFocus,
+	collectSocialProfiles
+];
+
+//#endregion
+//#region src/profile/index.ts
+/**
+* Profile module — compile, load, and rebuild user profiles.
+*/
+/** Load the current profile from disk. Returns null if not found. */
+async function loadProfile() {
+	try {
+		return await fs.readFile(getProfilePath(), "utf-8");
+	} catch {
+		return null;
+	}
+}
+/** Save profile markdown to disk. */
+async function saveProfile(content) {
+	const profilePath = getProfilePath();
+	await fs.writeFile(profilePath, content, "utf-8");
+	return profilePath;
+}
+/**
+* Full rebuild: scan local machine → compile profile → write to disk.
+* Also writes raw files for the scan data (for vault/distill pipeline compatibility).
+*/
+async function rebuildProfile(opts) {
+	const verbose = opts?.verbose ?? true;
+	const spin = verbose ? spinner("Scanning local machine...") : null;
+	const settled = await Promise.allSettled(ALL_COLLECTORS.map((collector) => collector()));
+	const results = [];
+	const failed = [];
+	for (let i = 0; i < settled.length; i++) {
+		const s = settled[i];
+		if (s.status === "fulfilled") results.push(s.value);
+		else {
+			const name = ALL_COLLECTORS[i].name;
+			failed.push(name);
+			if (verbose) warn(`Collector ${name} failed: ${String(s.reason)}`);
+		}
+	}
+	spin?.succeed(`Scanned ${results.length} sources (${failed.length} failed)`);
+	if (!opts?.skipRaw) for (const entry of results) try {
+		await addConnectorEntry("mac", entry);
+	} catch {}
+	return {
+		profilePath: await saveProfile(compileProfile(results)),
+		results
+	};
+}
+
+//#endregion
+//#region src/cli/register.init.ts
+/** Create directory structure, write default configs, register QMD, scan & compile profile. */
+async function runInit(options = {}) {
+	const { overwriteConfig = false, skipScan = false } = options;
+	const paiHome = getPaiHome();
+	const dirs = [
+		path.join(getRawDir(), "local"),
+		path.join(getRawDir(), "web"),
+		path.join(getRawDir(), "connector"),
+		path.join(getVaultDir(), "coding"),
+		path.join(getVaultDir(), "work"),
+		path.join(getVaultDir(), "life"),
+		path.join(getVaultDir(), "preferences"),
+		path.join(getVaultDir(), "context"),
+		getSkillsDir(),
+		getConfigDir()
+	];
+	for (const dir of dirs) await fs.mkdir(dir, { recursive: true });
+	const configPath = getConfigPath();
+	const profilesPath = getProfilesPath();
+	const prefsPath = getPreferencesPath();
+	if (overwriteConfig) {
+		await saveConfig(configPath, DEFAULT_CONFIG);
+		await saveConfig(profilesPath, DEFAULT_PROFILES);
+		await saveConfig(prefsPath, DEFAULT_PREFERENCES);
+	} else {
+		try {
+			await fs.access(configPath);
+			info("Config already exists, skipping.");
+		} catch {
+			await saveConfig(configPath, DEFAULT_CONFIG);
+		}
+		try {
+			await fs.access(profilesPath);
+			info("Profiles config already exists, skipping.");
+		} catch {
+			await saveConfig(profilesPath, DEFAULT_PROFILES);
+		}
+		try {
+			await fs.access(prefsPath);
+			info("Preferences already exists, skipping.");
+		} catch {
+			await saveConfig(prefsPath, DEFAULT_PREFERENCES);
+			success("Created preferences.md — edit to customize AI behavior.");
+		}
+	}
+	if (await isQmdAvailable()) {
+		try {
+			await execQmd([
+				"collection",
+				"add",
+				getRawDir(),
+				"--name",
+				"raw",
+				"--mask",
+				"**/*.md"
+			]);
+			success("QMD collection 'raw' registered.");
+		} catch {
+			warn("QMD collection 'raw' may already exist, skipping.");
+		}
+		try {
+			await execQmd([
+				"collection",
+				"add",
+				getVaultDir(),
+				"--name",
+				"vault",
+				"--mask",
+				"**/*.md"
+			]);
+			success("QMD collection 'vault' registered.");
+		} 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) {
+		log("");
+		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)`);
+		}
+	}
+	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`);
+	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.");
+	}
+}
+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) => {
+		const paiHome = getPaiHome();
+		const spin = spinner(`Initializing pai at ${paiHome}...`);
+		try {
+			spin.succeed(`Initializing pai at ${paiHome}`);
+			await runInit({
+				overwriteConfig: false,
+				skipScan: opts.skipScan
+			});
+		} catch (err) {
+			spin.fail("Initialization failed");
+			const msg = err instanceof Error ? err.message : String(err);
+			error(msg);
+			process.exit(1);
+		}
+	});
+}
+
+//#endregion
+//#region src/scraper/index.ts
+/**
+* Scrape a URL and return title + markdown content.
+* Uses fetch + defuddle for content extraction.
+* Falls back to basic HTML extraction if defuddle is unavailable.
+*/
+async function scrapeUrl(url, timeout = 3e4) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeout);
+	let html;
+	try {
+		const response = await fetch(url, {
+			signal: controller.signal,
+			headers: {
+				"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+				Accept: "text/html,application/xhtml+xml"
+			}
+		});
+		if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+		html = await response.text();
+	} finally {
+		clearTimeout(timer);
+	}
+	try {
+		const defuddleMod = await import("defuddle/node");
+		const Defuddle = defuddleMod.Defuddle ?? defuddleMod.default;
+		if (Defuddle) {
+			const result = new Defuddle(html, { url }).parse();
+			return {
+				url,
+				title: result.title || extractTitleFromHtml(html),
+				markdown: result.content ? htmlToSimpleMarkdown(result.content) : extractTextFromHtml(html)
+			};
+		}
+	} catch {
+		warn("defuddle not available, using basic HTML extraction");
+	}
+	return {
+		url,
+		title: extractTitleFromHtml(html),
+		markdown: extractTextFromHtml(html)
+	};
+}
+/** Extract <title> from HTML */
+function extractTitleFromHtml(html) {
+	return html.match(/<title[^>]*>([^<]+)<\/title>/i)?.[1]?.trim() ?? "Untitled";
+}
+/** Basic HTML to text extraction (fallback) */
+function extractTextFromHtml(html) {
+	return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/\s+/g, " ").trim().slice(0, 1e4);
+}
+/** Convert simple HTML to markdown */
+function htmlToSimpleMarkdown(html) {
+	return html.replace(/<h1[^>]*>([\s\S]*?)<\/h1>/gi, "# $1\n\n").replace(/<h2[^>]*>([\s\S]*?)<\/h2>/gi, "## $1\n\n").replace(/<h3[^>]*>([\s\S]*?)<\/h3>/gi, "### $1\n\n").replace(/<p[^>]*>([\s\S]*?)<\/p>/gi, "$1\n\n").replace(/<br\s*\/?>/gi, "\n").replace(/<strong[^>]*>([\s\S]*?)<\/strong>/gi, "**$1**").replace(/<em[^>]*>([\s\S]*?)<\/em>/gi, "*$1*").replace(/<a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, "[$2]($1)").replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, "- $1\n").replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, "`$1`").replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, "```\n$1\n```\n").replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+//#endregion
+//#region src/cli/register.add.ts
+function registerAddCommand(program) {
+	program.command("add <input>").description("Add content to raw layer (text, file path, or URL with --url)").option("--url", "Treat input as URL, scrape and save").option("--source <source>", "Source tag", "local").action(async (input, opts) => {
+		try {
+			let filePath;
+			if (opts.url) {
+				const spin = spinner(`Scraping ${input}...`);
+				try {
+					const result = await scrapeUrl(input, (await loadConfig()).scraper.timeout);
+					filePath = await addUrl(input, result.title, result.markdown);
+					spin.succeed(`Scraped: ${result.title}`);
+				} catch (err) {
+					spin.fail("Scraping failed");
+					throw err;
+				}
+			} else try {
+				if ((await fs.stat(input)).isFile()) {
+					filePath = await addFile(input, opts.source);
+					success(`Added file: ${input}`);
+				} else throw new Error("Not a file");
+			} catch {
+				filePath = await addText(input, opts.source);
+				success("Added text content");
+			}
+			info(`Saved to: ${filePath}`);
+			info("Run \"pai distill\" to process into vault.");
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			error(`Failed to add: ${msg}`);
+			process.exit(1);
+		}
+	});
+}
+
+//#endregion
+//#region src/llm/client.ts
+let cachedConfig = null;
+let cachedPreferences = null;
+async function getConfig() {
+	if (!cachedConfig) cachedConfig = await loadConfig();
+	return cachedConfig;
+}
+/** Load user preferences.md (cached per process) */
+async function getPreferences() {
+	if (cachedPreferences !== null) return cachedPreferences;
+	try {
+		cachedPreferences = await fs.readFile(getPreferencesPath(), "utf-8");
+	} catch {
+		cachedPreferences = "";
+	}
+	return cachedPreferences;
+}
+/** Create an OpenAI-compatible client from config */
+async function createLlmClient() {
+	const config = await getConfig();
+	const apiKey = process.env[config.llm.apiKeyEnv];
+	if (!apiKey) throw new Error(`Missing API key: set ${config.llm.apiKeyEnv} environment variable`);
+	return new OpenAI({
+		apiKey,
+		baseURL: config.llm.baseUrl || void 0
+	});
+}
+/**
+* Single LLM call with system + user messages.
+* Automatically prepends user preferences to the system prompt.
+* Retries once on failure.
+*/
+async function llmCall(prompt, system, model) {
+	const config = await getConfig();
+	const client = await createLlmClient();
+	const modelName = model ?? config.llm.cheapModel;
+	const prefs = await getPreferences();
+	const fullSystem = prefs ? `${system}\n\n---USER PREFERENCES (always respect these)---\n${prefs}` : system;
+	for (let attempt = 0; attempt < 2; attempt++) try {
+		return (await client.chat.completions.create({
+			model: modelName,
+			messages: [{
+				role: "system",
+				content: fullSystem
+			}, {
+				role: "user",
+				content: prompt
+			}],
+			temperature: .3
+		})).choices[0]?.message?.content ?? "";
+	} catch (err) {
+		if (attempt === 0) {
+			await new Promise((r) => setTimeout(r, 1e3));
+			continue;
+		}
+		throw err;
+	}
+	return "";
+}
+
+//#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.
+
+CRITICAL: One raw input often contains MULTIPLE types of data. You MUST split them into separate entries routed to different vault files.
+
+Two kinds of valuable content:
+
+1) EXPERIENTIAL: concrete lessons, preferences, tips, or experiences.
+2) SYSTEM CONTEXT: data from system/connector scans — identity, environment, habits, preferences.
+
+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
+
+Do NOT mark as valuable: generic news, ads, or content with no personal signal.
+
+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"
+}
+
+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`;
+}
+/** Build user prompt for triage */
+function triageUserPrompt(rawContent, vaultFiles) {
+	return `Evaluate this raw input and decide if it's worth distilling:
+
+---RAW CONTENT---
+${rawContent}
+---END RAW CONTENT---
+${vaultFiles.length > 0 ? `\nExisting vault files:\n${vaultFiles.map((f) => `- ${f}`).join("\n")}` : "\nNo existing vault files yet."}
+
+Route to context/, preferences/, life/, coding/, or work/ as appropriate. Respond with JSON only.`;
+}
+
+//#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);
+	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"
+		}];
+		return {
+			valuable: Boolean(raw.valuable),
+			entries,
+			reason: raw.reason ?? ""
+		};
+	} catch {
+		return {
+			valuable: false,
+			entries: [],
+			reason: `Failed to parse triage 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.`;
+}
+
+//#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
+*/
+async function distillAndMerge(rawContent, rawFilePath, targetFile, extractDirective) {
+	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;
+}
+
+//#endregion
+//#region src/distill/index.ts
+/** List all existing vault files (relative paths like "coding/python.md") */
+async function listVaultFiles() {
+	const vaultDir = getVaultDir();
+	const files = [];
+	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));
+			}
+		} catch {}
+	}
+	await walk(vaultDir);
+	return files;
+}
+/** Run the full distill pipeline on all pending raw files */
+async function distillPipeline(options = {}) {
+	const result = {
+		processed: 0,
+		valuable: 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.");
+		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)}...`);
+		try {
+			const rawFileContent = await fs.readFile(filePath, "utf-8");
+			const { content } = parseFrontmatter(rawFileContent);
+			const triage = await triageRawFile(content, vaultFilesList);
+			result.processed++;
+			if (!triage.valuable || triage.entries.length === 0) {
+				spin.succeed(`Discarded: ${path.basename(filePath)} — ${triage.reason}`);
+				result.discarded++;
+				if (!options.dryRun) {
+					const updated = updateRawFrontmatter(rawFileContent, { status: "discarded" });
+					await fs.writeFile(filePath, 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++;
+				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(", ")
+			});
+			await fs.writeFile(filePath, updated, "utf-8");
+			spin.succeed(`Distilled ${path.basename(filePath)} → ${targets.join(", ")} (${triage.entries.length} entries)`);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			spin.fail(`Error processing ${path.basename(filePath)}: ${msg}`);
+			result.errors.push(`${filePath}: ${msg}`);
+		}
+	}
+	return result;
+}
+
+//#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) => {
+		try {
+			const result = await distillPipeline({
+				singleFile: opts.file,
+				dryRun: opts.dryRun
+			});
+			log("");
+			log(bold("Distill summary:"));
+			log(`  Processed:  ${result.processed}`);
+			log(`  Valuable:   ${result.valuable}`);
+			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.");
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			error(`Distill failed: ${msg}`);
+			process.exit(1);
+		}
+	});
+}
+
+//#endregion
+//#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.
+
+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`;
+}
+/** 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.
+
+Required sections:
+# Personal Context — ${profileName}
+
+## Who I Am
+## Preferences
+## Hard-won Lessons
+## Current Work
+
+---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 "未提供".`;
+}
+
+//#endregion
+//#region src/generate/index.ts
+/** Recursively list all markdown files in a directory */
+async function walkMd(dir) {
+	const results = [];
+	try {
+		const entries = await fs.readdir(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			const full = path.join(dir, entry.name);
+			if (entry.isDirectory()) results.push(...await walkMd(full));
+			else if (entry.name.endsWith(".md")) results.push(full);
+		}
+	} catch {}
+	return results;
+}
+/** Collect vault file contents matching scope patterns */
+async function collectVaultContent(scope) {
+	const vaultDir = getVaultDir();
+	const allFiles = await walkMd(vaultDir);
+	const matched = [];
+	for (const file of allFiles) {
+		const relative = "vault/" + path.relative(vaultDir, file);
+		for (const pattern of scope) if (minimatch(relative, pattern)) {
+			matched.push(file);
+			break;
+		}
+	}
+	const contents = [];
+	for (const file of matched) try {
+		const content = await fs.readFile(file, "utf-8");
+		contents.push(`--- ${path.relative(vaultDir, file)} ---\n${content}`);
+	} catch {}
+	return contents.join("\n\n");
+}
+/** Generate a single SKILL.md profile */
+async function generateProfile(profileName) {
+	const profileDef = (await loadProfiles()).profiles[profileName];
+	if (!profileDef) throw new Error(`Profile "${profileName}" not found in profiles.json5`);
+	const vaultContent = await collectVaultContent(profileDef.scope);
+	if (!vaultContent.trim()) throw new Error(`No vault content found for profile "${profileName}". Run 'pai distill' first.`);
+	const system = generateSystemPrompt();
+	const skillMd = await llmCall(generateUserPrompt(profileName, vaultContent, profileDef.maxLines), system);
+	const skillsDir = getSkillsDir();
+	await fs.mkdir(skillsDir, { recursive: true });
+	const outPath = path.join(skillsDir, `${profileName}.md`);
+	await fs.writeFile(outPath, skillMd.trim() + "\n", "utf-8");
+	return outPath;
+}
+/** Generate all profiles defined in profiles.json5 */
+async function generateAll() {
+	const profiles = await loadProfiles();
+	const profileNames = Object.keys(profiles.profiles);
+	if (profileNames.length === 0) {
+		warn("No profiles defined in profiles.json5");
+		return [];
+	}
+	const results = [];
+	for (const name of profileNames) {
+		const spin = spinner(`Generating profile: ${name}...`);
+		try {
+			const outPath = await generateProfile(name);
+			spin.succeed(`Generated ${name} → ${outPath}`);
+			results.push(outPath);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			spin.fail(`Failed to generate ${name}: ${msg}`);
+		}
+	}
+	return results;
+}
+
+//#endregion
+//#region src/cli/register.generate.ts
+function registerGenerateCommand(program) {
+	program.command("generate").description("Generate SKILL.md profiles from vault content").option("--profile <name>", "Generate a specific profile only").action(async (opts) => {
+		try {
+			if (opts.profile) {
+				const spin = spinner(`Generating profile: ${opts.profile}...`);
+				try {
+					const outPath = await generateProfile(opts.profile);
+					spin.succeed(`Generated: ${outPath}`);
+				} catch (err) {
+					spin.fail("Generation failed");
+					throw err;
+				}
+			} else {
+				const results = await generateAll();
+				if (results.length > 0) {
+					log("");
+					success(`Generated ${results.length} SKILL.md profile(s).`);
+					info("These files can be used by AI agents (Cursor, Claude, etc.).");
+				}
+			}
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			error(`Generate failed: ${msg}`);
+			process.exit(1);
+		}
+	});
+}
+
+//#endregion
+//#region src/search/index.ts
+/**
+* Hybrid search via QMD.
+* - "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)
+*
+* For "search" (fast) mode, QMD BM25 doesn't support CJK tokenization,
+* so we supplement with ripgrep 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");
+	let results = parseSearchResults(await execQmd([
+		mode,
+		query,
+		"--collection",
+		collection,
+		"--json",
+		"-n",
+		String(n)
+	]));
+	if (mode === "search" && results.length === 0 && hasCjk(query)) results = await grepFallback(query, collection, n);
+	return results;
+}
+/** Parse QMD JSON search output into SearchResult[] */
+function parseSearchResults(stdout) {
+	try {
+		const parsed = JSON.parse(stdout);
+		if (!Array.isArray(parsed)) return [];
+		return parsed.map((item) => ({
+			file: item.file ?? "",
+			title: item.title ?? void 0,
+			snippet: item.snippet ?? item.content?.slice(0, 200) ?? "",
+			score: item.score
+		}));
+	} catch {
+		return [];
+	}
+}
+/** Check if a string contains CJK characters */
+function hasCjk(text) {
+	return /[\u4e00-\u9fff\u3040-\u30ff\uac00-\ud7af]/.test(text);
+}
+/**
+* grep fallback for CJK text that BM25 can't tokenize.
+* Runs: grep -rl "query" <dir> --include="*.md"
+* Then reads matched files and extracts context.
+*/
+async function grepFallback(query, collection, n) {
+	const baseDir = collection === "raw" ? getRawDir() : getVaultDir();
+	const stdout = await new Promise((resolve) => {
+		execFile("grep", [
+			"-rl",
+			"--include=*.md",
+			query,
+			baseDir
+		], {
+			encoding: "utf-8",
+			timeout: 5e3
+		}, (_err, out) => {
+			resolve(out ?? "");
+		});
+	});
+	if (!stdout.trim()) return [];
+	const files = stdout.trim().split("\n").slice(0, n);
+	const results = [];
+	for (const filePath of files) {
+		if (!filePath) continue;
+		const snippet = (await new Promise((resolve) => {
+			execFile("grep", [
+				"-m1",
+				"-C1",
+				query,
+				filePath
+			], {
+				encoding: "utf-8",
+				timeout: 2e3
+			}, (_err, out) => resolve(out ?? ""));
+		})).replace(/\n/g, " ").trim().slice(0, 160);
+		const relative = path.relative(baseDir, filePath);
+		const titleLine = await new Promise((resolve) => {
+			execFile("grep", [
+				"-m1",
+				"^# ",
+				filePath
+			], {
+				encoding: "utf-8",
+				timeout: 1e3
+			}, (_err, out) => resolve(out?.replace(/^#\s+/, "").trim() ?? ""));
+		});
+		results.push({
+			file: `qmd://${collection}/${relative}`,
+			title: titleLine || path.basename(filePath, ".md"),
+			snippet,
+			score: 1
+		});
+	}
+	return results;
+}
+/** Update QMD index: runs `qmd update` + `qmd embed` */
+async function updateIndex() {
+	await execQmd(["update"]);
+	await execQmd(["embed"]);
+}
+
+//#endregion
+//#region src/cli/register.search.ts
+function registerSearchCommand(program) {
+	program.command("search <query>").description("Search vault (default) or raw via QMD").option("--raw", "Search raw collection instead of vault").option("--all", "Search all collections").option("--fast", "BM25 keyword search only (instant, no AI)").option("--vector", "Vector similarity search only").option("--json", "Output results as JSON (for agent consumption)").option("-n, --num <number>", "Number of results", "5").action(async (query, opts) => {
+		try {
+			const n = parseInt(opts.num, 10);
+			const collection = opts.raw ? "raw" : opts.all ? void 0 : "vault";
+			const mode = opts.fast ? "search" : opts.vector ? "vsearch" : "query";
+			if (opts.all) {
+				const [vaultResults, rawResults] = await Promise.all([search(query, "vault", n, mode), search(query, "raw", n, mode)]);
+				if (opts.json) {
+					process.stdout.write(JSON.stringify({
+						vault: vaultResults,
+						raw: rawResults
+					}, null, 2) + "\n");
+					return;
+				}
+				log("");
+				log(bold(`Search results for: "${query}"`));
+				if (vaultResults.length > 0) {
+					log("\n" + bold("Vault:"));
+					for (const r of vaultResults) printResult(r);
+				}
+				if (rawResults.length > 0) {
+					log("\n" + bold("Raw:"));
+					for (const r of rawResults) printResult(r);
+				}
+				if (vaultResults.length === 0 && rawResults.length === 0) info("No results found.");
+			} else {
+				const results = await search(query, collection, n, mode);
+				if (opts.json) {
+					process.stdout.write(JSON.stringify(results, null, 2) + "\n");
+					return;
+				}
+				log("");
+				log(bold(`Search results for: "${query}" (${collection ?? "all"})`));
+				if (results.length === 0) info("No results found.");
+				else for (const r of results) printResult(r);
+			}
+			log("");
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			error(`Search failed: ${msg}`);
+			process.exit(1);
+		}
+	});
+}
+function printResult(r) {
+	const score = r.score != null ? dim(` (${r.score.toFixed(2)})`) : "";
+	log(`  ${bold(r.title ?? r.file)}${score}`);
+	log(`  ${dim(r.snippet.slice(0, 120))}`);
+	log(`  ${dim(r.file)}`);
+	log("");
+}
+
+//#endregion
+//#region src/cli/register.index.ts
+function registerIndexCommand(program) {
+	program.command("index").description("Update QMD index (qmd update + qmd embed)").action(async () => {
+		const spin = spinner("Updating QMD index...");
+		try {
+			await updateIndex();
+			spin.succeed("QMD index updated successfully.");
+		} catch (err) {
+			spin.fail("Index update failed");
+			const msg = err instanceof Error ? err.message : String(err);
+			error(msg);
+			process.exit(1);
+		}
+	});
+}
+
+//#endregion
+//#region src/cli/register.import.ts
+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 result = await scanMac({ dryRun: opts.dryRun });
+				if (opts.dryRun) return;
+				log("");
+				success(`Mac scan complete: ${result.created} created, ${result.updated} updated, ${result.skipped} unchanged`);
+				if (result.failed.length > 0) warn(`${result.failed.length} failed: ${result.failed.join(", ")}`);
+				info("Run \"pai distill\" to process scanned data.");
+				return;
+			}
+			if (opts.source === "gmail") {
+				const { syncGmail } = await import("./gmail-B9ja9sKN.mjs");
+				const parsedDays = parseInt(opts.days ?? "30", 10);
+				const days = Number.isNaN(parsedDays) ? 30 : parsedDays;
+				const doSync = () => syncGmail({
+					days,
+					query: opts.query,
+					maxResults: 100
+				});
+				await encryption.loadKey();
+				await googleOAuth.init();
+				let entries;
+				const spinGmail = opts.dryRun ? null : spinner("Syncing Gmail...");
+				try {
+					entries = await doSync();
+				} catch (err) {
+					if (err instanceof Error && err.message.includes("Not authenticated")) {
+						spinGmail?.stop();
+						info("Not authenticated; starting Google OAuth...");
+						await googleOAuth.authorize();
+						const spinRetry = opts.dryRun ? null : spinner("Syncing Gmail...");
+						entries = await doSync();
+						spinRetry?.stop();
+					} else throw err;
+				} finally {
+					spinGmail?.stop();
+				}
+				if (opts.dryRun) {
+					info(`Would import ${entries.length} Gmail message(s).`);
+					return;
+				}
+				let created = 0;
+				let updated = 0;
+				let skipped = 0;
+				for (const entry of entries) {
+					const status = await addConnectorEntry("gmail", entry);
+					if (status === "created") created++;
+					else if (status === "updated") updated++;
+					else skipped++;
+				}
+				success(`Gmail import: ${created} created, ${updated} updated, ${skipped} unchanged`);
+				info("Run \"pai distill\" to process imported data.");
+				return;
+			}
+			if (opts.source === "calendar") {
+				const { syncCalendar } = await import("./calendar-BHcM4wfQ.mjs");
+				const parsedDays = parseInt(opts.days ?? "30", 10);
+				const days = Number.isNaN(parsedDays) ? 30 : parsedDays;
+				const doSync = () => syncCalendar({
+					lookbackDays: days,
+					lookforwardDays: 90
+				});
+				await encryption.loadKey();
+				await googleOAuth.init();
+				let entries;
+				const spinCal = opts.dryRun ? null : spinner("Syncing Calendar...");
+				try {
+					entries = await doSync();
+				} catch (err) {
+					if (err instanceof Error && err.message.includes("Not authenticated")) {
+						spinCal?.stop();
+						info("Not authenticated; starting Google OAuth...");
+						await googleOAuth.authorize();
+						const spinRetry = opts.dryRun ? null : spinner("Syncing Calendar...");
+						entries = await doSync();
+						spinRetry?.stop();
+					} else throw err;
+				} finally {
+					spinCal?.stop();
+				}
+				if (opts.dryRun) {
+					info(`Would import ${entries.length} calendar event(s).`);
+					return;
+				}
+				let created = 0;
+				let updated = 0;
+				let skipped = 0;
+				for (const entry of entries) {
+					const status = await addConnectorEntry("calendar", entry);
+					if (status === "created") created++;
+					else if (status === "updated") updated++;
+					else skipped++;
+				}
+				success(`Calendar import: ${created} created, ${updated} updated, ${skipped} unchanged`);
+				info("Run \"pai distill\" to process imported data.");
+				return;
+			}
+			if (!opts.path) {
+				error("--path is required for this source. Usage: pai import --source <name> --path <dir>");
+				process.exit(1);
+			}
+			const sourcePath = opts.path;
+			const source = `connector/${opts.source}`;
+			const stat = await fs.stat(sourcePath);
+			const outDir = path.join(getRawDir(), "connector", opts.source);
+			await fs.mkdir(outDir, { recursive: true });
+			let imported = 0;
+			if (stat.isDirectory()) {
+				const entries = await fs.readdir(sourcePath, { withFileTypes: true });
+				for (const entry of entries) if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".txt") || entry.name.endsWith(".json"))) {
+					const content = await fs.readFile(path.join(sourcePath, entry.name), "utf-8");
+					const title = path.basename(entry.name, path.extname(entry.name));
+					const filename = generateRawFilename(title);
+					const fileContent = createRawFile({
+						source,
+						timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+						status: "pending"
+					}, title, content);
+					await fs.writeFile(path.join(outDir, filename), fileContent, "utf-8");
+					imported++;
+				}
+			} else {
+				const content = await fs.readFile(sourcePath, "utf-8");
+				const title = path.basename(sourcePath, path.extname(sourcePath));
+				const filename = generateRawFilename(title);
+				const fileContent = createRawFile({
+					source,
+					timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+					status: "pending"
+				}, title, content);
+				await fs.writeFile(path.join(outDir, filename), fileContent, "utf-8");
+				imported = 1;
+			}
+			success(`Imported ${imported} file(s) from ${opts.source}`);
+			info("Run \"pai distill\" to process imported data.");
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			error(`Import failed: ${msg}`);
+			process.exit(1);
+		}
+	});
+}
+
+//#endregion
+//#region src/cli/register.status.ts
+function registerStatusCommand(program) {
+	program.command("status").description("Show pai data status overview").option("--json", "Output as JSON (for agent consumption)").action(async (opts) => {
+		try {
+			const allRaw = await listAll();
+			const pendingRaw = await listPending();
+			const vaultFiles = await countFiles(getVaultDir());
+			const skillFiles = await countFiles(getSkillsDir());
+			if (opts.json) {
+				process.stdout.write(JSON.stringify({
+					raw: {
+						total: allRaw.length,
+						pending: pendingRaw.length
+					},
+					vault: { files: vaultFiles },
+					profiles: skillFiles
+				}, null, 2) + "\n");
+				return;
+			}
+			log("");
+			log(bold("pai status"));
+			log("─".repeat(40));
+			log(`  Raw files:      ${allRaw.length} total, ${pendingRaw.length} pending`);
+			log(`  Vault files:    ${vaultFiles}`);
+			log(`  SKILL profiles: ${skillFiles}`);
+			log("");
+			if (pendingRaw.length > 0) info(`${pendingRaw.length} file(s) waiting to be distilled. Run "pai distill" to process.`);
+			if (vaultFiles === 0) info("No vault content yet. Run \"pai add <text>\" then \"pai distill\".");
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			error(`Status check failed: ${msg}`);
+			process.exit(1);
+		}
+	});
+}
+async function countFiles(dir) {
+	let count = 0;
+	try {
+		const entries = await fs.readdir(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			const full = path.join(dir, entry.name);
+			if (entry.isDirectory()) count += await countFiles(full);
+			else if (entry.name.endsWith(".md")) count++;
+		}
+	} catch {}
+	return count;
+}
+
+//#endregion
+//#region src/cli/register.reset.ts
+function askConfirm(question) {
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	return new Promise((resolve) => {
+		rl.question(question, (answer) => {
+			rl.close();
+			resolve(/^y|yes$/i.test(answer.trim()));
+		});
+	});
+}
+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) => {
+		const paiHome = getPaiHome();
+		if (!opts.force) {
+			if (!await askConfirm(`Remove ALL data at ${paiHome} and re-initialize? [y/N] `)) {
+				info("Reset cancelled.");
+				return;
+			}
+		}
+		const spin = spinner(`Resetting pai at ${paiHome}...`);
+		try {
+			await fs.rm(paiHome, {
+				recursive: true,
+				force: true
+			});
+			await runInit({ overwriteConfig: true });
+			spin.succeed(`pai reset complete. Fresh state at ${paiHome}`);
+		} catch (err) {
+			spin.fail("Reset failed");
+			const msg = err instanceof Error ? err.message : String(err);
+			error(msg);
+			process.exit(1);
+		}
+	});
+}
+
+//#endregion
+//#region src/ask/system-prompt.ts
+/**
+* System prompt for the ask agent (personal AI secretary).
+* Built in sections, similar to clawdbot system-prompt.ts.
+*/
+function buildAskSystemPrompt() {
+	const sections = [];
+	const paiHome = getPaiHome();
+	const homeDir = os.homedir();
+	sections.push(`You are a personal AI secretary who knows the user intimately.
+Your job: answer questions about the user accurately, specifically, and honestly.
+Today's date: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
+User home: ${homeDir}
+PAI data directory: ${paiHome}`);
+	sections.push(`## Data Layout
+${paiHome}/
+├── profile.md          # Compiled user profile (identity, env, projects)
+├── raw/                # Original immutable data with timestamps
+│   ├── local/          # Manual input
+│   ├── web/            # URL scrapes
+│   └── connector/      # Imported data from connectors (dynamic — use queryConnector to discover)
+├── vault/              # Distilled knowledge (experiences, preferences, lessons)
+│   ├── coding/
+│   ├── context/
+│   ├── life/
+│   └── preferences/
+└── config/             # Configuration files`);
+	sections.push(`## Tool Strategy
+
+### Knowledge tools (use first — fast, structured)
+- readProfile: Read compiled user profile — fastest way to understand who the user is
+- searchVault: Search distilled knowledge. Ranked by RELEVANCE, not recency.
+- searchRaw: Search original raw data. Has timestamps in frontmatter. Ranked by RELEVANCE, not recency.
+
+### Connector data tool (for time/fact-based questions — calendar, email, etc.)
+- queryConnector: Query imported data from ANY connector source.
+  - Call WITHOUT source → discovers available sources (calendar, gmail, mac, or any future connector)
+  - Call WITH source + range → returns entries sorted by date, with structured fields
+  - Supports range: upcoming/today/this_week/past_week/past_month/all
+  - ALWAYS use this for schedule, email, or any time-sensitive imported data questions
+  - Examples: "下一个会议" → queryConnector(source="calendar", range="upcoming", limit=3)
+  - Examples: "最近邮件" → queryConnector(source="gmail", range="past_week", sort="desc")
+
+### Filesystem tools (use to go deeper)
+- readFile: Read full content of any file. ALWAYS use this after search finds a relevant file — search snippets are too short to answer well.
+- grep: Search file contents with regex (ripgrep)
+- glob: Find files by pattern
+- ls: List directory contents
+- bash: Execute shell commands
+
+### CRITICAL: Always read files after searching
+Search tools return short snippets. When you find relevant results:
+1. Use readFile to read the full content of the top results
+2. Extract specific details (names, dates, numbers) from the full text
+3. NEVER answer based on search snippets alone — they are incomplete
+
+### Recommended flow
+1. For calendar/email/time-sensitive data → use queryConnector FIRST (time-aware, structured)
+2. readProfile → understand who the user is
+3. searchVault/searchRaw → find relevant topics
+4. readFile → read full content of promising results
+5. grep/glob/bash → dig deeper if needed
+
+### Time-sensitive queries
+searchVault and searchRaw rank by relevance, NOT by recency.
+When the user asks about schedules, recent events, emails, or activity:
+- Use queryConnector — it parses dates from content and supports time range filtering
+- For system state: use bash (e.g. \`git -C <project_dir> log --oneline -20 --since="1 week ago"\`)
+- Do NOT rely solely on search for time-based questions — search has no time ranking`);
+	sections.push(`## Rules
+- ONLY answer based on data from tools — NEVER fabricate information
+- If you cannot find the answer after thorough searching, say so honestly
+- Be specific: use real names, versions, dates, numbers from the data
+- Be concise but substantive: answer like a knowledgeable personal secretary
+- NEVER give empty or placeholder answers — if data is sparse, say what you found and what's missing
+- When citing sources, prefer qmd:// paths from vault/raw searches`);
+	return sections.join("\n\n");
+}
+
+//#endregion
+//#region src/ask/tools-meta.ts
+const BASH_TIMEOUT_MS = 3e4;
+const BASH_OUTPUT_MAX_BYTES = 10 * 1024;
+function resolvePath(raw) {
+	const trimmed = raw.trim();
+	if (trimmed.startsWith("~")) return path.join(os.homedir(), trimmed.slice(1).replace(/^\//, ""));
+	return path.resolve(trimmed);
+}
+const ReadFileParams = Type.Object({
+	path: Type.String({ description: "Absolute or relative file path" }),
+	offset: Type.Optional(Type.Number({ description: "Start line (1-based)" })),
+	limit: Type.Optional(Type.Number({ description: "Number of lines to read" }))
+});
+const readFileTool = {
+	name: "readFile",
+	label: "Read File",
+	description: "Read file contents. Supports offset/limit for large files. Path can be absolute or relative; ~ expands to home directory.",
+	parameters: ReadFileParams,
+	execute: async (_toolCallId, params) => {
+		const resolved = resolvePath(params.path);
+		try {
+			const lines = (await fs.readFile(resolved, "utf-8")).split("\n");
+			const start = Math.min(lines.length, params.offset != null ? Math.max(0, params.offset - 1) : 0);
+			const end = params.limit != null ? Math.min(lines.length, start + params.limit) : lines.length;
+			return {
+				content: [{
+					type: "text",
+					text: lines.slice(start, end).join("\n")
+				}],
+				details: {
+					path: resolved,
+					lines: end - start,
+					totalLines: lines.length
+				}
+			};
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${msg}`
+				}],
+				details: {
+					error: msg,
+					path: resolved
+				}
+			};
+		}
+	}
+};
+const GrepParams = Type.Object({
+	pattern: Type.String({ description: "Regex pattern to search" }),
+	path: Type.Optional(Type.String({ description: "File or directory to search in" })),
+	glob: Type.Optional(Type.String({ description: "File glob filter, e.g. '*.ts'" })),
+	maxResults: Type.Optional(Type.Number({ description: "Max matching lines to return (default 20)" }))
+});
+const grepTool = {
+	name: "grep",
+	label: "Grep",
+	description: "Search file contents using ripgrep (rg). Returns matching lines with context.",
+	parameters: GrepParams,
+	execute: async (_toolCallId, params) => {
+		const maxResults = params.maxResults ?? 20;
+		const args = [
+			"-n",
+			"-m",
+			String(maxResults),
+			params.pattern
+		];
+		if (params.path) args.push(resolvePath(params.path));
+		if (params.glob) args.push("--glob", params.glob);
+		return new Promise((resolve) => {
+			execFile("rg", args, {
+				encoding: "utf-8",
+				timeout: 1e4,
+				maxBuffer: 512 * 1024
+			}, (err, stdout, stderr) => {
+				if (err) {
+					if (err.code === "1" || err.code === 1) {
+						resolve({
+							content: [{
+								type: "text",
+								text: "No matches found."
+							}],
+							details: {
+								matches: [],
+								count: 0
+							}
+						});
+						return;
+					}
+					resolve({
+						content: [{
+							type: "text",
+							text: `Error: ${stderr?.trim() || err.message}`
+						}],
+						details: { error: stderr?.trim() || err.message }
+					});
+					return;
+				}
+				const lines = stdout.trim().split("\n").slice(0, maxResults);
+				resolve({
+					content: [{
+						type: "text",
+						text: lines.join("\n")
+					}],
+					details: {
+						matches: lines,
+						count: lines.length
+					}
+				});
+			});
+		});
+	}
+};
+async function globWalk(dir, pattern, results, baseDir) {
+	const { minimatch } = await import("minimatch");
+	const mm = new minimatch.Minimatch(pattern, { dot: true });
+	let entries;
+	try {
+		entries = await fs.readdir(dir, { withFileTypes: true });
+	} catch {
+		return;
+	}
+	for (const e of entries) {
+		const full = path.join(dir, e.name);
+		const relative = path.relative(baseDir, full);
+		if (e.isDirectory()) await globWalk(full, pattern, results, baseDir);
+		else if (mm.match(relative) || mm.match(e.name)) results.push(full);
+	}
+}
+const GlobParams = Type.Object({
+	pattern: Type.String({ description: "Glob pattern, e.g. '**/*.md'" }),
+	cwd: Type.Optional(Type.String({ description: "Base directory (default: current)" }))
+});
+const globTool = {
+	name: "glob",
+	label: "Find Files",
+	description: "Find files matching a glob pattern. Returns file paths. Pattern e.g. '**/*.md' or '*.ts'.",
+	parameters: GlobParams,
+	execute: async (_toolCallId, params) => {
+		const baseDir = params.cwd ? resolvePath(params.cwd) : process.cwd();
+		const results = [];
+		await globWalk(baseDir, params.pattern, results, baseDir);
+		const limited = results.slice(0, 200);
+		return {
+			content: [{
+				type: "text",
+				text: limited.length > 0 ? limited.join("\n") : "No files matched the pattern."
+			}],
+			details: {
+				paths: limited,
+				count: results.length
+			}
+		};
+	}
+};
+const LsParams = Type.Object({ path: Type.String({ description: "Directory path" }) });
+const lsTool = {
+	name: "ls",
+	label: "List Directory",
+	description: "List directory contents with file types and sizes. Path can be absolute or ~/...",
+	parameters: LsParams,
+	execute: async (_toolCallId, params) => {
+		const resolved = resolvePath(params.path);
+		try {
+			const entries = await fs.readdir(resolved, { withFileTypes: true });
+			const items = [];
+			for (const e of entries) {
+				const item = {
+					name: e.name,
+					type: e.isDirectory() ? "dir" : "file"
+				};
+				if (e.isFile()) try {
+					item.size = (await fs.stat(path.join(resolved, e.name))).size;
+				} catch {}
+				items.push(item);
+			}
+			return {
+				content: [{
+					type: "text",
+					text: items.map((i) => `${i.type === "dir" ? "📁" : "📄"} ${i.name}${i.size != null ? ` (${i.size}B)` : ""}`).join("\n")
+				}],
+				details: {
+					path: resolved,
+					entries: items
+				}
+			};
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${msg}`
+				}],
+				details: {
+					error: msg,
+					path: resolved
+				}
+			};
+		}
+	}
+};
+const BashParams = Type.Object({
+	command: Type.String({ description: "Shell command to execute" }),
+	cwd: Type.Optional(Type.String({ description: "Working directory" }))
+});
+const bashTool = {
+	name: "bash",
+	label: "Shell",
+	description: "Execute a shell command. Use for checking system state, running pai commands, etc. Timeout: 30s. Output truncated to 10KB.",
+	parameters: BashParams,
+	execute: async (_toolCallId, params) => {
+		const workDir = params.cwd ? resolvePath(params.cwd) : process.cwd();
+		return new Promise((resolve) => {
+			execFile("bash", ["-c", params.command], {
+				encoding: "utf-8",
+				timeout: BASH_TIMEOUT_MS,
+				maxBuffer: BASH_OUTPUT_MAX_BYTES,
+				cwd: workDir
+			}, (err, stdout, stderr) => {
+				if (err) {
+					resolve({
+						content: [{
+							type: "text",
+							text: [
+								stdout ? `stdout: ${stdout.slice(0, 2e3)}` : "",
+								stderr ? `stderr: ${stderr.slice(0, 2e3)}` : "",
+								`error: ${err.message}`
+							].filter(Boolean).join("\n")
+						}],
+						details: {
+							exitCode: err.code ?? -1,
+							error: err.message
+						}
+					});
+					return;
+				}
+				const output = (stdout ?? "").slice(0, BASH_OUTPUT_MAX_BYTES);
+				const stderrTrimmed = (stderr ?? "").trim();
+				resolve({
+					content: [{
+						type: "text",
+						text: stderrTrimmed ? `${output}\nstderr: ${stderrTrimmed}` : output
+					}],
+					details: { exitCode: 0 }
+				});
+			});
+		});
+	}
+};
+
+//#endregion
+//#region src/ask/tools-connector.ts
+/**
+* Try to extract a meaningful content date from markdown body.
+* Checks common field patterns across connector types:
+*   **Time**: ...   (calendar events)
+*   **Date**: ...   (emails, generic)
+*   **Created**: ...
+* Falls back to frontmatter timestamp (import time).
+*/
+function extractContentDate(content, frontmatter) {
+	const patterns = [
+		/\*\*Time\*\*:\s*(\S+)/,
+		/\*\*Date\*\*:\s*(.+)/,
+		/\*\*Created\*\*:\s*(.+)/
+	];
+	for (const re of patterns) {
+		const m = content.match(re);
+		if (m) {
+			const raw = re === patterns[0] ? m[1] : m[1].trim();
+			const d = new Date(raw);
+			if (!isNaN(d.getTime())) return d;
+		}
+	}
+	if (typeof frontmatter.timestamp === "string") {
+		const d = new Date(frontmatter.timestamp);
+		if (!isNaN(d.getTime())) return d;
+	}
+	return null;
+}
+/** Extract title from "# Title" in markdown content */
+function extractTitle(content) {
+	const m = content.match(/^#\s+(.+)/m);
+	return m ? m[1].trim() : "(no title)";
+}
+/** Extract all "- **Field**: value" pairs from markdown content */
+function extractFields(content) {
+	const fields = {};
+	const re = /\*\*(\w[\w\s]*?)\*\*:\s*(.+)/g;
+	let match;
+	while ((match = re.exec(content)) !== null) fields[match[1].trim()] = match[2].trim();
+	return fields;
+}
+/** Read and parse all markdown files in a connector subdirectory */
+async function readConnectorDir(subdir) {
+	const dir = path.join(getPaiHome(), "raw", "connector", subdir);
+	let fileNames;
+	try {
+		fileNames = (await fs.readdir(dir)).filter((f) => f.endsWith(".md"));
+	} catch {
+		return [];
+	}
+	const results = [];
+	const BATCH = 50;
+	for (let i = 0; i < fileNames.length; i += BATCH) {
+		const batch = fileNames.slice(i, i + BATCH);
+		const parsed = await Promise.all(batch.map(async (f) => {
+			const filePath = path.join(dir, f);
+			try {
+				const { data, content } = matter(await fs.readFile(filePath, "utf-8"));
+				const fm = data;
+				return {
+					file: filePath,
+					title: extractTitle(content),
+					date: extractContentDate(content, fm),
+					fields: extractFields(content),
+					frontmatter: fm
+				};
+			} catch {
+				return null;
+			}
+		}));
+		for (const p of parsed) if (p) results.push(p);
+	}
+	return results;
+}
+const QueryConnectorParams = Type.Object({
+	source: Type.Optional(Type.String({ description: "Connector source to query (e.g. 'calendar', 'gmail', 'mac'). Omit to list all available sources." })),
+	range: Type.Optional(Type.Union([
+		Type.Literal("upcoming"),
+		Type.Literal("today"),
+		Type.Literal("this_week"),
+		Type.Literal("past_week"),
+		Type.Literal("past_month"),
+		Type.Literal("all")
+	], { description: "Time range filter. 'upcoming' = future events only, 'today' = today, 'this_week' = ±7 days, 'past_week' = last 7 days, 'past_month' = last 30 days, 'all' = no filter. Default: 'all'." })),
+	limit: Type.Optional(Type.Number({ description: "Max entries to return (default 10)" })),
+	query: Type.Optional(Type.String({ description: "Optional text filter on title/content (case-insensitive)" })),
+	sort: Type.Optional(Type.Union([Type.Literal("asc"), Type.Literal("desc")], { description: "Sort by date: 'asc' = oldest first (good for upcoming events), 'desc' = newest first (good for emails). Default: auto-detected based on range." }))
+});
+const queryConnectorTool = {
+	name: "queryConnector",
+	label: "Query Connector Data",
+	description: "Query imported data from any connector source (calendar, gmail, mac, etc.). Call WITHOUT 'source' to discover available connectors. Call WITH 'source' to query entries sorted by date. Supports time range filtering and text search. Use this for ALL time-sensitive questions (schedules, recent emails, upcoming events).",
+	parameters: QueryConnectorParams,
+	execute: async (_toolCallId, params) => {
+		const connectorDir = path.join(getPaiHome(), "raw", "connector");
+		if (!params.source) {
+			let subdirs;
+			try {
+				subdirs = (await fs.readdir(connectorDir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+			} catch {
+				return {
+					content: [{
+						type: "text",
+						text: "No connector data found. Run 'pai import' to import data."
+					}],
+					details: { sources: [] }
+				};
+			}
+			if (subdirs.length === 0) return {
+				content: [{
+					type: "text",
+					text: "No connector sources found. Run 'pai import --source <source>' to import data."
+				}],
+				details: { sources: [] }
+			};
+			const summaries = [];
+			for (const sub of subdirs) {
+				const subPath = path.join(connectorDir, sub);
+				try {
+					const files = (await fs.readdir(subPath)).filter((f) => f.endsWith(".md"));
+					let sample = "";
+					if (files.length > 0) try {
+						const latest = path.join(subPath, files[files.length - 1]);
+						const { content } = matter(await fs.readFile(latest, "utf-8"));
+						sample = extractTitle(content);
+					} catch {}
+					summaries.push({
+						name: sub,
+						files: files.length,
+						sample
+					});
+				} catch {
+					summaries.push({
+						name: sub,
+						files: 0,
+						sample: ""
+					});
+				}
+			}
+			return {
+				content: [{
+					type: "text",
+					text: `Available connector sources:\n${summaries.map((s) => `- **${s.name}**: ${s.files} files${s.sample ? ` (latest: "${s.sample}")` : ""}`).join("\n")}\n\nCall queryConnector with source="<name>" to query a specific source.`
+				}],
+				details: { sources: summaries.map((s) => ({
+					name: s.name,
+					files: s.files
+				})) }
+			};
+		}
+		const entries = await readConnectorDir(params.source);
+		if (entries.length === 0) return {
+			content: [{
+				type: "text",
+				text: `No data found for source "${params.source}". Check available sources by calling queryConnector without a source parameter.`
+			}],
+			details: {
+				results: [],
+				totalImported: 0
+			}
+		};
+		const now = /* @__PURE__ */ new Date();
+		const range = params.range ?? "all";
+		const limit = params.limit ?? 10;
+		const queryLower = params.query?.toLowerCase();
+		const filtered = entries.filter((e) => {
+			if (queryLower) {
+				if (!(e.title + " " + Object.values(e.fields).join(" ")).toLowerCase().includes(queryLower)) return false;
+			}
+			if (range !== "all") {
+				if (!e.date) return false;
+				const t = e.date.getTime();
+				const nowMs = now.getTime();
+				const DAY = 1440 * 60 * 1e3;
+				switch (range) {
+					case "upcoming":
+						if (t < nowMs) return false;
+						break;
+					case "today": {
+						const startOfDay = new Date(now);
+						startOfDay.setHours(0, 0, 0, 0);
+						const endOfDay = new Date(now);
+						endOfDay.setHours(23, 59, 59, 999);
+						if (t < startOfDay.getTime() || t > endOfDay.getTime()) return false;
+						break;
+					}
+					case "this_week":
+						if (t < nowMs - 7 * DAY || t > nowMs + 7 * DAY) return false;
+						break;
+					case "past_week":
+						if (t < nowMs - 7 * DAY || t > nowMs) return false;
+						break;
+					case "past_month":
+						if (t < nowMs - 30 * DAY || t > nowMs) return false;
+						break;
+				}
+			}
+			return true;
+		});
+		const sortDir = params.sort ?? (range === "upcoming" || range === "today" || range === "this_week" ? "asc" : "desc");
+		filtered.sort((a, b) => {
+			const ta = a.date?.getTime() ?? 0;
+			const tb = b.date?.getTime() ?? 0;
+			return sortDir === "asc" ? ta - tb : tb - ta;
+		});
+		const limited = filtered.slice(0, limit);
+		if (limited.length === 0) return {
+			content: [{
+				type: "text",
+				text: `No entries matched for source "${params.source}", range "${range}". Total imported: ${entries.length}`
+			}],
+			details: {
+				results: [],
+				totalImported: entries.length
+			}
+		};
+		const text = limited.map((e, i) => {
+			const parts = [`${i + 1}. **${e.title}**`];
+			for (const [key, val] of Object.entries(e.fields)) parts.push(`   ${key}: ${val}`);
+			if (e.date && !e.fields["Time"] && !e.fields["Date"]) parts.push(`   Date: ${e.date.toISOString()}`);
+			return parts.join("\n");
+		}).join("\n\n");
+		return {
+			content: [{
+				type: "text",
+				text: `Found ${filtered.length} entries (showing ${limited.length}) from "${params.source}":\n\n${text}`
+			}],
+			details: {
+				results: limited.map((e) => ({
+					file: e.file,
+					title: e.title,
+					date: e.date?.toISOString() ?? null,
+					fields: e.fields
+				})),
+				totalMatched: filtered.length,
+				totalImported: entries.length
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/ask/tools-pai.ts
+const SearchParams = Type.Object({
+	query: Type.String({ description: "Search query" }),
+	limit: Type.Optional(Type.Number({ description: "Max results (default 5)" }))
+});
+const searchVaultTool = {
+	name: "searchVault",
+	label: "Search Vault",
+	description: "Search user's distilled knowledge vault (experiences, preferences, lessons). Hybrid search: BM25 + vector + reranking. Ranked by RELEVANCE, not recency. For time-sensitive queries, supplement with bash/grep on raw files.",
+	parameters: SearchParams,
+	execute: async (_toolCallId, params) => {
+		if (!await isQmdAvailable()) return {
+			content: [{
+				type: "text",
+				text: "Error: QMD not installed."
+			}],
+			details: { error: "QMD not installed" }
+		};
+		try {
+			const results = await search(params.query, "vault", params.limit ?? 5, "query");
+			return {
+				content: [{
+					type: "text",
+					text: results.map((r) => `## ${r.title ?? "Untitled"}\nFile: ${r.file}\n${r.snippet ?? ""}`).join("\n\n") || "No results found."
+				}],
+				details: { results: results.map((r) => ({
+					file: r.file,
+					title: r.title,
+					snippet: r.snippet
+				})) }
+			};
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${msg}`
+				}],
+				details: { error: msg }
+			};
+		}
+	}
+};
+const searchRawTool = {
+	name: "searchRaw",
+	label: "Search Raw",
+	description: "Search user's original raw data (for tracing back to sources). Raw files have timestamps in frontmatter. Ranked by RELEVANCE, not recency.",
+	parameters: SearchParams,
+	execute: async (_toolCallId, params) => {
+		if (!await isQmdAvailable()) return {
+			content: [{
+				type: "text",
+				text: "Error: QMD not installed."
+			}],
+			details: { error: "QMD not installed" }
+		};
+		try {
+			const results = await search(params.query, "raw", params.limit ?? 5, "query");
+			return {
+				content: [{
+					type: "text",
+					text: results.map((r) => `## ${r.title ?? "Untitled"}\nFile: ${r.file}\n${r.snippet ?? ""}`).join("\n\n") || "No results found."
+				}],
+				details: { results: results.map((r) => ({
+					file: r.file,
+					title: r.title,
+					snippet: r.snippet
+				})) }
+			};
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${msg}`
+				}],
+				details: { error: msg }
+			};
+		}
+	}
+};
+const EmptyParams = Type.Object({});
+const readProfileTool = {
+	name: "readProfile",
+	label: "Read Profile",
+	description: "Read the user's compiled profile (identity, environment, tools, projects, habits). This is the fastest way to understand who the user is.",
+	parameters: EmptyParams,
+	execute: async () => {
+		const profile = await loadProfile();
+		return {
+			content: [{
+				type: "text",
+				text: profile ?? "No profile found. Run 'pai init' first."
+			}],
+			details: { hasProfile: !!profile }
+		};
+	}
+};
+
+//#endregion
+//#region src/ask/tools.ts
+/** Create the full ask agent tool set: pai knowledge tools + filesystem meta tools */
+function createAskTools(opts) {
+	const tools = [
+		searchVaultTool,
+		searchRawTool,
+		readProfileTool,
+		queryConnectorTool,
+		readFileTool,
+		grepTool,
+		globTool,
+		lsTool
+	];
+	if (opts?.allowBash) tools.push(bashTool);
+	return tools;
+}
+
+//#endregion
+//#region src/ask/agent.ts
+/**
+* Resolve a model from pai config.
+* - If custom baseUrl is set, construct an openai-completions Model for compatibility.
+* - Otherwise try the pi-ai registry first, then fallback to a manual Model.
+*/
+function resolveModel(modelId, baseUrl) {
+	const trimmedBase = baseUrl?.trim() || void 0;
+	if (trimmedBase) return {
+		id: modelId,
+		name: modelId,
+		api: "openai-completions",
+		provider: "openai",
+		baseUrl: trimmedBase,
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		contextWindow: 128e3,
+		maxTokens: 16384
+	};
+	const registered = getModel("openai", modelId);
+	if (registered) return registered;
+	return {
+		id: modelId,
+		name: modelId,
+		api: "openai-completions",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		contextWindow: 128e3,
+		maxTokens: 16384
+	};
+}
+/** Build full system prompt with user preferences injected */
+async function getSystemPrompt() {
+	const base = buildAskSystemPrompt();
+	try {
+		const prefs = await fs.readFile(getPreferencesPath(), "utf-8");
+		if (prefs.trim()) return `${base}\n\n---USER PREFERENCES (always respect these)---\n${prefs}`;
+	} catch {}
+	return base;
+}
+/** Knowledge tool names whose results count as citable sources */
+const KNOWLEDGE_TOOLS = new Set([
+	"searchVault",
+	"searchRaw",
+	"readProfile",
+	"readFile",
+	"queryConnector"
+]);
+/** Extract source file paths from pai knowledge tool results only (skip glob/ls/bash noise) */
+function extractSources(messages) {
+	const sources = /* @__PURE__ */ new Set();
+	for (const msg of messages) {
+		if (msg.role !== "toolResult") continue;
+		if (!KNOWLEDGE_TOOLS.has(msg.toolName)) continue;
+		const details = msg.details;
+		if (!details) continue;
+		if (Array.isArray(details.results)) {
+			for (const r of details.results) if (typeof r.file === "string" && r.file) sources.add(r.file);
+		}
+		if (typeof details.path === "string" && details.path) sources.add(details.path);
+	}
+	return [...sources];
+}
+/** Aggregate token usage from all assistant messages */
+function aggregateUsage(messages) {
+	const usage = {
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		cacheWriteTokens: 0,
+		totalTokens: 0,
+		cost: 0
+	};
+	for (const msg of messages) if (msg.role === "assistant" && msg.usage) {
+		const u = msg.usage;
+		usage.inputTokens += u.input ?? 0;
+		usage.outputTokens += u.output ?? 0;
+		usage.cacheReadTokens += u.cacheRead ?? 0;
+		usage.cacheWriteTokens += u.cacheWrite ?? 0;
+		usage.totalTokens += u.totalTokens ?? 0;
+		if (u.cost) usage.cost += u.cost.total ?? 0;
+	}
+	return usage;
+}
+/** Extract text answer from the last assistant message */
+function extractAnswer(messages) {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i];
+		if (msg.role === "assistant" && Array.isArray(msg.content)) {
+			const texts = [];
+			for (const c of msg.content) if (c.type === "text") texts.push(c.text);
+			if (texts.length > 0) return texts.join("");
+		}
+	}
+	return "";
+}
+async function runAskAgent(question, opts) {
+	const config = await loadConfig();
+	const apiKey = process.env[config.llm.apiKeyEnv];
+	if (!apiKey) throw new Error(`Missing API key: set ${config.llm.apiKeyEnv} environment variable`);
+	const modelId = opts?.model ?? config.llm.cheapModel;
+	const model = resolveModel(modelId, config.llm.baseUrl);
+	const agent = new Agent({
+		initialState: {
+			systemPrompt: await getSystemPrompt(),
+			model,
+			tools: createAskTools({ allowBash: opts?.allowBash })
+		},
+		getApiKey: async () => apiKey
+	});
+	const maxSteps = opts?.maxSteps ?? 10;
+	let turnCount = 0;
+	let toolCallCount = 0;
+	const unsubscribe = agent.subscribe((event) => {
+		if (event.type === "turn_end") {
+			turnCount++;
+			if (turnCount >= maxSteps) agent.abort();
+		}
+		if (event.type === "tool_execution_start") toolCallCount++;
+		opts?.onEvent?.(event);
+	});
+	const startTime = performance.now();
+	try {
+		await agent.prompt(question);
+	} finally {
+		unsubscribe();
+	}
+	const durationMs = Math.round(performance.now() - startTime);
+	const messages = agent.state.messages;
+	const answer = extractAnswer(messages);
+	const sources = extractSources(messages);
+	const usage = aggregateUsage(messages);
+	let actualModel = modelId;
+	let stopReason = "unknown";
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const m = messages[i];
+		if (m.role === "assistant") {
+			if (m.model) actualModel = m.model;
+			if (m.stopReason) stopReason = m.stopReason;
+			break;
+		}
+	}
+	return {
+		answer,
+		sources,
+		steps: turnCount,
+		durationMs,
+		usage,
+		model: actualModel,
+		toolCalls: toolCallCount,
+		stopReason
+	};
+}
+
+//#endregion
+//#region src/cli/register.ask.ts
+function registerAskCommand(program) {
+	program.command("ask <question>").description("Ask a question about the user; agent uses tools (search, read, bash) to find the answer").option("--json", "Output as JSON (answer, sources, steps)").option("--steps <n>", "Max tool-call steps", "10").option("--model <name>", "Override LLM model").option("--verbose", "Show each tool step").option("--unsafe-bash", "Enable bash tool (risk: model can execute arbitrary commands)").action(async (question, opts) => {
+		if (!question?.trim()) {
+			error("Usage: pai ask <question>");
+			process.exit(1);
+		}
+		try {
+			const onEvent = opts.verbose ? (event) => {
+				if (event.type === "tool_execution_start") log(`[tool] ${event.toolName}(${JSON.stringify(event.args ?? {}).slice(0, 80)}...)`);
+				if (event.type === "tool_execution_end") {
+					const status = event.isError ? "✗" : "✓";
+					log(`[tool] ${event.toolName} ${status}`);
+				}
+			} : void 0;
+			const result = await runAskAgent(question.trim(), {
+				maxSteps: parseInt(String(opts.steps), 10) || 10,
+				model: opts.model,
+				allowBash: opts.unsafeBash,
+				onEvent
+			});
+			if (opts.json) process.stdout.write(JSON.stringify({
+				answer: result.answer,
+				sources: result.sources,
+				model: result.model,
+				steps: result.steps,
+				toolCalls: result.toolCalls,
+				stopReason: result.stopReason,
+				durationMs: result.durationMs,
+				usage: result.usage
+			}, null, 2) + "\n");
+			else {
+				process.stdout.write(result.answer + "\n");
+				if (result.sources.length > 0) process.stdout.write("\n_Sources: " + result.sources.join(", ") + "_\n");
+				const { usage, durationMs, steps, model, toolCalls } = result;
+				const secs = (durationMs / 1e3).toFixed(1);
+				const tps = durationMs > 0 ? (usage.outputTokens / durationMs * 1e3).toFixed(1) : "–";
+				const costStr = usage.cost > 0 ? `$${usage.cost.toFixed(4)}` : "";
+				const cacheStr = usage.cacheReadTokens > 0 ? ` · cache: ${usage.cacheReadTokens} read` : "";
+				const parts = [
+					model,
+					`${secs}s`,
+					`${steps} steps · ${toolCalls} tool calls`,
+					`${usage.totalTokens} tokens (in: ${usage.inputTokens}, out: ${usage.outputTokens})`,
+					`${tps} tok/s`
+				];
+				if (cacheStr) parts.push(cacheStr.replace(" · ", ""));
+				if (costStr) parts.push(costStr);
+				process.stdout.write(`\n---\n${parts.join(" · ")}\n`);
+			}
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			error(`Ask failed: ${msg}`);
+			process.exit(1);
+		}
+	});
+}
+
+//#endregion
+//#region src/cli/register.context.ts
+function registerContextCommand(program) {
+	program.command("context").description("Output personal context for AI agents (identity + task-relevant memories)").option("--task <description>", "Current task — searches vault for relevant memories").option("--profile <name>", "Profile to use", "full-context").option("--json", "Output as JSON for machine consumption").action(async (opts) => {
+		try {
+			const profileName = opts.profile ?? "full-context";
+			const profileContent = await readProfile(profileName);
+			if (!profileContent) {
+				error(`Profile "${profileName}" not found. Run "pai generate" first.`);
+				process.exit(1);
+			}
+			const identity = extractCompactIdentity(profileContent);
+			let memories = [];
+			if (opts.task) {
+				if (await isQmdAvailable()) memories = await search(opts.task, "vault", 5, "query");
+			}
+			if (opts.json) {
+				const output = {
+					profile: profileName,
+					identity,
+					memories: memories.map((m) => ({
+						file: m.file,
+						title: m.title ?? null,
+						snippet: m.snippet,
+						score: m.score ?? null
+					}))
+				};
+				process.stdout.write(JSON.stringify(output, null, 2) + "\n");
+			} else {
+				process.stdout.write(identity + "\n");
+				if (memories.length > 0) {
+					process.stdout.write("\n## Relevant Memories\n\n");
+					for (const m of memories) {
+						const title = m.title ?? path.basename(m.file);
+						const snippet = m.snippet.slice(0, 160).replace(/\n/g, " ");
+						process.stdout.write(`- **${title}**: ${snippet}\n`);
+						process.stdout.write(`  _source: ${m.file}_\n\n`);
+					}
+				} else if (opts.task) process.stdout.write("\n_No matching memories found for this task._\n");
+			}
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			error(`Context failed: ${msg}`);
+			process.exit(1);
+		}
+	});
+}
+/** Read a profile file from ~/.pai/skills/profiles/ */
+async function readProfile(name) {
+	const profilePath = path.join(getSkillsDir(), `${name}.md`);
+	try {
+		return await fs.readFile(profilePath, "utf-8");
+	} catch {
+		return null;
+	}
+}
+/**
+* Extract compact identity from a full profile.
+* Keeps: ## Who I Am, ## Preferences, ## Current Work sections
+* Drops: ## Hard-won Lessons (those come from search results instead)
+*/
+function extractCompactIdentity(profile) {
+	const lines = profile.split("\n");
+	const sections = [];
+	let current = null;
+	for (const line of lines) if (line.startsWith("## ")) {
+		if (current) sections.push(current);
+		current = {
+			heading: line,
+			lines: []
+		};
+	} else if (line.startsWith("# ") && !line.startsWith("## ")) {
+		if (current) sections.push(current);
+		current = {
+			heading: line,
+			lines: []
+		};
+	} else if (current) current.lines.push(line);
+	if (current) sections.push(current);
+	return sections.filter((s) => !s.heading.toLowerCase().includes("hard-won lessons")).map((s) => [s.heading, ...s.lines].join("\n")).join("\n");
+}
+
+//#endregion
+//#region src/cli/register.distribute.ts
+const MANAGED_TAG = "<!-- managed by pai distribute — do not edit manually -->";
+function registerDistributeCommand(program) {
+	program.command("distribute").description("Deploy personal profile + agent instructions to Cursor rules and other agent configs").option("--target <name>", "Target platform (cursor). Default: all").option("--profile <name>", "Legacy: use a generated SKILL.md profile instead of profile.md").action(async (opts) => {
+		try {
+			let profileContent = null;
+			let source = "";
+			if (opts.profile) {
+				profileContent = await readLegacyProfile(opts.profile);
+				source = `skills/profiles/${opts.profile}.md`;
+			} else {
+				profileContent = await loadProfile();
+				source = "profile.md";
+				if (!profileContent) {
+					profileContent = await readLegacyProfile("full-context");
+					source = "skills/profiles/full-context.md";
+				}
+			}
+			if (!profileContent) {
+				error("No profile found. Run \"pai init\" or \"pai profile --rebuild\" first.");
+				process.exit(1);
+			}
+			info(`Source: ${source}`);
+			const ruleContent = buildAgentRule(profileContent);
+			const targets = opts.target ? [opts.target] : ["cursor"];
+			const results = [];
+			for (const target of targets) switch (target) {
+				case "cursor": {
+					const wrote = await distributeToCursor(ruleContent);
+					if (wrote) results.push(wrote);
+					break;
+				}
+				default: warn(`Unknown target: ${target}`);
+			}
+			if (results.length > 0) {
+				success(`Distributed to ${results.length} target(s):`);
+				for (const r of results) log(`  → ${r}`);
+			} else warn("No targets were written.");
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			error(`Distribute failed: ${msg}`);
+			process.exit(1);
+		}
+	});
+}
+/** Read a legacy SKILL.md profile file from skills/profiles/ */
+async function readLegacyProfile(name) {
+	const profilePath = path.join(getSkillsDir(), `${name}.md`);
+	try {
+		return await fs.readFile(profilePath, "utf-8");
+	} catch {
+		return null;
+	}
+}
+/**
+* Build the full agent rule file content.
+* Combines: user profile (who you are) + skill instructions (how to use pai).
+*/
+function buildAgentRule(profileContent) {
+	return `${MANAGED_TAG}
+# Personal AI Context
+
+${profileContent.trim()}
+
+---
+
+## Agent Skill — pai CLI
+
+You have access to the user's personal knowledge base via \`pai\` CLI commands.
+Use these to retrieve context, search knowledge, and remember new lessons.
+
+### Retrieve task-relevant memories (RECOMMENDED before starting work)
+
+\`\`\`bash
+pai context --task "<brief description of current task>"
+\`\`\`
+
+This returns the user's identity + vault memories relevant to the task.
+
+### Search specific knowledge
+
+\`\`\`bash
+pai search "<query>"              # hybrid search (best quality, ~5s)
+pai search "<query>" --fast       # keyword search (instant)
+pai search "<query>" --json       # machine-readable output
+\`\`\`
+
+### Remember new lessons
+
+When you discover something the user should remember (a lesson, preference, or tip):
+
+\`\`\`bash
+pai add "<lesson or experience>"
+\`\`\`
+
+### Rebuild profile after changes
+
+\`\`\`bash
+pai profile --rebuild             # re-scan local machine and recompile
+pai distribute                    # redeploy updated profile
+\`\`\`
+`;
+}
+/** Deploy to ~/.cursor/rules/pai-context.mdc */
+async function distributeToCursor(content) {
+	const cursorRulesDir = path.join(os.homedir(), ".cursor", "rules");
+	const targetPath = path.join(cursorRulesDir, "pai-context.mdc");
+	try {
+		await fs.mkdir(cursorRulesDir, { recursive: true });
+		await fs.writeFile(targetPath, content, "utf-8");
+		return targetPath;
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		warn(`Failed to write Cursor rule: ${msg}`);
+		return null;
+	}
+}
+
+//#endregion
+//#region src/cli/register.profile.ts
+function registerProfileCommand(program) {
+	program.command("profile").description("View, rebuild, or export your personal profile").option("--rebuild", "Re-scan local machine and rebuild profile").option("--export", "Output profile in copy-paste friendly format").option("--json", "Output profile metadata as JSON").action(async (opts) => {
+		try {
+			if (opts.rebuild) {
+				const { profilePath, results } = await rebuildProfile({ verbose: true });
+				success(`Profile rebuilt → ${profilePath}`);
+				info(`Compiled from ${results.length} data sources.`);
+				return;
+			}
+			const profile = await loadProfile();
+			if (!profile) {
+				error("No profile found. Run \"pai init\" or \"pai profile --rebuild\" first.");
+				process.exit(1);
+			}
+			if (opts.json) {
+				const lines = profile.split("\n");
+				const sections = [];
+				for (const line of lines) if (line.startsWith("## ")) sections.push({
+					heading: line.replace("## ", ""),
+					lineCount: 0
+				});
+				else if (sections.length > 0) sections[sections.length - 1].lineCount++;
+				const meta = {
+					path: getProfilePath(),
+					totalLines: lines.length,
+					sections
+				};
+				process.stdout.write(JSON.stringify(meta, null, 2) + "\n");
+				return;
+			}
+			if (opts.export) {
+				process.stdout.write(profile);
+				return;
+			}
+			log("");
+			info(`Profile: ${getProfilePath()}`);
+			log("");
+			process.stdout.write(profile);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			error(`Profile command failed: ${msg}`);
+			process.exit(1);
+		}
+	});
+}
+
+//#endregion
+//#region src/cli/command-registry.ts
+const commandRegistry = [
+	{
+		id: "auth",
+		register: (p) => registerAuthCommand(p)
+	},
+	{
+		id: "init",
+		register: (p) => registerInitCommand(p)
+	},
+	{
+		id: "reset",
+		register: (p) => registerResetCommand(p)
+	},
+	{
+		id: "add",
+		register: (p) => registerAddCommand(p)
+	},
+	{
+		id: "profile",
+		register: (p) => registerProfileCommand(p)
+	},
+	{
+		id: "distill",
+		register: (p) => registerDistillCommand(p)
+	},
+	{
+		id: "generate",
+		register: (p) => registerGenerateCommand(p)
+	},
+	{
+		id: "search",
+		register: (p) => registerSearchCommand(p)
+	},
+	{
+		id: "index",
+		register: (p) => registerIndexCommand(p)
+	},
+	{
+		id: "import",
+		register: (p) => registerImportCommand(p)
+	},
+	{
+		id: "status",
+		register: (p) => registerStatusCommand(p)
+	},
+	{
+		id: "context",
+		register: (p) => registerContextCommand(p)
+	},
+	{
+		id: "ask",
+		register: (p) => registerAskCommand(p)
+	},
+	{
+		id: "distribute",
+		register: (p) => registerDistributeCommand(p)
+	}
+];
+function registerAllCommands(program) {
+	for (const entry of commandRegistry) entry.register(program);
+}
+
+//#endregion
+//#region src/cli/build-program.ts
+function buildProgram() {
+	const program = new Command().name("pai").description("Personal AI Data Wallet — local-first experience manager").version("0.1.0");
+	registerAllCommands(program);
+	return program;
+}
+
+//#endregion
+//#region src/entry.ts
+const program = buildProgram();
+process.on("uncaughtException", (error) => {
+	console.error("[pai] Uncaught exception:", error.message);
+	process.exit(1);
+});
+program.parseAsync(process.argv).catch((err) => {
+	console.error("[pai] Error:", err.message);
+	process.exit(1);
+});
+
+//#endregion
+export { info as a, warn as c, bold as i, addConnectorEntry as n, log as o, googleOAuth as r, spinner as s, ALL_COLLECTORS as t };
+//# sourceMappingURL=entry.mjs.map