@madh-io/alfred-ai 0.5.0 → 0.7.0

package/bundle/index.js

@@ -11,7 +11,7 @@ var __export = (target, all) => {
 
 // ../config/dist/schema.js
 import { z } from "zod";
-var TelegramConfigSchema, DiscordConfigSchema, WhatsAppConfigSchema, MatrixConfigSchema, SignalConfigSchema, StorageConfigSchema, LoggerConfigSchema, SecurityConfigSchema, LLMProviderConfigSchema, SearchConfigSchema, EmailConfigSchema, AlfredConfigSchema;
+var TelegramConfigSchema, DiscordConfigSchema, WhatsAppConfigSchema, MatrixConfigSchema, SignalConfigSchema, StorageConfigSchema, LoggerConfigSchema, SecurityConfigSchema, LLMProviderConfigSchema, SearchConfigSchema, EmailConfigSchema, SpeechConfigSchema, CalDAVConfigSchema, GoogleCalendarConfigSchema, MicrosoftCalendarConfigSchema, CalendarConfigSchema, AlfredConfigSchema;
 var init_schema = __esm({
   "../config/dist/schema.js"() {
     "use strict";
@@ -80,6 +80,33 @@ var init_schema = __esm({
         pass: z.string()
       })
     });
+    SpeechConfigSchema = z.object({
+      provider: z.enum(["openai", "groq"]),
+      apiKey: z.string(),
+      baseUrl: z.string().optional()
+    });
+    CalDAVConfigSchema = z.object({
+      serverUrl: z.string(),
+      username: z.string(),
+      password: z.string()
+    });
+    GoogleCalendarConfigSchema = z.object({
+      clientId: z.string(),
+      clientSecret: z.string(),
+      refreshToken: z.string()
+    });
+    MicrosoftCalendarConfigSchema = z.object({
+      clientId: z.string(),
+      clientSecret: z.string(),
+      tenantId: z.string(),
+      refreshToken: z.string()
+    });
+    CalendarConfigSchema = z.object({
+      provider: z.enum(["caldav", "google", "microsoft"]),
+      caldav: CalDAVConfigSchema.optional(),
+      google: GoogleCalendarConfigSchema.optional(),
+      microsoft: MicrosoftCalendarConfigSchema.optional()
+    });
     AlfredConfigSchema = z.object({
       name: z.string(),
       telegram: TelegramConfigSchema,
@@ -92,7 +119,9 @@ var init_schema = __esm({
       logger: LoggerConfigSchema,
       security: SecurityConfigSchema,
       search: SearchConfigSchema.optional(),
-      email: EmailConfigSchema.optional()
+      email: EmailConfigSchema.optional(),
+      speech: SpeechConfigSchema.optional(),
+      calendar: CalendarConfigSchema.optional()
     });
   }
 });
@@ -212,7 +241,21 @@ var init_loader = __esm({
       ALFRED_SEARCH_API_KEY: ["search", "apiKey"],
       ALFRED_SEARCH_BASE_URL: ["search", "baseUrl"],
       ALFRED_EMAIL_USER: ["email", "auth", "user"],
-      ALFRED_EMAIL_PASS: ["email", "auth", "pass"]
+      ALFRED_EMAIL_PASS: ["email", "auth", "pass"],
+      ALFRED_SPEECH_PROVIDER: ["speech", "provider"],
+      ALFRED_SPEECH_API_KEY: ["speech", "apiKey"],
+      ALFRED_SPEECH_BASE_URL: ["speech", "baseUrl"],
+      ALFRED_CALENDAR_PROVIDER: ["calendar", "provider"],
+      ALFRED_CALDAV_SERVER_URL: ["calendar", "caldav", "serverUrl"],
+      ALFRED_CALDAV_USERNAME: ["calendar", "caldav", "username"],
+      ALFRED_CALDAV_PASSWORD: ["calendar", "caldav", "password"],
+      ALFRED_GOOGLE_CALENDAR_CLIENT_ID: ["calendar", "google", "clientId"],
+      ALFRED_GOOGLE_CALENDAR_CLIENT_SECRET: ["calendar", "google", "clientSecret"],
+      ALFRED_GOOGLE_CALENDAR_REFRESH_TOKEN: ["calendar", "google", "refreshToken"],
+      ALFRED_MICROSOFT_CALENDAR_CLIENT_ID: ["calendar", "microsoft", "clientId"],
+      ALFRED_MICROSOFT_CALENDAR_CLIENT_SECRET: ["calendar", "microsoft", "clientSecret"],
+      ALFRED_MICROSOFT_CALENDAR_TENANT_ID: ["calendar", "microsoft", "tenantId"],
+      ALFRED_MICROSOFT_CALENDAR_REFRESH_TOKEN: ["calendar", "microsoft", "refreshToken"]
     };
     ConfigLoader = class {
       loadConfig(configPath) {
@@ -422,6 +465,43 @@ var init_migrations = __esm({
           ON notes(user_id, updated_at DESC);
       `);
         }
+      },
+      {
+        version: 5,
+        description: "Add user profile fields (timezone, language, bio, preferences)",
+        up(db) {
+          db.exec(`
+        ALTER TABLE users ADD COLUMN timezone TEXT;
+        ALTER TABLE users ADD COLUMN language TEXT;
+        ALTER TABLE users ADD COLUMN bio TEXT;
+        ALTER TABLE users ADD COLUMN preferences TEXT;
+      `);
+        }
+      },
+      {
+        version: 6,
+        description: "Add embeddings table for semantic search",
+        up(db) {
+          db.exec(`
+        CREATE TABLE IF NOT EXISTS embeddings (
+          id TEXT PRIMARY KEY,
+          user_id TEXT NOT NULL,
+          source_type TEXT NOT NULL,
+          source_id TEXT NOT NULL,
+          content TEXT NOT NULL,
+          embedding BLOB NOT NULL,
+          model TEXT NOT NULL,
+          dimensions INTEGER NOT NULL,
+          created_at TEXT NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_embeddings_user
+          ON embeddings(user_id);
+
+        CREATE INDEX IF NOT EXISTS idx_embeddings_source
+          ON embeddings(source_type, source_id);
+      `);
+        }
       }
     ];
   }
@@ -652,6 +732,44 @@ var init_user_repository = __esm({
         values.push(id);
         this.db.prepare(`UPDATE users SET ${fields.join(", ")} WHERE id = ?`).run(...values);
       }
+      updateProfile(id, data) {
+        const fields = [];
+        const values = [];
+        if (data.timezone !== void 0) {
+          fields.push("timezone = ?");
+          values.push(data.timezone ?? null);
+        }
+        if (data.language !== void 0) {
+          fields.push("language = ?");
+          values.push(data.language ?? null);
+        }
+        if (data.bio !== void 0) {
+          fields.push("bio = ?");
+          values.push(data.bio ?? null);
+        }
+        if (data.preferences !== void 0) {
+          fields.push("preferences = ?");
+          values.push(data.preferences ? JSON.stringify(data.preferences) : null);
+        }
+        if (fields.length === 0)
+          return;
+        fields.push("updated_at = ?");
+        values.push((/* @__PURE__ */ new Date()).toISOString());
+        values.push(id);
+        this.db.prepare(`UPDATE users SET ${fields.join(", ")} WHERE id = ?`).run(...values);
+      }
+      getProfile(id) {
+        const row = this.db.prepare("SELECT display_name, timezone, language, bio, preferences FROM users WHERE id = ?").get(id);
+        if (!row)
+          return void 0;
+        return {
+          displayName: row.display_name ?? void 0,
+          timezone: row.timezone ?? void 0,
+          language: row.language ?? void 0,
+          bio: row.bio ?? void 0,
+          preferences: row.preferences ? JSON.parse(row.preferences) : void 0
+        };
+      }
       mapRow(row) {
         return {
           id: row.id,
@@ -659,6 +777,10 @@ var init_user_repository = __esm({
           platformUserId: row.platform_user_id,
           username: row.username ?? void 0,
           displayName: row.display_name ?? void 0,
+          timezone: row.timezone ?? void 0,
+          language: row.language ?? void 0,
+          bio: row.bio ?? void 0,
+          preferences: row.preferences ? JSON.parse(row.preferences) : void 0,
           createdAt: row.created_at,
           updatedAt: row.updated_at
         };
@@ -927,6 +1049,69 @@ var init_note_repository = __esm({
   }
 });
 
+// ../storage/dist/repositories/embedding-repository.js
+import { randomUUID as randomUUID4 } from "node:crypto";
+var EmbeddingRepository;
+var init_embedding_repository = __esm({
+  "../storage/dist/repositories/embedding-repository.js"() {
+    "use strict";
+    EmbeddingRepository = class {
+      db;
+      constructor(db) {
+        this.db = db;
+      }
+      store(input2) {
+        const id = randomUUID4();
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        this.db.prepare("DELETE FROM embeddings WHERE user_id = ? AND source_type = ? AND source_id = ?").run(input2.userId, input2.sourceType, input2.sourceId);
+        const buffer = Buffer.from(new Float32Array(input2.embedding).buffer);
+        this.db.prepare("INSERT INTO embeddings (id, user_id, source_type, source_id, content, embedding, model, dimensions, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)").run(id, input2.userId, input2.sourceType, input2.sourceId, input2.content, buffer, input2.model, input2.dimensions, now);
+        return {
+          id,
+          userId: input2.userId,
+          sourceType: input2.sourceType,
+          sourceId: input2.sourceId,
+          content: input2.content,
+          embedding: input2.embedding,
+          model: input2.model,
+          dimensions: input2.dimensions,
+          createdAt: now
+        };
+      }
+      findByUser(userId) {
+        const rows = this.db.prepare("SELECT * FROM embeddings WHERE user_id = ? ORDER BY created_at DESC").all(userId);
+        return rows.map((row) => this.mapRow(row));
+      }
+      findBySource(sourceType, sourceId) {
+        const row = this.db.prepare("SELECT * FROM embeddings WHERE source_type = ? AND source_id = ?").get(sourceType, sourceId);
+        if (!row)
+          return void 0;
+        return this.mapRow(row);
+      }
+      delete(sourceType, sourceId) {
+        const result = this.db.prepare("DELETE FROM embeddings WHERE source_type = ? AND source_id = ?").run(sourceType, sourceId);
+        return result.changes > 0;
+      }
+      mapRow(row) {
+        const blob = row.embedding;
+        const float32 = new Float32Array(blob.buffer, blob.byteOffset, blob.byteLength / 4);
+        const embedding = Array.from(float32);
+        return {
+          id: row.id,
+          userId: row.user_id,
+          sourceType: row.source_type,
+          sourceId: row.source_id,
+          content: row.content,
+          embedding,
+          model: row.model,
+          dimensions: row.dimensions,
+          createdAt: row.created_at
+        };
+      }
+    };
+  }
+});
+
 // ../storage/dist/index.js
 var init_dist3 = __esm({
   "../storage/dist/index.js"() {
@@ -940,6 +1125,7 @@ var init_dist3 = __esm({
     init_migrations();
     init_reminder_repository();
     init_note_repository();
+    init_embedding_repository();
   }
 });
 
@@ -994,6 +1180,12 @@ var init_provider = __esm({
       getContextWindow() {
         return this.contextWindow;
       }
+      async embed(_text) {
+        return void 0;
+      }
+      supportsEmbeddings() {
+        return false;
+      }
     };
   }
 });
@@ -1082,6 +1274,15 @@ var init_anthropic = __esm({
             switch (block.type) {
               case "text":
                 return { type: "text", text: block.text };
+              case "image":
+                return {
+                  type: "image",
+                  source: {
+                    type: "base64",
+                    media_type: block.source.media_type,
+                    data: block.source.data
+                  }
+                };
               case "tool_use":
                 return {
                   type: "tool_use",
@@ -1260,6 +1461,25 @@ var init_openai = __esm({
       isAvailable() {
         return !!this.config.apiKey;
       }
+      async embed(text) {
+        try {
+          const response = await this.client.embeddings.create({
+            model: "text-embedding-3-small",
+            input: text
+          });
+          const data = response.data[0];
+          return {
+            embedding: data.embedding,
+            model: "text-embedding-3-small",
+            dimensions: data.embedding.length
+          };
+        } catch {
+          return void 0;
+        }
+      }
+      supportsEmbeddings() {
+        return true;
+      }
       mapMessages(messages, system) {
         const mapped = [];
         if (system) {
@@ -1278,6 +1498,14 @@ var init_openai = __esm({
               case "text":
                 textParts.push({ type: "text", text: block.text });
                 break;
+              case "image":
+                textParts.push({
+                  type: "image_url",
+                  image_url: {
+                    url: `data:${block.source.media_type};base64,${block.source.data}`
+                  }
+                });
+                break;
               case "tool_use":
                 toolUseParts.push({
                   id: block.id,
@@ -1382,6 +1610,9 @@ var init_openrouter = __esm({
       isAvailable() {
         return !!this.config.apiKey;
       }
+      supportsEmbeddings() {
+        return false;
+      }
     };
   }
 });
@@ -1608,6 +1839,34 @@ var init_ollama = __esm({
           return false;
         }
       }
+      async embed(text) {
+        try {
+          const res = await fetch(`${this.baseUrl}/api/embed`, {
+            method: "POST",
+            headers: this.getHeaders(),
+            body: JSON.stringify({
+              model: "nomic-embed-text",
+              input: text
+            })
+          });
+          if (!res.ok)
+            return void 0;
+          const data = await res.json();
+          if (!data.embeddings || data.embeddings.length === 0)
+            return void 0;
+          const embedding = data.embeddings[0];
+          return {
+            embedding,
+            model: "nomic-embed-text",
+            dimensions: embedding.length
+          };
+        } catch {
+          return void 0;
+        }
+      }
+      supportsEmbeddings() {
+        return true;
+      }
       buildOptions(request) {
         const options = {};
         const temperature = request.temperature ?? this.config.temperature;
@@ -1636,11 +1895,15 @@ var init_ollama = __esm({
       }
       mapContentBlocks(role, blocks) {
         const textParts = [];
+        const images = [];
         for (const block of blocks) {
           switch (block.type) {
             case "text":
               textParts.push(block.text);
               break;
+            case "image":
+              images.push(block.source.data);
+              break;
             case "tool_use":
               textParts.push(`[Tool call: ${block.name}(${JSON.stringify(block.input)})]`);
               break;
@@ -1649,7 +1912,11 @@ var init_ollama = __esm({
               break;
           }
         }
-        return { role, content: textParts.join("\n") };
+        const msg = { role, content: textParts.join("\n") };
+        if (images.length > 0) {
+          msg.images = images;
+        }
+        return msg;
       }
       mapTools(tools) {
         return tools.map((tool) => ({
@@ -1725,6 +1992,9 @@ function estimateMessageTokens(msg) {
       case "text":
         tokens += estimateTokens(block.text);
         break;
+      case "image":
+        tokens += 1e3;
+        break;
       case "tool_use":
         tokens += estimateTokens(block.name) + estimateTokens(JSON.stringify(block.input));
         break;
@@ -1740,7 +2010,8 @@ var init_prompt_builder = __esm({
   "../llm/dist/prompt-builder.js"() {
     "use strict";
     PromptBuilder = class {
-      buildSystemPrompt(memories, skills) {
+      buildSystemPrompt(context = {}) {
+        const { memories, skills, userProfile, todayEvents } = context;
         const os3 = process.platform === "darwin" ? "macOS" : process.platform === "win32" ? "Windows" : "Linux";
         const homeDir = process.env["HOME"] || process.env["USERPROFILE"] || "~";
         let prompt = `You are Alfred, a personal AI assistant. You run on ${os3} (home: ${homeDir}).
@@ -1771,6 +2042,48 @@ For complex tasks, work through multiple steps:
 `;
           }
         }
+        if (userProfile) {
+          prompt += "\n\n## User profile";
+          if (userProfile.displayName) {
+            prompt += `
+- Name: ${userProfile.displayName}`;
+          }
+          if (userProfile.timezone) {
+            const now = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-GB", {
+              timeZone: userProfile.timezone,
+              hour: "2-digit",
+              minute: "2-digit"
+            });
+            prompt += `
+- Timezone: ${userProfile.timezone} (Current local time: ${now})`;
+          }
+          if (userProfile.language) {
+            prompt += `
+- Language: ${userProfile.language}`;
+          }
+          if (userProfile.bio) {
+            prompt += `
+- Bio: ${userProfile.bio}`;
+          }
+        }
+        if (todayEvents && todayEvents.length > 0) {
+          prompt += "\n\n## Today's events";
+          for (const event of todayEvents) {
+            const startTime = event.allDay ? "All day" : event.start.toLocaleTimeString("en-GB", {
+              hour: "2-digit",
+              minute: "2-digit",
+              ...userProfile?.timezone ? { timeZone: userProfile.timezone } : {}
+            });
+            const endTime = event.allDay ? "" : `-${event.end.toLocaleTimeString("en-GB", {
+              hour: "2-digit",
+              minute: "2-digit",
+              ...userProfile?.timezone ? { timeZone: userProfile.timezone } : {}
+            })}`;
+            const location = event.location ? ` @ ${event.location}` : "";
+            prompt += `
+- ${startTime}${endTime}: ${event.title}${location}`;
+          }
+        }
         if (memories && memories.length > 0) {
           prompt += "\n\n## Memories about this user\n";
           for (const m of memories) {
@@ -2223,7 +2536,8 @@ var init_skill_sandbox = __esm({
       constructor(logger) {
         this.logger = logger;
       }
-      async execute(skill, input2, context, timeoutMs = DEFAULT_TIMEOUT_MS) {
+      async execute(skill, input2, context, timeoutMs) {
+        timeoutMs = timeoutMs ?? skill.metadata.timeoutMs ?? DEFAULT_TIMEOUT_MS;
         const { name } = skill.metadata;
         this.logger.info({ skill: name, input: input2 }, "Skill execution started");
         try {
@@ -3086,6 +3400,7 @@ var init_memory = __esm({
     init_skill();
     MemorySkill = class extends Skill {
       memoryRepo;
+      embeddingService;
       metadata = {
         name: "memory",
         description: "Store and retrieve persistent memories. Use this to remember user preferences, facts, and important information across conversations.",
@@ -3096,7 +3411,7 @@ var init_memory = __esm({
           properties: {
             action: {
               type: "string",
-              enum: ["save", "recall", "search", "list", "delete"],
+              enum: ["save", "recall", "search", "list", "delete", "semantic_search"],
               description: "The memory action to perform"
             },
             key: {
@@ -3119,9 +3434,10 @@ var init_memory = __esm({
           required: ["action"]
         }
       };
-      constructor(memoryRepo) {
+      constructor(memoryRepo, embeddingService) {
         super();
         this.memoryRepo = memoryRepo;
+        this.embeddingService = embeddingService;
       }
       async execute(input2, context) {
         const action = input2.action;
@@ -3136,10 +3452,12 @@ var init_memory = __esm({
             return this.listMemories(input2, context);
           case "delete":
             return this.deleteMemory(input2, context);
+          case "semantic_search":
+            return this.semanticSearchMemories(input2, context);
           default:
             return {
               success: false,
-              error: `Unknown action: "${String(action)}". Valid actions: save, recall, search, list, delete`
+              error: `Unknown action: "${String(action)}". Valid actions: save, recall, search, list, delete, semantic_search`
             };
         }
       }
@@ -3160,6 +3478,10 @@ var init_memory = __esm({
           };
         }
         const entry = this.memoryRepo.save(context.userId, key, value, category ?? "general");
+        if (this.embeddingService) {
+          this.embeddingService.embedAndStore(context.userId, `${key}: ${value}`, "memory", key).catch(() => {
+          });
+        }
         return {
           success: true,
           data: entry,
@@ -3230,6 +3552,25 @@ ${entries.map((e) => `- [${e.category}] ${e.key}: "${e.value}"`).join("\n")}`
           display: deleted ? `Memory "${key}" deleted.` : `No memory found for key "${key}".`
         };
       }
+      async semanticSearchMemories(input2, context) {
+        const query = input2.query;
+        if (!query || typeof query !== "string") {
+          return { success: false, error: 'Missing required field "query" for semantic_search action' };
+        }
+        if (!this.embeddingService) {
+          return this.searchMemories(input2, context);
+        }
+        const results = await this.embeddingService.semanticSearch(context.userId, query, 10);
+        if (results.length === 0) {
+          return this.searchMemories(input2, context);
+        }
+        return {
+          success: true,
+          data: results,
+          display: `Found ${results.length} semantically related memory(ies):
+${results.map((r) => `- ${r.key}: "${r.value}" (score: ${r.score.toFixed(2)})`).join("\n")}`
+        };
+      }
     };
   }
 });
@@ -3251,6 +3592,8 @@ var init_delegate = __esm({
         description: 'Delegate a complex sub-task to an autonomous sub-agent that has full tool access. The sub-agent can use shell, web search, calculator, memory, email, and all other tools. Use when a task is independent enough to run in parallel or when it requires a focused, multi-step workflow (e.g. "research X and summarize", "find all TODO files and list them", "check the weather and draft a packing list"). The sub-agent runs up to 5 tool iterations autonomously.',
         riskLevel: "write",
         version: "2.0.0",
+        timeoutMs: 12e4,
+        // 2 minutes — delegate chains multiple LLM calls + tool executions
         inputSchema: {
           type: "object",
           properties: {
@@ -3847,24 +4190,28 @@ var init_file = __esm({
     FileSkill = class extends Skill {
       metadata = {
         name: "file",
-        description: "Read or write files safely. Use for reading file contents, writing text to files, listing directory contents, or getting file info. Prefer this over shell for simple file operations.",
+        description: 'Read, write, move, or copy files. Use for reading file contents, writing text to files, saving binary data, listing directory contents, moving/copying files, or getting file info. Prefer this over shell for file operations. When a user sends a file attachment, it is saved to the inbox \u2014 use "move" to relocate it.',
         riskLevel: "write",
-        version: "1.0.0",
+        version: "2.0.0",
         inputSchema: {
           type: "object",
           properties: {
             action: {
               type: "string",
-              enum: ["read", "write", "append", "list", "info", "exists"],
+              enum: ["read", "write", "write_binary", "append", "list", "info", "exists", "move", "copy", "delete"],
               description: "The file operation to perform"
             },
             path: {
               type: "string",
               description: "Absolute or relative file/directory path (~ expands to home)"
             },
+            destination: {
+              type: "string",
+              description: "Destination path for move/copy actions (~ expands to home)"
+            },
             content: {
               type: "string",
-              description: "Content to write (required for write/append)"
+              description: "Content to write (required for write/append; base64-encoded for write_binary)"
             }
           },
           required: ["action", "path"]
@@ -3874,6 +4221,7 @@ var init_file = __esm({
         const action = input2.action;
         const rawPath = input2.path;
         const content = input2.content;
+        const destination = input2.destination;
         if (!action || !rawPath) {
           return { success: false, error: 'Missing required fields "action" and "path"' };
         }
@@ -3883,6 +4231,8 @@ var init_file = __esm({
             return this.readFile(resolvedPath);
           case "write":
             return this.writeFile(resolvedPath, content);
+          case "write_binary":
+            return this.writeBinaryFile(resolvedPath, content);
           case "append":
             return this.appendFile(resolvedPath, content);
           case "list":
@@ -3891,8 +4241,14 @@ var init_file = __esm({
             return this.fileInfo(resolvedPath);
           case "exists":
             return this.fileExists(resolvedPath);
+          case "move":
+            return this.moveFile(resolvedPath, destination);
+          case "copy":
+            return this.copyFile(resolvedPath, destination);
+          case "delete":
+            return this.deleteFile(resolvedPath);
           default:
-            return { success: false, error: `Unknown action "${action}". Valid: read, write, append, list, info, exists` };
+            return { success: false, error: `Unknown action "${action}". Valid: read, write, write_binary, append, list, info, exists, move, copy, delete` };
         }
       }
       resolvePath(raw) {
@@ -4001,6 +4357,89 @@ Modified: ${info.modified}`
           display: exists ? `Yes, "${filePath}" exists` : `No, "${filePath}" does not exist`
         };
       }
+      writeBinaryFile(filePath, base64Content) {
+        if (!base64Content) {
+          return { success: false, error: 'Missing "content" (base64-encoded) for write_binary action' };
+        }
+        try {
+          const dir = path4.dirname(filePath);
+          fs4.mkdirSync(dir, { recursive: true });
+          const buffer = Buffer.from(base64Content, "base64");
+          fs4.writeFileSync(filePath, buffer);
+          return {
+            success: true,
+            data: { path: filePath, bytes: buffer.length },
+            display: `Written ${buffer.length} bytes (binary) to ${filePath}`
+          };
+        } catch (err) {
+          return { success: false, error: `Cannot write "${filePath}": ${err.message}` };
+        }
+      }
+      moveFile(source, destination) {
+        if (!destination) {
+          return { success: false, error: 'Missing "destination" for move action' };
+        }
+        const resolvedDest = this.resolvePath(destination);
+        try {
+          const destDir = path4.dirname(resolvedDest);
+          fs4.mkdirSync(destDir, { recursive: true });
+          fs4.renameSync(source, resolvedDest);
+          return {
+            success: true,
+            data: { from: source, to: resolvedDest },
+            display: `Moved ${source} \u2192 ${resolvedDest}`
+          };
+        } catch (err) {
+          try {
+            fs4.copyFileSync(source, resolvedDest);
+            fs4.unlinkSync(source);
+            return {
+              success: true,
+              data: { from: source, to: resolvedDest },
+              display: `Moved ${source} \u2192 ${resolvedDest}`
+            };
+          } catch (err2) {
+            return { success: false, error: `Cannot move "${source}" to "${resolvedDest}": ${err2.message}` };
+          }
+        }
+      }
+      copyFile(source, destination) {
+        if (!destination) {
+          return { success: false, error: 'Missing "destination" for copy action' };
+        }
+        const resolvedDest = this.resolvePath(destination);
+        try {
+          const destDir = path4.dirname(resolvedDest);
+          fs4.mkdirSync(destDir, { recursive: true });
+          fs4.copyFileSync(source, resolvedDest);
+          return {
+            success: true,
+            data: { from: source, to: resolvedDest },
+            display: `Copied ${source} \u2192 ${resolvedDest}`
+          };
+        } catch (err) {
+          return { success: false, error: `Cannot copy "${source}" to "${resolvedDest}": ${err.message}` };
+        }
+      }
+      deleteFile(filePath) {
+        try {
+          if (!fs4.existsSync(filePath)) {
+            return { success: false, error: `"${filePath}" does not exist` };
+          }
+          const stat = fs4.statSync(filePath);
+          if (stat.isDirectory()) {
+            return { success: false, error: `"${filePath}" is a directory. Use shell for directory deletion.` };
+          }
+          fs4.unlinkSync(filePath);
+          return {
+            success: true,
+            data: { path: filePath },
+            display: `Deleted ${filePath}`
+          };
+        } catch (err) {
+          return { success: false, error: `Cannot delete "${filePath}": ${err.message}` };
+        }
+      }
     };
   }
 });
@@ -4425,69 +4864,877 @@ ${cleaned}`
   }
 });
 
-// ../skills/dist/index.js
-var init_dist6 = __esm({
-  "../skills/dist/index.js"() {
+// ../skills/dist/built-in/profile.js
+var ProfileSkill;
+var init_profile = __esm({
+  "../skills/dist/built-in/profile.js"() {
     "use strict";
     init_skill();
-    init_skill_registry();
-    init_skill_sandbox();
-    init_plugin_loader();
-    init_calculator();
-    init_system_info();
-    init_web_search();
-    init_reminder();
-    init_note();
-    init_weather();
-    init_shell();
-    init_memory();
-    init_delegate();
-    init_email();
-    init_http();
-    init_file();
-    init_clipboard();
-    init_screenshot();
-    init_browser();
-  }
-});
-
-// ../core/dist/conversation-manager.js
-var ConversationManager;
-var init_conversation_manager = __esm({
-  "../core/dist/conversation-manager.js"() {
-    "use strict";
-    ConversationManager = class {
-      conversations;
-      constructor(conversations) {
-        this.conversations = conversations;
+    ProfileSkill = class extends Skill {
+      userRepo;
+      metadata = {
+        name: "profile",
+        description: "Manage user profile settings including timezone, language, and bio. Use this to personalize Alfred for each user.",
+        riskLevel: "write",
+        version: "1.0.0",
+        inputSchema: {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: ["get", "set_timezone", "set_language", "set_bio", "set_preference"],
+              description: "The profile action to perform"
+            },
+            value: {
+              type: "string",
+              description: "The value to set (for set_* actions)"
+            },
+            preference_key: {
+              type: "string",
+              description: "The preference key (for set_preference)"
+            },
+            preference_value: {
+              type: "string",
+              description: "The preference value (for set_preference)"
+            }
+          },
+          required: ["action"]
+        }
+      };
+      constructor(userRepo) {
+        super();
+        this.userRepo = userRepo;
       }
-      getOrCreateConversation(platform, chatId, userId) {
-        const existing = this.conversations.findByPlatformChat(platform, chatId);
-        if (existing) {
-          this.conversations.updateTimestamp(existing.id);
-          return existing;
+      async execute(input2, context) {
+        const action = input2.action;
+        const user = this.userRepo.findOrCreate(context.platform, context.userId);
+        switch (action) {
+          case "get":
+            return this.getProfile(user.id);
+          case "set_timezone":
+            return this.setField(user.id, "timezone", input2.value);
+          case "set_language":
+            return this.setField(user.id, "language", input2.value);
+          case "set_bio":
+            return this.setField(user.id, "bio", input2.value);
+          case "set_preference":
+            return this.setPreference(user.id, input2.preference_key, input2.preference_value);
+          default:
+            return { success: false, error: `Unknown action: "${String(action)}"` };
+        }
+      }
+      getProfile(userId) {
+        const profile = this.userRepo.getProfile(userId);
+        if (!profile) {
+          return { success: true, data: null, display: "No profile found. Set your timezone, language, or bio to create one." };
+        }
+        const parts = [];
+        if (profile.displayName)
+          parts.push(`Name: ${profile.displayName}`);
+        if (profile.timezone)
+          parts.push(`Timezone: ${profile.timezone}`);
+        if (profile.language)
+          parts.push(`Language: ${profile.language}`);
+        if (profile.bio)
+          parts.push(`Bio: ${profile.bio}`);
+        if (profile.preferences) {
+          for (const [key, value] of Object.entries(profile.preferences)) {
+            parts.push(`${key}: ${String(value)}`);
+          }
         }
-        return this.conversations.create(platform, chatId, userId);
+        return {
+          success: true,
+          data: profile,
+          display: parts.length > 0 ? `Profile:
+${parts.map((p) => `- ${p}`).join("\n")}` : "Profile is empty."
+        };
       }
-      addMessage(conversationId, role, content, toolCalls) {
-        return this.conversations.addMessage(conversationId, role, content, toolCalls);
+      setField(userId, field, value) {
+        if (!value || typeof value !== "string") {
+          return { success: false, error: `Missing required "value" for ${field}` };
+        }
+        this.userRepo.updateProfile(userId, { [field]: value });
+        return { success: true, data: { [field]: value }, display: `${field} set to "${value}"` };
       }
-      getHistory(conversationId, limit = 20) {
-        return this.conversations.getMessages(conversationId, limit);
+      setPreference(userId, key, value) {
+        if (!key || typeof key !== "string") {
+          return { success: false, error: 'Missing required "preference_key"' };
+        }
+        const profile = this.userRepo.getProfile(userId);
+        const prefs = profile?.preferences ?? {};
+        prefs[key] = value;
+        this.userRepo.updateProfile(userId, { preferences: prefs });
+        return { success: true, data: { key, value }, display: `Preference "${key}" set to "${value}"` };
       }
     };
   }
 });
 
-// ../core/dist/message-pipeline.js
-var MAX_TOOL_ITERATIONS, TOKEN_BUDGET_RATIO, MessagePipeline;
-var init_message_pipeline = __esm({
-  "../core/dist/message-pipeline.js"() {
+// ../skills/dist/built-in/calendar/calendar-provider.js
+var CalendarProvider;
+var init_calendar_provider = __esm({
+  "../skills/dist/built-in/calendar/calendar-provider.js"() {
+    "use strict";
+    CalendarProvider = class {
+    };
+  }
+});
+
+// ../skills/dist/built-in/calendar/caldav-provider.js
+var caldav_provider_exports = {};
+__export(caldav_provider_exports, {
+  CalDAVProvider: () => CalDAVProvider
+});
+var CalDAVProvider;
+var init_caldav_provider = __esm({
+  "../skills/dist/built-in/calendar/caldav-provider.js"() {
+    "use strict";
+    init_calendar_provider();
+    CalDAVProvider = class extends CalendarProvider {
+      config;
+      client;
+      constructor(config) {
+        super();
+        this.config = config;
+      }
+      async initialize() {
+        try {
+          const tsdav = await import("tsdav");
+          const { createDAVClient } = tsdav;
+          this.client = await createDAVClient({
+            serverUrl: this.config.serverUrl,
+            credentials: {
+              username: this.config.username,
+              password: this.config.password
+            },
+            authMethod: "Basic",
+            defaultAccountType: "caldav"
+          });
+        } catch (err) {
+          throw new Error(`CalDAV initialization failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+      async listEvents(start, end) {
+        const calendars = await this.client.fetchCalendars();
+        if (!calendars || calendars.length === 0)
+          return [];
+        const events = [];
+        for (const calendar of calendars) {
+          const objects = await this.client.fetchCalendarObjects({
+            calendar,
+            timeRange: {
+              start: start.toISOString(),
+              end: end.toISOString()
+            }
+          });
+          for (const obj of objects) {
+            const parsed = this.parseICalEvent(obj.data, obj.url);
+            if (parsed)
+              events.push(parsed);
+          }
+        }
+        return events.sort((a, b) => a.start.getTime() - b.start.getTime());
+      }
+      async createEvent(input2) {
+        const calendars = await this.client.fetchCalendars();
+        if (!calendars || calendars.length === 0) {
+          throw new Error("No calendars found");
+        }
+        const uid = `alfred-${Date.now()}@alfred`;
+        const ical = this.buildICalEvent(uid, input2);
+        await this.client.createCalendarObject({
+          calendar: calendars[0],
+          filename: `${uid}.ics`,
+          iCalString: ical
+        });
+        return {
+          id: uid,
+          title: input2.title,
+          start: input2.start,
+          end: input2.end,
+          location: input2.location,
+          description: input2.description,
+          allDay: input2.allDay
+        };
+      }
+      async updateEvent(id, input2) {
+        const calendars = await this.client.fetchCalendars();
+        for (const calendar of calendars) {
+          const objects = await this.client.fetchCalendarObjects({ calendar });
+          for (const obj of objects) {
+            if (obj.url?.includes(id) || obj.data?.includes(id)) {
+              const existing = this.parseICalEvent(obj.data, obj.url);
+              if (!existing)
+                continue;
+              const updated = {
+                title: input2.title ?? existing.title,
+                start: input2.start ?? existing.start,
+                end: input2.end ?? existing.end,
+                location: input2.location ?? existing.location,
+                description: input2.description ?? existing.description,
+                allDay: input2.allDay ?? existing.allDay
+              };
+              const ical = this.buildICalEvent(id, updated);
+              await this.client.updateCalendarObject({
+                calendarObject: { ...obj, data: ical }
+              });
+              return { id, ...updated };
+            }
+          }
+        }
+        throw new Error(`Event ${id} not found`);
+      }
+      async deleteEvent(id) {
+        const calendars = await this.client.fetchCalendars();
+        for (const calendar of calendars) {
+          const objects = await this.client.fetchCalendarObjects({ calendar });
+          for (const obj of objects) {
+            if (obj.url?.includes(id) || obj.data?.includes(id)) {
+              await this.client.deleteCalendarObject({ calendarObject: obj });
+              return;
+            }
+          }
+        }
+        throw new Error(`Event ${id} not found`);
+      }
+      async checkAvailability(start, end) {
+        const events = await this.listEvents(start, end);
+        const conflicts = events.filter((e) => !e.allDay && e.start < end && e.end > start);
+        return { available: conflicts.length === 0, conflicts };
+      }
+      parseICalEvent(data, url) {
+        try {
+          const lines = data.split("\n").map((l) => l.trim());
+          const get = (key) => lines.find((l) => l.startsWith(key + ":"))?.slice(key.length + 1);
+          const summary = get("SUMMARY");
+          const dtstart = get("DTSTART") ?? get("DTSTART;VALUE=DATE");
+          const dtend = get("DTEND") ?? get("DTEND;VALUE=DATE");
+          const location = get("LOCATION");
+          const description = get("DESCRIPTION");
+          const uid = get("UID") ?? url;
+          if (!summary || !dtstart)
+            return void 0;
+          const allDay = dtstart.length === 8;
+          return {
+            id: uid,
+            title: summary,
+            start: this.parseICalDate(dtstart),
+            end: dtend ? this.parseICalDate(dtend) : this.parseICalDate(dtstart),
+            location: location || void 0,
+            description: description || void 0,
+            allDay
+          };
+        } catch {
+          return void 0;
+        }
+      }
+      parseICalDate(str) {
+        if (str.length === 8) {
+          return /* @__PURE__ */ new Date(`${str.slice(0, 4)}-${str.slice(4, 6)}-${str.slice(6, 8)}`);
+        }
+        const clean = str.replace(/[^0-9TZ]/g, "");
+        if (clean.length >= 15) {
+          return /* @__PURE__ */ new Date(`${clean.slice(0, 4)}-${clean.slice(4, 6)}-${clean.slice(6, 8)}T${clean.slice(9, 11)}:${clean.slice(11, 13)}:${clean.slice(13, 15)}Z`);
+        }
+        return new Date(str);
+      }
+      buildICalEvent(uid, input2) {
+        const formatDate = (d, allDay) => {
+          if (allDay) {
+            return d.toISOString().slice(0, 10).replace(/-/g, "");
+          }
+          return d.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}/, "");
+        };
+        let ical = "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//Alfred//EN\r\nBEGIN:VEVENT\r\n";
+        ical += `UID:${uid}\r
+`;
+        ical += `SUMMARY:${input2.title}\r
+`;
+        if (input2.allDay) {
+          ical += `DTSTART;VALUE=DATE:${formatDate(input2.start, true)}\r
+`;
+          ical += `DTEND;VALUE=DATE:${formatDate(input2.end, true)}\r
+`;
+        } else {
+          ical += `DTSTART:${formatDate(input2.start)}\r
+`;
+          ical += `DTEND:${formatDate(input2.end)}\r
+`;
+        }
+        if (input2.location)
+          ical += `LOCATION:${input2.location}\r
+`;
+        if (input2.description)
+          ical += `DESCRIPTION:${input2.description}\r
+`;
+        ical += `DTSTAMP:${formatDate(/* @__PURE__ */ new Date())}\r
+`;
+        ical += "END:VEVENT\r\nEND:VCALENDAR\r\n";
+        return ical;
+      }
+    };
+  }
+});
+
+// ../skills/dist/built-in/calendar/google-provider.js
+var google_provider_exports = {};
+__export(google_provider_exports, {
+  GoogleCalendarProvider: () => GoogleCalendarProvider
+});
+var GoogleCalendarProvider;
+var init_google_provider = __esm({
+  "../skills/dist/built-in/calendar/google-provider.js"() {
+    "use strict";
+    init_calendar_provider();
+    GoogleCalendarProvider = class extends CalendarProvider {
+      config;
+      calendar;
+      constructor(config) {
+        super();
+        this.config = config;
+      }
+      async initialize() {
+        try {
+          const { google } = await import("googleapis");
+          const auth = new google.auth.OAuth2(this.config.clientId, this.config.clientSecret);
+          auth.setCredentials({ refresh_token: this.config.refreshToken });
+          this.calendar = google.calendar({ version: "v3", auth });
+        } catch (err) {
+          throw new Error(`Google Calendar initialization failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+      async listEvents(start, end) {
+        const response = await this.calendar.events.list({
+          calendarId: "primary",
+          timeMin: start.toISOString(),
+          timeMax: end.toISOString(),
+          singleEvents: true,
+          orderBy: "startTime"
+        });
+        return (response.data.items ?? []).map((item) => this.mapEvent(item));
+      }
+      async createEvent(input2) {
+        const event = {
+          summary: input2.title,
+          location: input2.location,
+          description: input2.description
+        };
+        if (input2.allDay) {
+          event.start = { date: input2.start.toISOString().slice(0, 10) };
+          event.end = { date: input2.end.toISOString().slice(0, 10) };
+        } else {
+          event.start = { dateTime: input2.start.toISOString() };
+          event.end = { dateTime: input2.end.toISOString() };
+        }
+        const response = await this.calendar.events.insert({
+          calendarId: "primary",
+          requestBody: event
+        });
+        return this.mapEvent(response.data);
+      }
+      async updateEvent(id, input2) {
+        const patch = {};
+        if (input2.title)
+          patch.summary = input2.title;
+        if (input2.location)
+          patch.location = input2.location;
+        if (input2.description)
+          patch.description = input2.description;
+        if (input2.start) {
+          patch.start = input2.allDay ? { date: input2.start.toISOString().slice(0, 10) } : { dateTime: input2.start.toISOString() };
+        }
+        if (input2.end) {
+          patch.end = input2.allDay ? { date: input2.end.toISOString().slice(0, 10) } : { dateTime: input2.end.toISOString() };
+        }
+        const response = await this.calendar.events.patch({
+          calendarId: "primary",
+          eventId: id,
+          requestBody: patch
+        });
+        return this.mapEvent(response.data);
+      }
+      async deleteEvent(id) {
+        await this.calendar.events.delete({
+          calendarId: "primary",
+          eventId: id
+        });
+      }
+      async checkAvailability(start, end) {
+        const events = await this.listEvents(start, end);
+        const conflicts = events.filter((e) => !e.allDay && e.start < end && e.end > start);
+        return { available: conflicts.length === 0, conflicts };
+      }
+      mapEvent(item) {
+        const allDay = !!item.start?.date;
+        return {
+          id: item.id,
+          title: item.summary ?? "(No title)",
+          start: new Date(item.start?.dateTime ?? item.start?.date),
+          end: new Date(item.end?.dateTime ?? item.end?.date),
+          location: item.location ?? void 0,
+          description: item.description ?? void 0,
+          allDay
+        };
+      }
+    };
+  }
+});
+
+// ../skills/dist/built-in/calendar/microsoft-provider.js
+var microsoft_provider_exports = {};
+__export(microsoft_provider_exports, {
+  MicrosoftCalendarProvider: () => MicrosoftCalendarProvider
+});
+var MicrosoftCalendarProvider;
+var init_microsoft_provider = __esm({
+  "../skills/dist/built-in/calendar/microsoft-provider.js"() {
+    "use strict";
+    init_calendar_provider();
+    MicrosoftCalendarProvider = class extends CalendarProvider {
+      config;
+      client;
+      accessToken = "";
+      constructor(config) {
+        super();
+        this.config = config;
+      }
+      async initialize() {
+        await this.refreshAccessToken();
+      }
+      async refreshAccessToken() {
+        const tokenUrl = `https://login.microsoftonline.com/${this.config.tenantId}/oauth2/v2.0/token`;
+        const body = new URLSearchParams({
+          client_id: this.config.clientId,
+          client_secret: this.config.clientSecret,
+          refresh_token: this.config.refreshToken,
+          grant_type: "refresh_token",
+          scope: "https://graph.microsoft.com/Calendars.ReadWrite offline_access"
+        });
+        const res = await fetch(tokenUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/x-www-form-urlencoded" },
+          body: body.toString()
+        });
+        if (!res.ok) {
+          throw new Error(`Microsoft token refresh failed: ${res.status}`);
+        }
+        const data = await res.json();
+        this.accessToken = data.access_token;
+      }
+      async graphRequest(path13, options = {}) {
+        const res = await fetch(`https://graph.microsoft.com/v1.0${path13}`, {
+          ...options,
+          headers: {
+            Authorization: `Bearer ${this.accessToken}`,
+            "Content-Type": "application/json",
+            ...options.headers
+          }
+        });
+        if (res.status === 401) {
+          await this.refreshAccessToken();
+          const retry = await fetch(`https://graph.microsoft.com/v1.0${path13}`, {
+            ...options,
+            headers: {
+              Authorization: `Bearer ${this.accessToken}`,
+              "Content-Type": "application/json",
+              ...options.headers
+            }
+          });
+          if (!retry.ok)
+            throw new Error(`Graph API error: ${retry.status}`);
+          return retry.json();
+        }
+        if (!res.ok)
+          throw new Error(`Graph API error: ${res.status}`);
+        if (res.status === 204)
+          return void 0;
+        return res.json();
+      }
+      async listEvents(start, end) {
+        const params = new URLSearchParams({
+          startDateTime: start.toISOString(),
+          endDateTime: end.toISOString(),
+          $orderby: "start/dateTime",
+          $top: "50"
+        });
+        const data = await this.graphRequest(`/me/calendarView?${params}`);
+        return (data.value ?? []).map((item) => this.mapEvent(item));
+      }
+      async createEvent(input2) {
+        const event = {
+          subject: input2.title,
+          body: input2.description ? { contentType: "text", content: input2.description } : void 0,
+          location: input2.location ? { displayName: input2.location } : void 0,
+          isAllDay: input2.allDay ?? false
+        };
+        if (input2.allDay) {
+          event.start = { dateTime: input2.start.toISOString().slice(0, 10) + "T00:00:00", timeZone: "UTC" };
+          event.end = { dateTime: input2.end.toISOString().slice(0, 10) + "T00:00:00", timeZone: "UTC" };
+        } else {
+          event.start = { dateTime: input2.start.toISOString(), timeZone: "UTC" };
+          event.end = { dateTime: input2.end.toISOString(), timeZone: "UTC" };
+        }
+        const data = await this.graphRequest("/me/events", {
+          method: "POST",
+          body: JSON.stringify(event)
+        });
+        return this.mapEvent(data);
+      }
+      async updateEvent(id, input2) {
+        const patch = {};
+        if (input2.title)
+          patch.subject = input2.title;
+        if (input2.description)
+          patch.body = { contentType: "text", content: input2.description };
+        if (input2.location)
+          patch.location = { displayName: input2.location };
+        if (input2.start) {
+          patch.start = { dateTime: input2.start.toISOString(), timeZone: "UTC" };
+        }
+        if (input2.end) {
+          patch.end = { dateTime: input2.end.toISOString(), timeZone: "UTC" };
+        }
+        const data = await this.graphRequest(`/me/events/${id}`, {
+          method: "PATCH",
+          body: JSON.stringify(patch)
+        });
+        return this.mapEvent(data);
+      }
+      async deleteEvent(id) {
+        await this.graphRequest(`/me/events/${id}`, { method: "DELETE" });
+      }
+      async checkAvailability(start, end) {
+        const events = await this.listEvents(start, end);
+        const conflicts = events.filter((e) => !e.allDay && e.start < end && e.end > start);
+        return { available: conflicts.length === 0, conflicts };
+      }
+      mapEvent(item) {
+        return {
+          id: item.id,
+          title: item.subject ?? "(No title)",
+          start: new Date(item.start?.dateTime),
+          end: new Date(item.end?.dateTime),
+          location: item.location?.displayName ?? void 0,
+          description: item.body?.content ?? void 0,
+          allDay: item.isAllDay ?? false
+        };
+      }
+    };
+  }
+});
+
+// ../skills/dist/built-in/calendar/factory.js
+async function createCalendarProvider(config) {
+  switch (config.provider) {
+    case "caldav": {
+      if (!config.caldav)
+        throw new Error("CalDAV config missing");
+      const { CalDAVProvider: CalDAVProvider2 } = await Promise.resolve().then(() => (init_caldav_provider(), caldav_provider_exports));
+      const provider = new CalDAVProvider2(config.caldav);
+      await provider.initialize();
+      return provider;
+    }
+    case "google": {
+      if (!config.google)
+        throw new Error("Google Calendar config missing");
+      const { GoogleCalendarProvider: GoogleCalendarProvider2 } = await Promise.resolve().then(() => (init_google_provider(), google_provider_exports));
+      const provider = new GoogleCalendarProvider2(config.google);
+      await provider.initialize();
+      return provider;
+    }
+    case "microsoft": {
+      if (!config.microsoft)
+        throw new Error("Microsoft Calendar config missing");
+      const { MicrosoftCalendarProvider: MicrosoftCalendarProvider2 } = await Promise.resolve().then(() => (init_microsoft_provider(), microsoft_provider_exports));
+      const provider = new MicrosoftCalendarProvider2(config.microsoft);
+      await provider.initialize();
+      return provider;
+    }
+    default:
+      throw new Error(`Unknown calendar provider: ${config.provider}`);
+  }
+}
+var init_factory = __esm({
+  "../skills/dist/built-in/calendar/factory.js"() {
+    "use strict";
+  }
+});
+
+// ../skills/dist/built-in/calendar/calendar-skill.js
+var CalendarSkill;
+var init_calendar_skill = __esm({
+  "../skills/dist/built-in/calendar/calendar-skill.js"() {
+    "use strict";
+    init_skill();
+    CalendarSkill = class extends Skill {
+      calendarProvider;
+      timezone;
+      metadata = {
+        name: "calendar",
+        description: "Manage calendar events. List upcoming events, create new events, update or delete existing ones, and check availability.",
+        riskLevel: "write",
+        version: "1.0.0",
+        inputSchema: {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: ["list_events", "create_event", "update_event", "delete_event", "check_availability"],
+              description: "The calendar action to perform"
+            },
+            start: {
+              type: "string",
+              description: "Start date/time in ISO 8601 format"
+            },
+            end: {
+              type: "string",
+              description: "End date/time in ISO 8601 format"
+            },
+            title: {
+              type: "string",
+              description: "Event title (for create/update)"
+            },
+            location: {
+              type: "string",
+              description: "Event location (for create/update)"
+            },
+            description: {
+              type: "string",
+              description: "Event description (for create/update)"
+            },
+            event_id: {
+              type: "string",
+              description: "Event ID (for update/delete)"
+            },
+            all_day: {
+              type: "boolean",
+              description: "Whether this is an all-day event"
+            }
+          },
+          required: ["action"]
+        }
+      };
+      constructor(calendarProvider, timezone) {
+        super();
+        this.calendarProvider = calendarProvider;
+        this.timezone = timezone;
+      }
+      async execute(input2, _context) {
+        const action = input2.action;
+        switch (action) {
+          case "list_events":
+            return this.listEvents(input2);
+          case "create_event":
+            return this.createEvent(input2);
+          case "update_event":
+            return this.updateEvent(input2);
+          case "delete_event":
+            return this.deleteEvent(input2);
+          case "check_availability":
+            return this.checkAvailability(input2);
+          default:
+            return { success: false, error: `Unknown action: "${String(action)}"` };
+        }
+      }
+      async getTodayEvents() {
+        const now = /* @__PURE__ */ new Date();
+        const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        const endOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1);
+        try {
+          return await this.calendarProvider.listEvents(startOfDay, endOfDay);
+        } catch {
+          return [];
+        }
+      }
+      async listEvents(input2) {
+        const start = input2.start ? new Date(input2.start) : /* @__PURE__ */ new Date();
+        const end = input2.end ? new Date(input2.end) : new Date(start.getTime() + 7 * 24 * 60 * 60 * 1e3);
+        try {
+          const events = await this.calendarProvider.listEvents(start, end);
+          if (events.length === 0) {
+            return { success: true, data: [], display: "No events found in this time range." };
+          }
+          const display = events.map((e) => this.formatEvent(e)).join("\n");
+          return { success: true, data: events, display: `${events.length} event(s):
+${display}` };
+        } catch (err) {
+          return { success: false, error: `Failed to list events: ${err instanceof Error ? err.message : String(err)}` };
+        }
+      }
+      async createEvent(input2) {
+        const title = input2.title;
+        const start = input2.start;
+        const end = input2.end;
+        if (!title)
+          return { success: false, error: 'Missing required field "title"' };
+        if (!start)
+          return { success: false, error: 'Missing required field "start"' };
+        if (!end)
+          return { success: false, error: 'Missing required field "end"' };
+        try {
+          const event = await this.calendarProvider.createEvent({
+            title,
+            start: new Date(start),
+            end: new Date(end),
+            location: input2.location,
+            description: input2.description,
+            allDay: input2.all_day
+          });
+          return {
+            success: true,
+            data: event,
+            display: `Event created: ${this.formatEvent(event)}`
+          };
+        } catch (err) {
+          return { success: false, error: `Failed to create event: ${err instanceof Error ? err.message : String(err)}` };
+        }
+      }
+      async updateEvent(input2) {
+        const eventId = input2.event_id;
+        if (!eventId)
+          return { success: false, error: 'Missing required field "event_id"' };
+        try {
+          const event = await this.calendarProvider.updateEvent(eventId, {
+            title: input2.title,
+            start: input2.start ? new Date(input2.start) : void 0,
+            end: input2.end ? new Date(input2.end) : void 0,
+            location: input2.location,
+            description: input2.description,
+            allDay: input2.all_day
+          });
+          return {
+            success: true,
+            data: event,
+            display: `Event updated: ${this.formatEvent(event)}`
+          };
+        } catch (err) {
+          return { success: false, error: `Failed to update event: ${err instanceof Error ? err.message : String(err)}` };
+        }
+      }
+      async deleteEvent(input2) {
+        const eventId = input2.event_id;
+        if (!eventId)
+          return { success: false, error: 'Missing required field "event_id"' };
+        try {
+          await this.calendarProvider.deleteEvent(eventId);
+          return { success: true, data: { deleted: eventId }, display: `Event "${eventId}" deleted.` };
+        } catch (err) {
+          return { success: false, error: `Failed to delete event: ${err instanceof Error ? err.message : String(err)}` };
+        }
+      }
+      async checkAvailability(input2) {
+        const start = input2.start;
+        const end = input2.end;
+        if (!start || !end)
+          return { success: false, error: 'Missing required fields "start" and "end"' };
+        try {
+          const result = await this.calendarProvider.checkAvailability(new Date(start), new Date(end));
+          const display = result.available ? "Time slot is available." : `Time slot has ${result.conflicts.length} conflict(s):
+${result.conflicts.map((e) => this.formatEvent(e)).join("\n")}`;
+          return { success: true, data: result, display };
+        } catch (err) {
+          return { success: false, error: `Failed to check availability: ${err instanceof Error ? err.message : String(err)}` };
+        }
+      }
+      formatEvent(event) {
+        const opts = {
+          hour: "2-digit",
+          minute: "2-digit",
+          ...this.timezone ? { timeZone: this.timezone } : {}
+        };
+        if (event.allDay) {
+          return `- All day: ${event.title}${event.location ? ` @ ${event.location}` : ""}`;
+        }
+        const startTime = event.start.toLocaleTimeString("en-GB", opts);
+        const endTime = event.end.toLocaleTimeString("en-GB", opts);
+        return `- ${startTime}-${endTime}: ${event.title}${event.location ? ` @ ${event.location}` : ""}`;
+      }
+    };
+  }
+});
+
+// ../skills/dist/built-in/calendar/index.js
+var init_calendar = __esm({
+  "../skills/dist/built-in/calendar/index.js"() {
+    "use strict";
+    init_calendar_provider();
+    init_caldav_provider();
+    init_google_provider();
+    init_microsoft_provider();
+    init_factory();
+    init_calendar_skill();
+  }
+});
+
+// ../skills/dist/index.js
+var init_dist6 = __esm({
+  "../skills/dist/index.js"() {
+    "use strict";
+    init_skill();
+    init_skill_registry();
+    init_skill_sandbox();
+    init_plugin_loader();
+    init_calculator();
+    init_system_info();
+    init_web_search();
+    init_reminder();
+    init_note();
+    init_weather();
+    init_shell();
+    init_memory();
+    init_delegate();
+    init_email();
+    init_http();
+    init_file();
+    init_clipboard();
+    init_screenshot();
+    init_browser();
+    init_profile();
+    init_calendar();
+  }
+});
+
+// ../core/dist/conversation-manager.js
+var ConversationManager;
+var init_conversation_manager = __esm({
+  "../core/dist/conversation-manager.js"() {
+    "use strict";
+    ConversationManager = class {
+      conversations;
+      constructor(conversations) {
+        this.conversations = conversations;
+      }
+      getOrCreateConversation(platform, chatId, userId) {
+        const existing = this.conversations.findByPlatformChat(platform, chatId);
+        if (existing) {
+          this.conversations.updateTimestamp(existing.id);
+          return existing;
+        }
+        return this.conversations.create(platform, chatId, userId);
+      }
+      addMessage(conversationId, role, content, toolCalls) {
+        return this.conversations.addMessage(conversationId, role, content, toolCalls);
+      }
+      getHistory(conversationId, limit = 20) {
+        return this.conversations.getMessages(conversationId, limit);
+      }
+    };
+  }
+});
+
+// ../core/dist/message-pipeline.js
+import fs5 from "node:fs";
+import path7 from "node:path";
+var MAX_TOOL_ITERATIONS, TOKEN_BUDGET_RATIO, MAX_INLINE_FILE_SIZE, MessagePipeline;
+var init_message_pipeline = __esm({
+  "../core/dist/message-pipeline.js"() {
     "use strict";
     init_dist4();
     MAX_TOOL_ITERATIONS = 10;
     TOKEN_BUDGET_RATIO = 0.85;
+    MAX_INLINE_FILE_SIZE = 1e5;
     MessagePipeline = class {
+      promptBuilder;
       llm;
       conversationManager;
       users;
@@ -4496,16 +5743,21 @@ var init_message_pipeline = __esm({
       skillSandbox;
       securityManager;
       memoryRepo;
-      promptBuilder;
-      constructor(llm, conversationManager, users, logger, skillRegistry, skillSandbox, securityManager, memoryRepo) {
-        this.llm = llm;
-        this.conversationManager = conversationManager;
-        this.users = users;
-        this.logger = logger;
-        this.skillRegistry = skillRegistry;
-        this.skillSandbox = skillSandbox;
-        this.securityManager = securityManager;
-        this.memoryRepo = memoryRepo;
+      speechTranscriber;
+      inboxPath;
+      embeddingService;
+      constructor(options) {
+        this.llm = options.llm;
+        this.conversationManager = options.conversationManager;
+        this.users = options.users;
+        this.logger = options.logger;
+        this.skillRegistry = options.skillRegistry;
+        this.skillSandbox = options.skillSandbox;
+        this.securityManager = options.securityManager;
+        this.memoryRepo = options.memoryRepo;
+        this.speechTranscriber = options.speechTranscriber;
+        this.inboxPath = options.inboxPath;
+        this.embeddingService = options.embeddingService;
         this.promptBuilder = new PromptBuilder();
       }
       async process(message, onProgress) {
@@ -4519,15 +5771,49 @@ var init_message_pipeline = __esm({
           let memories;
           if (this.memoryRepo) {
             try {
-              memories = this.memoryRepo.getRecentForPrompt(user.id, 20);
+              if (this.embeddingService && message.text) {
+                const semanticResults = await this.embeddingService.semanticSearch(user.id, message.text, 10);
+                const recentResults = this.memoryRepo.getRecentForPrompt(user.id, 5);
+                const seen = /* @__PURE__ */ new Set();
+                memories = [];
+                for (const m of semanticResults) {
+                  if (!seen.has(m.key)) {
+                    seen.add(m.key);
+                    memories.push(m);
+                  }
+                }
+                for (const m of recentResults) {
+                  if (!seen.has(m.key)) {
+                    seen.add(m.key);
+                    memories.push(m);
+                  }
+                }
+              } else {
+                memories = this.memoryRepo.getRecentForPrompt(user.id, 20);
+              }
             } catch {
             }
           }
+          let userProfile;
+          try {
+            if ("getProfile" in this.users) {
+              userProfile = this.users.getProfile(user.id);
+              if (userProfile && !userProfile.displayName) {
+                userProfile.displayName = user.displayName ?? user.username;
+              }
+            }
+          } catch {
+          }
           const skillMetas = this.skillRegistry ? this.skillRegistry.getAll().map((s) => s.metadata) : void 0;
           const tools = skillMetas ? this.promptBuilder.buildTools(skillMetas) : void 0;
-          const system = this.promptBuilder.buildSystemPrompt(memories, skillMetas);
+          const system = this.promptBuilder.buildSystemPrompt({
+            memories,
+            skills: skillMetas,
+            userProfile
+          });
           const allMessages = this.promptBuilder.buildMessages(history);
-          allMessages.push({ role: "user", content: message.text });
+          const userContent = await this.buildUserContent(message, onProgress);
+          allMessages.push({ role: "user", content: userContent });
           const messages = this.trimToContextWindow(system, allMessages);
           let response;
           let iteration = 0;
@@ -4672,6 +5958,10 @@ var init_message_pipeline = __esm({
             return `Weather: ${String(input2.location ?? "")}`;
           case "note":
             return `Note: ${String(input2.action ?? "")}`;
+          case "profile":
+            return `Profile: ${String(input2.action ?? "")}`;
+          case "calendar":
+            return `Calendar: ${String(input2.action ?? "")}`;
           default:
             return `Using ${toolName}...`;
         }
@@ -4713,6 +6003,135 @@ var init_message_pipeline = __esm({
         keptMessages.push(latestMsg);
         return keptMessages;
       }
+      /**
+       * Build the user content for the LLM request.
+       * Handles images (as vision blocks), audio (transcribed via Whisper),
+       * documents/files (saved to inbox), and plain text.
+       */
+      async buildUserContent(message, onProgress) {
+        const attachments = message.attachments?.filter((a) => a.data) ?? [];
+        if (attachments.length === 0) {
+          return message.text;
+        }
+        const blocks = [];
+        for (const attachment of attachments) {
+          if (attachment.type === "image" && attachment.data) {
+            blocks.push({
+              type: "image",
+              source: {
+                type: "base64",
+                media_type: attachment.mimeType ?? "image/jpeg",
+                data: attachment.data.toString("base64")
+              }
+            });
+            this.logger.info({ mimeType: attachment.mimeType, size: attachment.size }, "Image attached to LLM request");
+          } else if (attachment.type === "audio" && attachment.data) {
+            if (this.speechTranscriber) {
+              onProgress?.("Transcribing voice...");
+              try {
+                const transcript = await this.speechTranscriber.transcribe(attachment.data, attachment.mimeType ?? "audio/ogg");
+                const label = message.text === "[Voice message]" ? "" : `${message.text}
+
+`;
+                blocks.push({
+                  type: "text",
+                  text: `${label}[Voice transcript]: ${transcript}`
+                });
+                this.logger.info({ transcriptLength: transcript.length }, "Voice message transcribed");
+                return blocks.length === 1 ? blocks[0].type === "text" ? blocks[0].text : blocks : blocks;
+              } catch (err) {
+                this.logger.error({ err }, "Voice transcription failed");
+                blocks.push({
+                  type: "text",
+                  text: "[Voice message could not be transcribed]"
+                });
+              }
+            } else {
+              blocks.push({
+                type: "text",
+                text: "[Voice message received but speech-to-text is not configured. Add speech config to enable transcription.]"
+              });
+            }
+          } else if ((attachment.type === "document" || attachment.type === "video" || attachment.type === "other") && attachment.data) {
+            const savedPath = this.saveToInbox(attachment);
+            if (savedPath) {
+              const isTextFile = this.isTextMimeType(attachment.mimeType);
+              let fileNote = `[File received: "${attachment.fileName ?? "unknown"}" (${this.formatBytes(attachment.data.length)}, ${attachment.mimeType ?? "unknown type"})]
+[Saved to: ${savedPath}]`;
+              if (isTextFile && attachment.data.length <= MAX_INLINE_FILE_SIZE) {
+                const textContent = attachment.data.toString("utf-8");
+                fileNote += `
+[File content]:
+${textContent}`;
+              }
+              blocks.push({ type: "text", text: fileNote });
+              this.logger.info({ fileName: attachment.fileName, savedPath, size: attachment.data.length }, "File saved to inbox");
+            }
+          }
+        }
+        const skipTexts = ["[Photo]", "[Voice message]", "[Video]", "[Video note]", "[Document]", "[File]"];
+        if (message.text && !skipTexts.includes(message.text)) {
+          blocks.push({ type: "text", text: message.text });
+        } else if (blocks.some((b) => b.type === "image") && !blocks.some((b) => b.type === "text")) {
+          blocks.push({ type: "text", text: "What do you see in this image?" });
+        } else if (blocks.length === 0) {
+          blocks.push({ type: "text", text: message.text || "(empty message)" });
+        }
+        return blocks;
+      }
+      /**
+       * Save an attachment to the inbox directory.
+       * Returns the saved file path, or undefined on failure.
+       */
+      saveToInbox(attachment) {
+        if (!attachment.data)
+          return void 0;
+        const inboxDir = this.inboxPath ?? path7.resolve("./data/inbox");
+        try {
+          fs5.mkdirSync(inboxDir, { recursive: true });
+        } catch {
+          this.logger.error({ inboxDir }, "Cannot create inbox directory");
+          return void 0;
+        }
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+        const originalName = attachment.fileName ?? `file_${timestamp}`;
+        const safeName = originalName.replace(/[<>:"/\\|?*]/g, "_");
+        const fileName = `${timestamp}_${safeName}`;
+        const filePath = path7.join(inboxDir, fileName);
+        try {
+          fs5.writeFileSync(filePath, attachment.data);
+          return filePath;
+        } catch (err) {
+          this.logger.error({ err, filePath }, "Failed to save file to inbox");
+          return void 0;
+        }
+      }
+      isTextMimeType(mimeType) {
+        if (!mimeType)
+          return false;
+        const textTypes = [
+          "text/",
+          "application/json",
+          "application/xml",
+          "application/javascript",
+          "application/typescript",
+          "application/x-yaml",
+          "application/yaml",
+          "application/toml",
+          "application/x-sh",
+          "application/sql",
+          "application/csv",
+          "application/x-csv"
+        ];
+        return textTypes.some((t) => mimeType.startsWith(t));
+      }
+      formatBytes(bytes) {
+        if (bytes < 1024)
+          return `${bytes} B`;
+        if (bytes < 1024 * 1024)
+          return `${(bytes / 1024).toFixed(1)} KB`;
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+      }
     };
   }
 });
@@ -4732,35 +6151,239 @@ var init_reminder_scheduler = __esm({
         this.reminderRepo = reminderRepo;
         this.sendMessage = sendMessage;
         this.logger = logger;
-        this.checkIntervalMs = checkIntervalMs;
-      }
-      start() {
-        this.logger.info("Reminder scheduler started");
-        this.intervalId = setInterval(() => this.checkDueReminders(), this.checkIntervalMs);
-        this.checkDueReminders();
+        this.checkIntervalMs = checkIntervalMs;
+      }
+      start() {
+        this.logger.info("Reminder scheduler started");
+        this.intervalId = setInterval(() => this.checkDueReminders(), this.checkIntervalMs);
+        this.checkDueReminders();
+      }
+      stop() {
+        if (this.intervalId) {
+          clearInterval(this.intervalId);
+          this.intervalId = void 0;
+        }
+        this.logger.info("Reminder scheduler stopped");
+      }
+      async checkDueReminders() {
+        try {
+          const due = this.reminderRepo.getDue();
+          for (const reminder of due) {
+            try {
+              await this.sendMessage(reminder.platform, reminder.chatId, `\u23F0 Reminder: ${reminder.message}`);
+              this.reminderRepo.markFired(reminder.id);
+              this.logger.info({ reminderId: reminder.id }, "Reminder fired");
+            } catch (err) {
+              this.logger.error({ err, reminderId: reminder.id }, "Failed to send reminder");
+            }
+          }
+        } catch (err) {
+          this.logger.error({ err }, "Error checking due reminders");
+        }
+      }
+    };
+  }
+});
+
+// ../core/dist/speech-transcriber.js
+var SpeechTranscriber;
+var init_speech_transcriber = __esm({
+  "../core/dist/speech-transcriber.js"() {
+    "use strict";
+    SpeechTranscriber = class {
+      logger;
+      apiKey;
+      baseUrl;
+      constructor(config, logger) {
+        this.logger = logger;
+        this.apiKey = config.apiKey;
+        if (config.provider === "groq") {
+          this.baseUrl = config.baseUrl ?? "https://api.groq.com/openai/v1";
+        } else {
+          this.baseUrl = config.baseUrl ?? "https://api.openai.com/v1";
+        }
+      }
+      async transcribe(audioBuffer, mimeType) {
+        const ext = this.mimeToExtension(mimeType);
+        const formData = new FormData();
+        formData.append("file", new Blob([audioBuffer], { type: mimeType }), `audio.${ext}`);
+        formData.append("model", "whisper-1");
+        try {
+          const response = await fetch(`${this.baseUrl}/audio/transcriptions`, {
+            method: "POST",
+            headers: {
+              "Authorization": `Bearer ${this.apiKey}`
+            },
+            body: formData
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Whisper API ${response.status}: ${errorText}`);
+          }
+          const data = await response.json();
+          this.logger.info({ textLength: data.text.length }, "Voice transcribed");
+          return data.text;
+        } catch (err) {
+          this.logger.error({ err }, "Voice transcription failed");
+          throw err;
+        }
+      }
+      mimeToExtension(mimeType) {
+        const map = {
+          "audio/ogg": "ogg",
+          "audio/mpeg": "mp3",
+          "audio/mp4": "m4a",
+          "audio/wav": "wav",
+          "audio/webm": "webm",
+          "audio/x-m4a": "m4a"
+        };
+        return map[mimeType] ?? "ogg";
+      }
+    };
+  }
+});
+
+// ../core/dist/response-formatter.js
+var ResponseFormatter;
+var init_response_formatter = __esm({
+  "../core/dist/response-formatter.js"() {
+    "use strict";
+    ResponseFormatter = class {
+      format(text, platform) {
+        switch (platform) {
+          case "telegram":
+            return { text: this.toTelegramHTML(text), parseMode: "html" };
+          case "discord":
+            return { text, parseMode: "markdown" };
+          case "matrix":
+            return { text: this.toMatrixHTML(text), parseMode: "html" };
+          case "whatsapp":
+            return { text: this.toWhatsApp(text), parseMode: "text" };
+          case "signal":
+            return { text: this.stripFormatting(text), parseMode: "text" };
+          default:
+            return { text, parseMode: "text" };
+        }
+      }
+      toTelegramHTML(md) {
+        let html = md;
+        html = html.replace(/```(\w*)\n([\s\S]*?)```/g, (_match, _lang, code) => {
+          return `<pre>${this.escapeHTML(code.trimEnd())}</pre>`;
+        });
+        html = html.replace(/`([^`]+)`/g, (_match, code) => {
+          return `<code>${this.escapeHTML(code)}</code>`;
+        });
+        html = html.replace(/\*\*(.+?)\*\*/g, "<b>$1</b>");
+        html = html.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, "<i>$1</i>");
+        html = html.replace(/~~(.+?)~~/g, "<s>$1</s>");
+        html = html.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+        return html;
+      }
+      toMatrixHTML(md) {
+        return this.toTelegramHTML(md);
+      }
+      toWhatsApp(md) {
+        let text = md;
+        text = text.replace(/\*\*(.+?)\*\*/g, "*$1*");
+        text = text.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, "_$1_");
+        text = text.replace(/~~(.+?)~~/g, "~$1~");
+        text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1 ($2)");
+        return text;
+      }
+      stripFormatting(md) {
+        let text = md;
+        text = text.replace(/```\w*\n?/g, "");
+        text = text.replace(/`([^`]+)`/g, "$1");
+        text = text.replace(/\*\*(.+?)\*\*/g, "$1");
+        text = text.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, "$1");
+        text = text.replace(/~~(.+?)~~/g, "$1");
+        text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1 ($2)");
+        return text;
+      }
+      escapeHTML(text) {
+        return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+      }
+    };
+  }
+});
+
+// ../core/dist/embedding-service.js
+var EmbeddingService;
+var init_embedding_service = __esm({
+  "../core/dist/embedding-service.js"() {
+    "use strict";
+    EmbeddingService = class {
+      llm;
+      embeddingRepo;
+      logger;
+      constructor(llm, embeddingRepo, logger) {
+        this.llm = llm;
+        this.embeddingRepo = embeddingRepo;
+        this.logger = logger;
       }
-      stop() {
-        if (this.intervalId) {
-          clearInterval(this.intervalId);
-          this.intervalId = void 0;
+      async embedAndStore(userId, content, sourceType, sourceId) {
+        if (!this.llm.supportsEmbeddings()) {
+          return;
+        }
+        try {
+          const result = await this.llm.embed(content);
+          if (!result)
+            return;
+          this.embeddingRepo.store({
+            userId,
+            sourceType,
+            sourceId,
+            content,
+            embedding: result.embedding,
+            model: result.model,
+            dimensions: result.dimensions
+          });
+          this.logger.debug({ userId, sourceType, sourceId }, "Embedding stored");
+        } catch (err) {
+          this.logger.error({ err, userId, sourceType, sourceId }, "Failed to embed content");
         }
-        this.logger.info("Reminder scheduler stopped");
       }
-      async checkDueReminders() {
+      async semanticSearch(userId, query, limit = 10) {
+        if (!this.llm.supportsEmbeddings()) {
+          return [];
+        }
         try {
-          const due = this.reminderRepo.getDue();
-          for (const reminder of due) {
-            try {
-              await this.sendMessage(reminder.platform, reminder.chatId, `\u23F0 Reminder: ${reminder.message}`);
-              this.reminderRepo.markFired(reminder.id);
-              this.logger.info({ reminderId: reminder.id }, "Reminder fired");
-            } catch (err) {
-              this.logger.error({ err, reminderId: reminder.id }, "Failed to send reminder");
-            }
-          }
+          const queryResult = await this.llm.embed(query);
+          if (!queryResult)
+            return [];
+          const embeddings = this.embeddingRepo.findByUser(userId);
+          if (embeddings.length === 0)
+            return [];
+          const scored = embeddings.map((entry) => {
+            const score = this.cosineSimilarity(queryResult.embedding, entry.embedding);
+            return { ...entry, score };
+          });
+          scored.sort((a, b) => b.score - a.score);
+          const topResults = scored.slice(0, limit);
+          return topResults.map((r) => ({
+            key: r.sourceId,
+            value: r.content,
+            category: r.sourceType,
+            score: r.score
+          }));
         } catch (err) {
-          this.logger.error({ err }, "Error checking due reminders");
+          this.logger.error({ err }, "Semantic search failed");
+          return [];
+        }
+      }
+      cosineSimilarity(a, b) {
+        if (a.length !== b.length)
+          return 0;
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+          dotProduct += a[i] * b[i];
+          normA += a[i] * a[i];
+          normB += b[i] * b[i];
         }
+        const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+        return denominator === 0 ? 0 : dotProduct / denominator;
       }
     };
   }
@@ -4774,6 +6397,12 @@ var init_adapter = __esm({
     "use strict";
     MessagingAdapter = class extends EventEmitter {
       status = "disconnected";
+      async sendPhoto(_chatId, _photo, _caption) {
+        return void 0;
+      }
+      async sendFile(_chatId, _file, _fileName, _caption) {
+        return void 0;
+      }
       getStatus() {
         return this.status;
       }
@@ -4782,7 +6411,7 @@ var init_adapter = __esm({
 });
 
 // ../messaging/dist/adapters/telegram.js
-import { Bot } from "grammy";
+import { Bot, InputFile } from "grammy";
 function mapParseMode(mode) {
   if (mode === "markdown")
     return "MarkdownV2";
@@ -4805,21 +6434,65 @@ var init_telegram = __esm({
       async connect() {
         this.status = "connecting";
         this.bot.on("message:text", (ctx) => {
+          this.emit("message", this.normalizeMessage(ctx.message, ctx.message.text));
+        });
+        this.bot.on("message:photo", async (ctx) => {
           const msg = ctx.message;
-          const normalized = {
-            id: String(msg.message_id),
-            platform: "telegram",
-            chatId: String(msg.chat.id),
-            chatType: msg.chat.type === "private" ? "dm" : "group",
-            userId: String(msg.from.id),
-            userName: msg.from.username ?? String(msg.from.id),
-            displayName: [msg.from.first_name, msg.from.last_name].filter(Boolean).join(" "),
-            text: msg.text,
-            timestamp: new Date(msg.date * 1e3),
-            replyToMessageId: msg.reply_to_message ? String(msg.reply_to_message.message_id) : void 0
-          };
+          const caption = msg.caption ?? "";
+          const text = caption || "[Photo]";
+          const photo = msg.photo[msg.photo.length - 1];
+          const attachment = await this.downloadAttachment(photo.file_id, "image", "image/jpeg");
+          const normalized = this.normalizeMessage(msg, text);
+          normalized.attachments = attachment ? [attachment] : void 0;
+          this.emit("message", normalized);
+        });
+        this.bot.on("message:voice", async (ctx) => {
+          const msg = ctx.message;
+          const attachment = await this.downloadAttachment(msg.voice.file_id, "audio", msg.voice.mime_type ?? "audio/ogg");
+          const normalized = this.normalizeMessage(msg, "[Voice message]");
+          normalized.attachments = attachment ? [attachment] : void 0;
+          this.emit("message", normalized);
+        });
+        this.bot.on("message:audio", async (ctx) => {
+          const msg = ctx.message;
+          const caption = msg.caption ?? "";
+          const text = caption || `[Audio: ${msg.audio.file_name ?? "audio"}]`;
+          const attachment = await this.downloadAttachment(msg.audio.file_id, "audio", msg.audio.mime_type ?? "audio/mpeg");
+          const normalized = this.normalizeMessage(msg, text);
+          normalized.attachments = attachment ? [attachment] : void 0;
+          this.emit("message", normalized);
+        });
+        this.bot.on("message:video", async (ctx) => {
+          const msg = ctx.message;
+          const caption = msg.caption ?? "";
+          const text = caption || "[Video]";
+          const attachment = await this.downloadAttachment(msg.video.file_id, "video", msg.video.mime_type ?? "video/mp4");
+          const normalized = this.normalizeMessage(msg, text);
+          normalized.attachments = attachment ? [attachment] : void 0;
+          this.emit("message", normalized);
+        });
+        this.bot.on("message:document", async (ctx) => {
+          const msg = ctx.message;
+          const doc = msg.document;
+          const caption = msg.caption ?? "";
+          const text = caption || `[Document: ${doc.file_name ?? "file"}]`;
+          const attachment = await this.downloadAttachment(doc.file_id, "document", doc.mime_type ?? "application/octet-stream", doc.file_name);
+          const normalized = this.normalizeMessage(msg, text);
+          normalized.attachments = attachment ? [attachment] : void 0;
+          this.emit("message", normalized);
+        });
+        this.bot.on("message:video_note", async (ctx) => {
+          const msg = ctx.message;
+          const attachment = await this.downloadAttachment(msg.video_note.file_id, "video", "video/mp4");
+          const normalized = this.normalizeMessage(msg, "[Video note]");
+          normalized.attachments = attachment ? [attachment] : void 0;
           this.emit("message", normalized);
         });
+        this.bot.on("message:sticker", (ctx) => {
+          const msg = ctx.message;
+          const emoji = msg.sticker.emoji ?? "\u{1F3F7}\uFE0F";
+          this.emit("message", this.normalizeMessage(msg, `[Sticker: ${emoji}]`));
+        });
         this.bot.catch((err) => {
           this.emit("error", err.error);
         });
@@ -4842,12 +6515,58 @@ var init_telegram = __esm({
         });
         return String(result.message_id);
       }
-      async editMessage(chatId, messageId, text) {
-        await this.bot.api.editMessageText(Number(chatId), Number(messageId), text);
+      async editMessage(chatId, messageId, text, options) {
+        await this.bot.api.editMessageText(Number(chatId), Number(messageId), text, {
+          parse_mode: mapParseMode(options?.parseMode)
+        });
       }
       async deleteMessage(chatId, messageId) {
         await this.bot.api.deleteMessage(Number(chatId), Number(messageId));
       }
+      async sendPhoto(chatId, photo, caption) {
+        const result = await this.bot.api.sendPhoto(Number(chatId), new InputFile(photo, "image.png"), { caption });
+        return String(result.message_id);
+      }
+      async sendFile(chatId, file, fileName, caption) {
+        const result = await this.bot.api.sendDocument(Number(chatId), new InputFile(file, fileName), { caption });
+        return String(result.message_id);
+      }
+      normalizeMessage(msg, text) {
+        return {
+          id: String(msg.message_id),
+          platform: "telegram",
+          chatId: String(msg.chat.id),
+          chatType: msg.chat.type === "private" ? "dm" : "group",
+          userId: String(msg.from.id),
+          userName: msg.from.username ?? String(msg.from.id),
+          displayName: [msg.from.first_name, msg.from.last_name].filter(Boolean).join(" "),
+          text,
+          timestamp: new Date(msg.date * 1e3),
+          replyToMessageId: msg.reply_to_message ? String(msg.reply_to_message.message_id) : void 0
+        };
+      }
+      async downloadAttachment(fileId, type, mimeType, fileName) {
+        try {
+          const file = await this.bot.api.getFile(fileId);
+          const filePath = file.file_path;
+          if (!filePath)
+            return void 0;
+          const url = `https://api.telegram.org/file/bot${this.bot.token}/${filePath}`;
+          const response = await fetch(url);
+          if (!response.ok)
+            return void 0;
+          const buffer = Buffer.from(await response.arrayBuffer());
+          return {
+            type,
+            mimeType,
+            fileName: fileName ?? filePath.split("/").pop(),
+            size: buffer.length,
+            data: buffer
+          };
+        } catch {
+          return void 0;
+        }
+      }
     };
   }
 });
@@ -4877,22 +6596,29 @@ var init_discord = __esm({
             GatewayIntentBits.DirectMessages
           ]
         });
-        this.client.on(Events.MessageCreate, (message) => {
+        this.client.on(Events.MessageCreate, async (message) => {
           if (message.author.bot)
             return;
-          const normalized = {
-            id: message.id,
-            platform: "discord",
-            chatId: message.channelId,
-            chatType: message.channel.isDMBased() ? "dm" : "group",
-            userId: message.author.id,
-            userName: message.author.username,
-            displayName: message.author.displayName,
-            text: message.content,
-            timestamp: message.createdAt,
-            replyToMessageId: message.reference?.messageId ?? void 0
-          };
-          this.emit("message", normalized);
+          try {
+            const attachments = await this.downloadAttachments(message);
+            const text = message.content || this.inferTextFromAttachments(attachments);
+            const normalized = {
+              id: message.id,
+              platform: "discord",
+              chatId: message.channelId,
+              chatType: message.channel.isDMBased() ? "dm" : "group",
+              userId: message.author.id,
+              userName: message.author.username,
+              displayName: message.author.displayName,
+              text,
+              timestamp: message.createdAt,
+              replyToMessageId: message.reference?.messageId ?? void 0,
+              attachments: attachments.length > 0 ? attachments : void 0
+            };
+            this.emit("message", normalized);
+          } catch (err) {
+            this.emit("error", err instanceof Error ? err : new Error(String(err)));
+          }
         });
         this.client.on(Events.ClientReady, () => {
           this.status = "connected";
@@ -4924,7 +6650,7 @@ var init_discord = __esm({
         const message = await channel.send(text);
         return message.id;
       }
-      async editMessage(chatId, messageId, text) {
+      async editMessage(chatId, messageId, text, _options) {
         if (!this.client)
           throw new Error("Client is not connected");
         const channel = await this.client.channels.fetch(chatId);
@@ -4944,6 +6670,82 @@ var init_discord = __esm({
         const message = await channel.messages.fetch(messageId);
         await message.delete();
       }
+      async sendPhoto(chatId, photo, caption) {
+        if (!this.client)
+          return void 0;
+        const channel = await this.client.channels.fetch(chatId);
+        if (!channel?.isTextBased() || !("send" in channel))
+          return void 0;
+        const msg = await channel.send({
+          content: caption,
+          files: [{ attachment: photo, name: "image.png" }]
+        });
+        return msg.id;
+      }
+      async sendFile(chatId, file, fileName, caption) {
+        if (!this.client)
+          return void 0;
+        const channel = await this.client.channels.fetch(chatId);
+        if (!channel?.isTextBased() || !("send" in channel))
+          return void 0;
+        const msg = await channel.send({
+          content: caption,
+          files: [{ attachment: file, name: fileName }]
+        });
+        return msg.id;
+      }
+      // ── Private helpers ──────────────────────────────────────────────
+      async downloadAttachments(message) {
+        const result = [];
+        const discordAttachments = message.attachments;
+        if (!discordAttachments || discordAttachments.size === 0)
+          return result;
+        for (const [, att] of discordAttachments) {
+          try {
+            const res = await fetch(att.url);
+            if (!res.ok)
+              continue;
+            const arrayBuffer = await res.arrayBuffer();
+            const data = Buffer.from(arrayBuffer);
+            const type = this.classifyContentType(att.contentType);
+            result.push({
+              type,
+              url: att.url,
+              mimeType: att.contentType ?? void 0,
+              fileName: att.name ?? void 0,
+              size: att.size ?? data.length,
+              data
+            });
+          } catch {
+          }
+        }
+        return result;
+      }
+      classifyContentType(contentType) {
+        if (!contentType)
+          return "other";
+        if (contentType.startsWith("image/"))
+          return "image";
+        if (contentType.startsWith("audio/"))
+          return "audio";
+        if (contentType.startsWith("video/"))
+          return "video";
+        return "document";
+      }
+      inferTextFromAttachments(attachments) {
+        if (attachments.length === 0)
+          return "";
+        const types = attachments.map((a) => a.type);
+        if (types.includes("image"))
+          return "[Photo]";
+        if (types.includes("audio"))
+          return "[Voice message]";
+        if (types.includes("video"))
+          return "[Video]";
+        if (types.includes("document"))
+          return "[Document]";
+        return "[File]";
+      }
     };
   }
 });
@@ -4962,7 +6764,7 @@ var init_matrix = __esm({
       botUserId;
       constructor(homeserverUrl, accessToken, botUserId) {
         super();
-        this.homeserverUrl = homeserverUrl;
+        this.homeserverUrl = homeserverUrl.replace(/\/+$/, "");
         this.accessToken = accessToken;
         this.botUserId = botUserId;
       }
@@ -4972,23 +6774,20 @@ var init_matrix = __esm({
         const storageProvider = new SimpleFsStorageProvider("./data/matrix-storage");
         this.client = new MatrixClient(this.homeserverUrl, this.accessToken, storageProvider);
         AutojoinRoomsMixin.setupOnClient(this.client);
-        this.client.on("room.message", (roomId, event) => {
+        this.client.on("room.message", async (roomId, event) => {
           if (event.sender === this.botUserId)
             return;
-          if (event.content?.msgtype !== "m.text")
+          const msgtype = event.content?.msgtype;
+          if (!msgtype)
             return;
-          const normalized = {
-            id: event.event_id,
-            platform: "matrix",
-            chatId: roomId,
-            chatType: "group",
-            userId: event.sender,
-            userName: event.sender.split(":")[0].slice(1),
-            text: event.content.body,
-            timestamp: new Date(event.origin_server_ts),
-            replyToMessageId: event.content["m.relates_to"]?.["m.in_reply_to"]?.event_id
-          };
-          this.emit("message", normalized);
+          try {
+            const message = await this.normalizeEvent(roomId, event, msgtype);
+            if (message) {
+              this.emit("message", message);
+            }
+          } catch (err) {
+            this.emit("error", err instanceof Error ? err : new Error(String(err)));
+          }
         });
         await this.client.start();
         this.status = "connected";
@@ -4999,27 +6798,177 @@ var init_matrix = __esm({
         this.status = "disconnected";
         this.emit("disconnected");
       }
-      async sendMessage(chatId, text, _options) {
+      async sendMessage(chatId, text, options) {
+        if (options?.parseMode === "html") {
+          const eventId2 = await this.client.sendEvent(chatId, "m.room.message", {
+            msgtype: "m.text",
+            body: text.replace(/<[^>]*>/g, ""),
+            format: "org.matrix.custom.html",
+            formatted_body: text
+          });
+          return eventId2;
+        }
         const eventId = await this.client.sendText(chatId, text);
         return eventId;
       }
-      async editMessage(chatId, messageId, text) {
-        await this.client.sendEvent(chatId, "m.room.message", {
+      async editMessage(chatId, messageId, text, options) {
+        const isHtml = options?.parseMode === "html";
+        const content = {
           "msgtype": "m.text",
-          "body": "* " + text,
+          "body": "* " + (isHtml ? text.replace(/<[^>]*>/g, "") : text),
           "m.new_content": {
             msgtype: "m.text",
-            body: text
+            body: isHtml ? text.replace(/<[^>]*>/g, "") : text,
+            ...isHtml ? { format: "org.matrix.custom.html", formatted_body: text } : {}
           },
           "m.relates_to": {
             rel_type: "m.replace",
             event_id: messageId
           }
-        });
+        };
+        await this.client.sendEvent(chatId, "m.room.message", content);
       }
       async deleteMessage(chatId, messageId) {
         await this.client.redactEvent(chatId, messageId);
       }
+      async sendPhoto(chatId, photo, caption) {
+        const mxcUrl = await this.client.uploadContent(photo, "image/png", "image.png");
+        const content = {
+          msgtype: "m.image",
+          body: caption ?? "image.png",
+          url: mxcUrl,
+          info: {
+            mimetype: "image/png",
+            size: photo.length
+          }
+        };
+        const eventId = await this.client.sendEvent(chatId, "m.room.message", content);
+        return eventId;
+      }
+      async sendFile(chatId, file, fileName, caption) {
+        const mimeType = this.guessMimeType(fileName);
+        const mxcUrl = await this.client.uploadContent(file, mimeType, fileName);
+        const content = {
+          msgtype: "m.file",
+          body: caption ?? fileName,
+          filename: fileName,
+          url: mxcUrl,
+          info: {
+            mimetype: mimeType,
+            size: file.length
+          }
+        };
+        const eventId = await this.client.sendEvent(chatId, "m.room.message", content);
+        return eventId;
+      }
+      // ── Private helpers ──────────────────────────────────────────────
+      async normalizeEvent(roomId, event, msgtype) {
+        const base = {
+          id: event.event_id,
+          platform: "matrix",
+          chatId: roomId,
+          chatType: "group",
+          userId: event.sender,
+          userName: event.sender.split(":")[0].slice(1),
+          timestamp: new Date(event.origin_server_ts),
+          replyToMessageId: event.content["m.relates_to"]?.["m.in_reply_to"]?.event_id
+        };
+        switch (msgtype) {
+          case "m.text":
+            return { ...base, text: event.content.body };
+          case "m.image": {
+            const attachment = await this.downloadAttachment(event.content, "image");
+            return {
+              ...base,
+              text: event.content.body ?? "[Photo]",
+              attachments: attachment ? [attachment] : void 0
+            };
+          }
+          case "m.audio": {
+            const attachment = await this.downloadAttachment(event.content, "audio");
+            return {
+              ...base,
+              text: event.content.body ?? "[Voice message]",
+              attachments: attachment ? [attachment] : void 0
+            };
+          }
+          case "m.video": {
+            const attachment = await this.downloadAttachment(event.content, "video");
+            return {
+              ...base,
+              text: event.content.body ?? "[Video]",
+              attachments: attachment ? [attachment] : void 0
+            };
+          }
+          case "m.file": {
+            const attachment = await this.downloadAttachment(event.content, "document");
+            return {
+              ...base,
+              text: event.content.body ?? "[Document]",
+              attachments: attachment ? [attachment] : void 0
+            };
+          }
+          default:
+            if (event.content.body) {
+              return { ...base, text: event.content.body };
+            }
+            return void 0;
+        }
+      }
+      /**
+       * Download a Matrix media file from an mxc:// URL.
+       * Uses the /_matrix/media/v3/download endpoint.
+       */
+      async downloadAttachment(content, type) {
+        const mxcUrl = content.url;
+        if (!mxcUrl || !mxcUrl.startsWith("mxc://"))
+          return void 0;
+        const info = content.info ?? {};
+        const mimeType = info.mimetype;
+        const size = info.size;
+        const fileName = content.filename ?? content.body ?? "file";
+        try {
+          const mxcParts = mxcUrl.slice(6);
+          const downloadUrl = `${this.homeserverUrl}/_matrix/media/v3/download/${mxcParts}`;
+          const res = await fetch(downloadUrl, {
+            headers: { Authorization: `Bearer ${this.accessToken}` }
+          });
+          if (!res.ok)
+            return void 0;
+          const arrayBuffer = await res.arrayBuffer();
+          const data = Buffer.from(arrayBuffer);
+          return {
+            type,
+            mimeType,
+            fileName,
+            size: size ?? data.length,
+            data
+          };
+        } catch {
+          return void 0;
+        }
+      }
+      guessMimeType(fileName) {
+        const ext = fileName.split(".").pop()?.toLowerCase();
+        const mimeMap = {
+          pdf: "application/pdf",
+          txt: "text/plain",
+          json: "application/json",
+          csv: "text/csv",
+          png: "image/png",
+          jpg: "image/jpeg",
+          jpeg: "image/jpeg",
+          gif: "image/gif",
+          mp3: "audio/mpeg",
+          ogg: "audio/ogg",
+          mp4: "video/mp4",
+          zip: "application/zip",
+          doc: "application/msword",
+          docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+          xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        };
+        return mimeMap[ext ?? ""] ?? "application/octet-stream";
+      }
     };
   }
 });
@@ -5033,6 +6982,7 @@ var init_whatsapp = __esm({
     WhatsAppAdapter = class extends MessagingAdapter {
       platform = "whatsapp";
       socket;
+      downloadMedia;
       dataPath;
       constructor(dataPath) {
         super();
@@ -5041,7 +6991,9 @@ var init_whatsapp = __esm({
       async connect() {
         this.status = "connecting";
         const baileys = await import("@whiskeysockets/baileys");
-        const { makeWASocket, useMultiFileAuthState, DisconnectReason } = baileys.default ?? baileys;
+        const mod = baileys.default ?? baileys;
+        const { makeWASocket, useMultiFileAuthState, DisconnectReason, downloadMediaMessage } = mod;
+        this.downloadMedia = downloadMediaMessage;
         const { state, saveCreds } = await useMultiFileAuthState(this.dataPath);
         this.socket = makeWASocket({
           auth: state,
@@ -5071,21 +7023,9 @@ var init_whatsapp = __esm({
               continue;
             if (message.key.fromMe)
               continue;
-            const text = message.message.conversation ?? message.message.extendedTextMessage?.text;
-            if (!text)
-              continue;
-            const normalized = {
-              id: message.key.id ?? "",
-              platform: "whatsapp",
-              chatId: message.key.remoteJid ?? "",
-              chatType: message.key.remoteJid?.endsWith("@g.us") ? "group" : "dm",
-              userId: message.key.participant ?? message.key.remoteJid ?? "",
-              userName: message.pushName ?? message.key.participant ?? message.key.remoteJid ?? "",
-              text,
-              timestamp: new Date(message.messageTimestamp * 1e3),
-              replyToMessageId: message.message.extendedTextMessage?.contextInfo?.stanzaId ?? void 0
-            };
-            this.emit("message", normalized);
+            this.processMessage(message).catch((err) => {
+              this.emit("error", err instanceof Error ? err : new Error(String(err)));
+            });
           }
         });
       }
@@ -5104,7 +7044,7 @@ var init_whatsapp = __esm({
         } : void 0);
         return msg?.key?.id ?? "";
       }
-      async editMessage(chatId, messageId, text) {
+      async editMessage(chatId, messageId, text, _options) {
         await this.socket.sendMessage(chatId, {
           text,
           edit: {
@@ -5123,6 +7063,128 @@ var init_whatsapp = __esm({
           }
         });
       }
+      async sendPhoto(chatId, photo, caption) {
+        const msg = await this.socket.sendMessage(chatId, {
+          image: photo,
+          caption
+        });
+        return msg?.key?.id;
+      }
+      async sendFile(chatId, file, fileName, caption) {
+        const msg = await this.socket.sendMessage(chatId, {
+          document: file,
+          fileName,
+          caption,
+          mimetype: this.guessMimeType(fileName)
+        });
+        return msg?.key?.id;
+      }
+      // ── Private helpers ──────────────────────────────────────────────
+      async processMessage(message) {
+        const msg = message.message;
+        const text = msg.conversation ?? msg.extendedTextMessage?.text ?? msg.imageMessage?.caption ?? msg.videoMessage?.caption ?? msg.documentMessage?.caption ?? "";
+        const attachments = [];
+        let fallbackText = text;
+        if (msg.imageMessage) {
+          const data = await this.downloadMediaSafe(message);
+          if (data) {
+            attachments.push({
+              type: "image",
+              mimeType: msg.imageMessage.mimetype ?? "image/jpeg",
+              size: msg.imageMessage.fileLength ?? data.length,
+              data
+            });
+          }
+          if (!fallbackText)
+            fallbackText = "[Photo]";
+        } else if (msg.audioMessage) {
+          const data = await this.downloadMediaSafe(message);
+          if (data) {
+            attachments.push({
+              type: "audio",
+              mimeType: msg.audioMessage.mimetype ?? "audio/ogg",
+              size: msg.audioMessage.fileLength ?? data.length,
+              data
+            });
+          }
+          if (!fallbackText)
+            fallbackText = "[Voice message]";
+        } else if (msg.videoMessage) {
+          const data = await this.downloadMediaSafe(message);
+          if (data) {
+            attachments.push({
+              type: "video",
+              mimeType: msg.videoMessage.mimetype ?? "video/mp4",
+              size: msg.videoMessage.fileLength ?? data.length,
+              data
+            });
+          }
+          if (!fallbackText)
+            fallbackText = "[Video]";
+        } else if (msg.documentMessage) {
+          const data = await this.downloadMediaSafe(message);
+          if (data) {
+            attachments.push({
+              type: "document",
+              mimeType: msg.documentMessage.mimetype ?? "application/octet-stream",
+              fileName: msg.documentMessage.fileName ?? "document",
+              size: msg.documentMessage.fileLength ?? data.length,
+              data
+            });
+          }
+          if (!fallbackText)
+            fallbackText = "[Document]";
+        } else if (msg.stickerMessage) {
+          if (!text)
+            return;
+        }
+        if (!fallbackText && attachments.length === 0)
+          return;
+        const normalized = {
+          id: message.key.id ?? "",
+          platform: "whatsapp",
+          chatId: message.key.remoteJid ?? "",
+          chatType: message.key.remoteJid?.endsWith("@g.us") ? "group" : "dm",
+          userId: message.key.participant ?? message.key.remoteJid ?? "",
+          userName: message.pushName ?? message.key.participant ?? message.key.remoteJid ?? "",
+          text: fallbackText,
+          timestamp: new Date(message.messageTimestamp * 1e3),
+          replyToMessageId: msg.extendedTextMessage?.contextInfo?.stanzaId ?? void 0,
+          attachments: attachments.length > 0 ? attachments : void 0
+        };
+        this.emit("message", normalized);
+      }
+      async downloadMediaSafe(message) {
+        try {
+          if (!this.downloadMedia)
+            return void 0;
+          const buffer = await this.downloadMedia(message, "buffer", {});
+          return Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
+        } catch {
+          return void 0;
+        }
+      }
+      guessMimeType(fileName) {
+        const ext = fileName.split(".").pop()?.toLowerCase();
+        const mimeMap = {
+          pdf: "application/pdf",
+          txt: "text/plain",
+          json: "application/json",
+          csv: "text/csv",
+          png: "image/png",
+          jpg: "image/jpeg",
+          jpeg: "image/jpeg",
+          gif: "image/gif",
+          mp3: "audio/mpeg",
+          ogg: "audio/ogg",
+          mp4: "video/mp4",
+          zip: "application/zip",
+          doc: "application/msword",
+          docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+          xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        };
+        return mimeMap[ext ?? ""] ?? "application/octet-stream";
+      }
     };
   }
 });
@@ -5192,7 +7254,7 @@ var init_signal = __esm({
         const result = await res.json();
         return String(result.timestamp ?? Date.now());
       }
-      async editMessage(_chatId, _messageId, _text) {
+      async editMessage(_chatId, _messageId, _text, _options) {
         throw new Error("Signal does not support message editing");
       }
       async deleteMessage(chatId, messageId) {
@@ -5217,10 +7279,24 @@ var init_signal = __esm({
         const messages = await res.json();
         for (const envelope of messages) {
           const dataMessage = envelope.envelope?.dataMessage;
-          if (!dataMessage?.message)
+          if (!dataMessage)
+            continue;
+          if (!dataMessage.message && (!dataMessage.attachments || dataMessage.attachments.length === 0))
             continue;
           const data = envelope.envelope;
           const chatId = dataMessage.groupInfo?.groupId ? `group.${dataMessage.groupInfo.groupId}` : data.sourceNumber ?? data.source ?? "";
+          const attachments = [];
+          if (dataMessage.attachments) {
+            for (const att of dataMessage.attachments) {
+              const downloaded = await this.downloadAttachment(att);
+              if (downloaded) {
+                attachments.push(downloaded);
+              }
+            }
+          }
+          const text = dataMessage.message || this.inferTextFromAttachments(attachments) || "";
+          if (!text && attachments.length === 0)
+            continue;
           const normalized = {
             id: String(dataMessage.timestamp ?? Date.now()),
             platform: "signal",
@@ -5229,12 +7305,59 @@ var init_signal = __esm({
             userId: data.sourceNumber ?? data.source ?? "",
             userName: data.sourceName ?? data.sourceNumber ?? data.source ?? "",
             displayName: data.sourceName,
-            text: dataMessage.message,
-            timestamp: new Date(dataMessage.timestamp ?? Date.now())
+            text,
+            timestamp: new Date(dataMessage.timestamp ?? Date.now()),
+            attachments: attachments.length > 0 ? attachments : void 0
           };
           this.emit("message", normalized);
         }
       }
+      async downloadAttachment(att) {
+        if (!att.id)
+          return void 0;
+        try {
+          const res = await fetch(`${this.apiUrl}/v1/attachments/${att.id}`);
+          if (!res.ok)
+            return void 0;
+          const arrayBuffer = await res.arrayBuffer();
+          const data = Buffer.from(arrayBuffer);
+          const type = this.classifyContentType(att.contentType);
+          return {
+            type,
+            mimeType: att.contentType ?? void 0,
+            fileName: att.filename ?? void 0,
+            size: att.size ?? data.length,
+            data
+          };
+        } catch {
+          return void 0;
+        }
+      }
+      classifyContentType(contentType) {
+        if (!contentType)
+          return "other";
+        if (contentType.startsWith("image/"))
+          return "image";
+        if (contentType.startsWith("audio/"))
+          return "audio";
+        if (contentType.startsWith("video/"))
+          return "video";
+        return "document";
+      }
+      inferTextFromAttachments(attachments) {
+        if (attachments.length === 0)
+          return "";
+        const types = attachments.map((a) => a.type);
+        if (types.includes("image"))
+          return "[Photo]";
+        if (types.includes("audio"))
+          return "[Voice message]";
+        if (types.includes("video"))
+          return "[Video]";
+        if (types.includes("document"))
+          return "[Document]";
+        return "[File]";
+      }
     };
   }
 });
@@ -5262,8 +7385,8 @@ var init_dist7 = __esm({
 });
 
 // ../core/dist/alfred.js
-import fs5 from "node:fs";
-import path7 from "node:path";
+import fs6 from "node:fs";
+import path8 from "node:path";
 import yaml2 from "js-yaml";
 var Alfred;
 var init_alfred = __esm({
@@ -5277,6 +7400,9 @@ var init_alfred = __esm({
     init_conversation_manager();
     init_message_pipeline();
     init_reminder_scheduler();
+    init_speech_transcriber();
+    init_response_formatter();
+    init_embedding_service();
     Alfred = class {
       config;
       logger;
@@ -5284,6 +7410,9 @@ var init_alfred = __esm({
       pipeline;
       reminderScheduler;
       adapters = /* @__PURE__ */ new Map();
+      formatter = new ResponseFormatter();
+      calendarSkill;
+      // CalendarSkill instance for today's events
       constructor(config) {
         this.config = config;
         this.logger = createLogger("alfred", config.logger.level);
@@ -5298,6 +7427,7 @@ var init_alfred = __esm({
         const memoryRepo = new MemoryRepository(db);
         const reminderRepo = new ReminderRepository(db);
         const noteRepo = new NoteRepository(db);
+        const embeddingRepo = new EmbeddingRepository(db);
         this.logger.info("Storage initialized");
         const ruleEngine = new RuleEngine();
         const rules = this.loadSecurityRules();
@@ -5307,6 +7437,7 @@ var init_alfred = __esm({
         const llmProvider = createLLMProvider(this.config.llm);
         await llmProvider.initialize();
         this.logger.info({ provider: this.config.llm.provider, model: this.config.llm.model }, "LLM provider initialized");
+        const embeddingService = new EmbeddingService(llmProvider, embeddingRepo, this.logger.child({ component: "embeddings" }));
         const skillSandbox = new SkillSandbox(this.logger.child({ component: "sandbox" }));
         const skillRegistry = new SkillRegistry();
         skillRegistry.register(new CalculatorSkill());
@@ -5320,7 +7451,7 @@ var init_alfred = __esm({
         skillRegistry.register(new NoteSkill(noteRepo));
         skillRegistry.register(new WeatherSkill());
         skillRegistry.register(new ShellSkill());
-        skillRegistry.register(new MemorySkill(memoryRepo));
+        skillRegistry.register(new MemorySkill(memoryRepo, embeddingService));
         skillRegistry.register(new DelegateSkill(llmProvider, skillRegistry, skillSandbox, securityManager));
         skillRegistry.register(new EmailSkill(this.config.email ? {
           imap: this.config.email.imap,
@@ -5332,9 +7463,40 @@ var init_alfred = __esm({
         skillRegistry.register(new ClipboardSkill());
         skillRegistry.register(new ScreenshotSkill());
         skillRegistry.register(new BrowserSkill());
+        skillRegistry.register(new ProfileSkill(userRepo));
+        let calendarSkill;
+        if (this.config.calendar) {
+          try {
+            const calendarProvider = await createCalendarProvider(this.config.calendar);
+            calendarSkill = new CalendarSkill(calendarProvider);
+            skillRegistry.register(calendarSkill);
+            this.logger.info({ provider: this.config.calendar.provider }, "Calendar initialized");
+          } catch (err) {
+            this.logger.warn({ err }, "Calendar initialization failed, continuing without calendar");
+          }
+        }
+        this.calendarSkill = calendarSkill;
         this.logger.info({ skills: skillRegistry.getAll().map((s) => s.metadata.name) }, "Skills registered");
+        let speechTranscriber;
+        if (this.config.speech?.apiKey) {
+          speechTranscriber = new SpeechTranscriber(this.config.speech, this.logger.child({ component: "speech" }));
+          this.logger.info({ provider: this.config.speech.provider }, "Speech-to-text initialized");
+        }
         const conversationManager = new ConversationManager(conversationRepo);
-        this.pipeline = new MessagePipeline(llmProvider, conversationManager, userRepo, this.logger.child({ component: "pipeline" }), skillRegistry, skillSandbox, securityManager, memoryRepo);
+        const inboxPath = path8.resolve(path8.dirname(this.config.storage.path), "inbox");
+        this.pipeline = new MessagePipeline({
+          llm: llmProvider,
+          conversationManager,
+          users: userRepo,
+          logger: this.logger.child({ component: "pipeline" }),
+          skillRegistry,
+          skillSandbox,
+          securityManager,
+          memoryRepo,
+          speechTranscriber,
+          inboxPath,
+          embeddingService
+        });
         this.reminderScheduler = new ReminderScheduler(reminderRepo, async (platform, chatId, text) => {
           const adapter = this.adapters.get(platform);
           if (adapter) {
@@ -5420,14 +7582,16 @@ var init_alfred = __esm({
               }
             };
             const response = await this.pipeline.process(message, onProgress);
+            const formatted = this.formatter.format(response, message.platform);
+            const sendOpts = formatted.parseMode !== "text" ? { parseMode: formatted.parseMode } : void 0;
             if (statusMessageId) {
               try {
-                await adapter.editMessage(message.chatId, statusMessageId, response);
+                await adapter.editMessage(message.chatId, statusMessageId, formatted.text, sendOpts);
               } catch {
-                await adapter.sendMessage(message.chatId, response);
+                await adapter.sendMessage(message.chatId, formatted.text, sendOpts);
               }
             } else {
-              await adapter.sendMessage(message.chatId, response);
+              await adapter.sendMessage(message.chatId, formatted.text, sendOpts);
             }
           } catch (error) {
             this.logger.error({ platform, err: error, chatId: message.chatId }, "Failed to handle message");
@@ -5449,22 +7613,22 @@ var init_alfred = __esm({
         });
       }
       loadSecurityRules() {
-        const rulesPath = path7.resolve(this.config.security.rulesPath);
+        const rulesPath = path8.resolve(this.config.security.rulesPath);
         const rules = [];
-        if (!fs5.existsSync(rulesPath)) {
+        if (!fs6.existsSync(rulesPath)) {
           this.logger.warn({ rulesPath }, "Security rules directory not found, using default deny");
           return rules;
         }
-        const stat = fs5.statSync(rulesPath);
+        const stat = fs6.statSync(rulesPath);
         if (!stat.isDirectory()) {
           this.logger.warn({ rulesPath }, "Security rules path is not a directory");
           return rules;
         }
-        const files = fs5.readdirSync(rulesPath).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+        const files = fs6.readdirSync(rulesPath).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
         for (const file of files) {
           try {
-            const filePath = path7.join(rulesPath, file);
-            const content = fs5.readFileSync(filePath, "utf-8");
+            const filePath = path8.join(rulesPath, file);
+            const content = fs6.readFileSync(filePath, "utf-8");
             const parsed = yaml2.load(content);
             if (parsed?.rules && Array.isArray(parsed.rules)) {
               rules.push(...parsed.rules);
@@ -5488,6 +7652,9 @@ var init_dist8 = __esm({
     init_message_pipeline();
     init_conversation_manager();
     init_reminder_scheduler();
+    init_speech_transcriber();
+    init_response_formatter();
+    init_embedding_service();
   }
 });
 
@@ -5558,8 +7725,8 @@ __export(setup_exports, {
 });
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
-import fs6 from "node:fs";
-import path8 from "node:path";
+import fs7 from "node:fs";
+import path9 from "node:path";
 import yaml3 from "js-yaml";
 function green(s) {
   return `${GREEN}${s}${RESET}`;
@@ -5590,20 +7757,20 @@ function loadExistingConfig(projectRoot) {
   let shellEnabled = false;
   let writeInGroups = false;
   let rateLimit = 30;
-  const configPath = path8.join(projectRoot, "config", "default.yml");
-  if (fs6.existsSync(configPath)) {
+  const configPath = path9.join(projectRoot, "config", "default.yml");
+  if (fs7.existsSync(configPath)) {
     try {
-      const parsed = yaml3.load(fs6.readFileSync(configPath, "utf-8"));
+      const parsed = yaml3.load(fs7.readFileSync(configPath, "utf-8"));
       if (parsed && typeof parsed === "object") {
         Object.assign(config, parsed);
       }
     } catch {
     }
   }
-  const envPath = path8.join(projectRoot, ".env");
-  if (fs6.existsSync(envPath)) {
+  const envPath = path9.join(projectRoot, ".env");
+  if (fs7.existsSync(envPath)) {
     try {
-      const lines = fs6.readFileSync(envPath, "utf-8").split("\n");
+      const lines = fs7.readFileSync(envPath, "utf-8").split("\n");
       for (const line of lines) {
         const trimmed = line.trim();
         if (!trimmed || trimmed.startsWith("#"))
@@ -5616,10 +7783,10 @@ function loadExistingConfig(projectRoot) {
     } catch {
     }
   }
-  const rulesPath = path8.join(projectRoot, "config", "rules", "default-rules.yml");
-  if (fs6.existsSync(rulesPath)) {
+  const rulesPath = path9.join(projectRoot, "config", "rules", "default-rules.yml");
+  if (fs7.existsSync(rulesPath)) {
     try {
-      const rulesContent = yaml3.load(fs6.readFileSync(rulesPath, "utf-8"));
+      const rulesContent = yaml3.load(fs7.readFileSync(rulesPath, "utf-8"));
       if (rulesContent?.rules) {
         shellEnabled = rulesContent.rules.some((r) => r.id === "allow-owner-admin" && r.effect === "allow");
         const writeDmRule = rulesContent.rules.find((r) => r.id === "allow-write-for-dm" || r.id === "allow-write-all");
@@ -5875,6 +8042,54 @@ ${bold("Email access (read & send emails via IMAP/SMTP)?")}`);
     } else {
       console.log(`  ${dim("Email disabled \u2014 you can configure it later.")}`);
     }
+    const speechProviders = ["openai", "groq"];
+    const existingSpeechProvider = existing.config.speech?.provider ?? existing.env["ALFRED_SPEECH_PROVIDER"] ?? "";
+    const existingSpeechIdx = speechProviders.indexOf(existingSpeechProvider);
+    const defaultSpeechChoice = existingSpeechIdx >= 0 ? existingSpeechIdx + 1 : 0;
+    console.log(`
+${bold("Voice message transcription (Speech-to-Text via Whisper)?")}`);
+    console.log(`${dim("Transcribes voice messages from Telegram, Discord, etc.")}`);
+    const speechLabels = [
+      "OpenAI Whisper \u2014 best quality",
+      "Groq Whisper \u2014 fast & free"
+    ];
+    console.log(`  ${cyan("0)")} None (disable voice transcription)${existingSpeechIdx === -1 ? ` ${dim("(current)")}` : ""}`);
+    for (let i = 0; i < speechLabels.length; i++) {
+      const cur = existingSpeechIdx === i ? ` ${dim("(current)")}` : "";
+      console.log(`  ${cyan(String(i + 1) + ")")} ${speechLabels[i]}${cur}`);
+    }
+    const speechChoice = await askNumber(rl, "> ", 0, speechProviders.length, defaultSpeechChoice);
+    let speechProvider;
+    let speechApiKey = "";
+    let speechBaseUrl = "";
+    if (speechChoice >= 1 && speechChoice <= speechProviders.length) {
+      speechProvider = speechProviders[speechChoice - 1];
+    }
+    if (speechProvider === "openai") {
+      const existingKey = existing.env["ALFRED_SPEECH_API_KEY"] ?? "";
+      if (existingKey) {
+        speechApiKey = await askWithDefault(rl, "  OpenAI API key (for Whisper)", existingKey);
+      } else {
+        console.log(`  ${dim("Uses your OpenAI API key for Whisper transcription.")}`);
+        speechApiKey = await askRequired(rl, "  OpenAI API key");
+      }
+      console.log(`  ${green(">")} OpenAI Whisper: ${dim(maskKey(speechApiKey))}`);
+    } else if (speechProvider === "groq") {
+      const existingKey = existing.env["ALFRED_SPEECH_API_KEY"] ?? "";
+      if (existingKey) {
+        speechApiKey = await askWithDefault(rl, "  Groq API key", existingKey);
+      } else {
+        console.log(`  ${dim("Get your free API key at: https://console.groq.com/")}`);
+        speechApiKey = await askRequired(rl, "  Groq API key");
+      }
+      const existingUrl = existing.env["ALFRED_SPEECH_BASE_URL"] ?? "";
+      if (existingUrl) {
+        speechBaseUrl = await askWithDefault(rl, "  Groq API URL", existingUrl);
+      }
+      console.log(`  ${green(">")} Groq Whisper: ${dim(maskKey(speechApiKey))}`);
+    } else {
+      console.log(`  ${dim("Voice transcription disabled \u2014 you can configure it later.")}`);
+    }
     console.log(`
 ${bold("Security configuration:")}`);
     const existingOwnerId = existing.config.security?.ownerUserId ?? existing.env["ALFRED_OWNER_USER_ID"] ?? "";
@@ -5970,6 +8185,17 @@ ${bold("Writing configuration files...")}`);
       envLines.push("# ALFRED_EMAIL_USER=");
       envLines.push("# ALFRED_EMAIL_PASS=");
     }
+    envLines.push("", "# === Speech-to-Text ===", "");
+    if (speechProvider) {
+      envLines.push(`ALFRED_SPEECH_PROVIDER=${speechProvider}`);
+      envLines.push(`ALFRED_SPEECH_API_KEY=${speechApiKey}`);
+      if (speechBaseUrl) {
+        envLines.push(`ALFRED_SPEECH_BASE_URL=${speechBaseUrl}`);
+      }
+    } else {
+      envLines.push("# ALFRED_SPEECH_PROVIDER=groq");
+      envLines.push("# ALFRED_SPEECH_API_KEY=");
+    }
     envLines.push("", "# === Security ===", "");
     if (ownerUserId) {
       envLines.push(`ALFRED_OWNER_USER_ID=${ownerUserId}`);
@@ -5977,12 +8203,12 @@ ${bold("Writing configuration files...")}`);
       envLines.push("# ALFRED_OWNER_USER_ID=");
     }
     envLines.push("");
-    const envPath = path8.join(projectRoot, ".env");
-    fs6.writeFileSync(envPath, envLines.join("\n"), "utf-8");
+    const envPath = path9.join(projectRoot, ".env");
+    fs7.writeFileSync(envPath, envLines.join("\n"), "utf-8");
     console.log(`  ${green("+")} ${dim(".env")} written`);
-    const configDir = path8.join(projectRoot, "config");
-    if (!fs6.existsSync(configDir)) {
-      fs6.mkdirSync(configDir, { recursive: true });
+    const configDir = path9.join(projectRoot, "config");
+    if (!fs7.existsSync(configDir)) {
+      fs7.mkdirSync(configDir, { recursive: true });
     }
     const config = {
       name: botName,
@@ -6030,6 +8256,13 @@ ${bold("Writing configuration files...")}`);
           auth: { user: emailUser, pass: emailPass }
         }
       } : {},
+      ...speechProvider ? {
+        speech: {
+          provider: speechProvider,
+          apiKey: speechApiKey,
+          ...speechBaseUrl ? { baseUrl: speechBaseUrl } : {}
+        }
+      } : {},
       storage: {
         path: "./data/alfred.db"
       },
@@ -6047,12 +8280,12 @@ ${bold("Writing configuration files...")}`);
       config.security.ownerUserId = ownerUserId;
     }
     const yamlStr = "# Alfred \u2014 Configuration\n# Generated by `alfred setup`\n# Edit manually or re-run `alfred setup` to reconfigure.\n\n" + yaml3.dump(config, { lineWidth: 120, noRefs: true, sortKeys: false });
-    const configPath = path8.join(configDir, "default.yml");
-    fs6.writeFileSync(configPath, yamlStr, "utf-8");
+    const configPath = path9.join(configDir, "default.yml");
+    fs7.writeFileSync(configPath, yamlStr, "utf-8");
     console.log(`  ${green("+")} ${dim("config/default.yml")} written`);
-    const rulesDir = path8.join(configDir, "rules");
-    if (!fs6.existsSync(rulesDir)) {
-      fs6.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path9.join(configDir, "rules");
+    if (!fs7.existsSync(rulesDir)) {
+      fs7.mkdirSync(rulesDir, { recursive: true });
     }
     const ownerAdminRule = enableShell && ownerUserId ? `
   # Allow admin actions (shell, etc.) for the owner only
@@ -6133,12 +8366,12 @@ ${ownerAdminRule}
     actions: ["*"]
     riskLevels: [read, write, destructive, admin]
 `;
-    const rulesPath = path8.join(rulesDir, "default-rules.yml");
-    fs6.writeFileSync(rulesPath, rulesYaml, "utf-8");
+    const rulesPath = path9.join(rulesDir, "default-rules.yml");
+    fs7.writeFileSync(rulesPath, rulesYaml, "utf-8");
     console.log(`  ${green("+")} ${dim("config/rules/default-rules.yml")} written`);
-    const dataDir = path8.join(projectRoot, "data");
-    if (!fs6.existsSync(dataDir)) {
-      fs6.mkdirSync(dataDir, { recursive: true });
+    const dataDir = path9.join(projectRoot, "data");
+    if (!fs7.existsSync(dataDir)) {
+      fs7.mkdirSync(dataDir, { recursive: true });
       console.log(`  ${green("+")} ${dim("data/")} directory created`);
     }
     console.log("");
@@ -6172,6 +8405,15 @@ ${ownerAdminRule}
     } else {
       console.log(`  ${bold("Email:")}          ${dim("disabled")}`);
     }
+    if (speechProvider) {
+      const speechLabelMap = {
+        openai: "OpenAI Whisper",
+        groq: "Groq Whisper"
+      };
+      console.log(`  ${bold("Voice:")}          ${speechLabelMap[speechProvider]}`);
+    } else {
+      console.log(`  ${bold("Voice:")}          ${dim("disabled")}`);
+    }
     if (ownerUserId) {
       console.log(`  ${bold("Owner ID:")}       ${ownerUserId}`);
       console.log(`  ${bold("Shell access:")}   ${enableShell ? green("enabled") : dim("disabled")}`);
@@ -6411,8 +8653,8 @@ var rules_exports = {};
 __export(rules_exports, {
   rulesCommand: () => rulesCommand
 });
-import fs7 from "node:fs";
-import path9 from "node:path";
+import fs8 from "node:fs";
+import path10 from "node:path";
 import yaml4 from "js-yaml";
 async function rulesCommand() {
   const configLoader = new ConfigLoader();
@@ -6423,18 +8665,18 @@ async function rulesCommand() {
     console.error("Failed to load configuration:", error.message);
     process.exit(1);
   }
-  const rulesPath = path9.resolve(config.security.rulesPath);
-  if (!fs7.existsSync(rulesPath)) {
+  const rulesPath = path10.resolve(config.security.rulesPath);
+  if (!fs8.existsSync(rulesPath)) {
     console.log(`Rules directory not found: ${rulesPath}`);
     console.log("No security rules loaded.");
     return;
   }
-  const stat = fs7.statSync(rulesPath);
+  const stat = fs8.statSync(rulesPath);
   if (!stat.isDirectory()) {
     console.error(`Rules path is not a directory: ${rulesPath}`);
     process.exit(1);
   }
-  const files = fs7.readdirSync(rulesPath).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+  const files = fs8.readdirSync(rulesPath).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
   if (files.length === 0) {
     console.log(`No YAML rule files found in: ${rulesPath}`);
     return;
@@ -6443,9 +8685,9 @@ async function rulesCommand() {
   const allRules = [];
   const errors = [];
   for (const file of files) {
-    const filePath = path9.join(rulesPath, file);
+    const filePath = path10.join(rulesPath, file);
     try {
-      const raw = fs7.readFileSync(filePath, "utf-8");
+      const raw = fs8.readFileSync(filePath, "utf-8");
       const parsed = yaml4.load(raw);
       const rules = ruleLoader.loadFromObject(parsed);
       allRules.push(...rules);
@@ -6497,8 +8739,8 @@ var status_exports = {};
 __export(status_exports, {
   statusCommand: () => statusCommand
 });
-import fs8 from "node:fs";
-import path10 from "node:path";
+import fs9 from "node:fs";
+import path11 from "node:path";
 import yaml5 from "js-yaml";
 async function statusCommand() {
   const configLoader = new ConfigLoader();
@@ -6555,22 +8797,22 @@ async function statusCommand() {
   }
   console.log("");
   console.log("Storage:");
-  const dbPath = path10.resolve(config.storage.path);
-  const dbExists = fs8.existsSync(dbPath);
+  const dbPath = path11.resolve(config.storage.path);
+  const dbExists = fs9.existsSync(dbPath);
   console.log(`  Database: ${dbPath}`);
   console.log(`  Status:   ${dbExists ? "exists" : "not yet created"}`);
   console.log("");
-  const rulesPath = path10.resolve(config.security.rulesPath);
+  const rulesPath = path11.resolve(config.security.rulesPath);
   let ruleCount = 0;
   let ruleFileCount = 0;
-  if (fs8.existsSync(rulesPath) && fs8.statSync(rulesPath).isDirectory()) {
-    const files = fs8.readdirSync(rulesPath).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+  if (fs9.existsSync(rulesPath) && fs9.statSync(rulesPath).isDirectory()) {
+    const files = fs9.readdirSync(rulesPath).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
     ruleFileCount = files.length;
     const ruleLoader = new RuleLoader();
     for (const file of files) {
-      const filePath = path10.join(rulesPath, file);
+      const filePath = path11.join(rulesPath, file);
       try {
-        const raw = fs8.readFileSync(filePath, "utf-8");
+        const raw = fs9.readFileSync(filePath, "utf-8");
         const parsed = yaml5.load(raw);
         const rules = ruleLoader.loadFromObject(parsed);
         ruleCount += rules.length;
@@ -6604,8 +8846,8 @@ var logs_exports = {};
 __export(logs_exports, {
   logsCommand: () => logsCommand
 });
-import fs9 from "node:fs";
-import path11 from "node:path";
+import fs10 from "node:fs";
+import path12 from "node:path";
 async function logsCommand(tail) {
   const configLoader = new ConfigLoader();
   let config;
@@ -6615,8 +8857,8 @@ async function logsCommand(tail) {
     console.error("Failed to load configuration:", error.message);
     process.exit(1);
   }
-  const dbPath = path11.resolve(config.storage.path);
-  if (!fs9.existsSync(dbPath)) {
+  const dbPath = path12.resolve(config.storage.path);
+  if (!fs10.existsSync(dbPath)) {
     console.log(`Database not found at: ${dbPath}`);
     console.log("No audit log entries. Alfred has not been run yet, or the database path is incorrect.");
     return;