@knowsuchagency/fulcrum 3.2.1 → 3.4.0

package/server/index.js

@@ -4611,6 +4611,7 @@ var init_schema = __esm(() => {
     isFavorite: integer("is_favorite", { mode: "boolean" }).default(false),
     messageCount: integer("message_count").default(0),
     lastMessageAt: text("last_message_at"),
+    claudeSessionId: text("claude_session_id"),
     createdAt: text("created_at").notNull(),
     updatedAt: text("updated_at").notNull()
   });
@@ -296775,13 +296776,26 @@ var require_dist18 = __commonJS((exports) => {
 });
 
 // server/services/channels/slack-channel.ts
-var import_bolt, SlackChannel;
+import { readFileSync as readFileSync7 } from "fs";
+import { basename as basename2 } from "path";
+var import_bolt, SUPPORTED_MIME_TYPES, MAX_FILE_SIZE, SlackChannel;
 var init_slack_channel = __esm(() => {
   init_drizzle_orm();
   init_db2();
   init_logger3();
   init_settings();
   import_bolt = __toESM(require_dist18(), 1);
+  SUPPORTED_MIME_TYPES = new Set([
+    "image/png",
+    "image/jpeg",
+    "image/gif",
+    "image/webp",
+    "application/pdf",
+    "text/plain",
+    "text/csv",
+    "text/markdown"
+  ]);
+  MAX_FILE_SIZE = 10 * 1024 * 1024;
   SlackChannel = class SlackChannel {
     type = "slack";
     connectionId;
@@ -296925,8 +296939,9 @@ var init_slack_channel = __esm(() => {
     async handleMessage(message) {
       if (message.bot_id || message.subtype === "bot_message")
         return;
-      const content = message.text;
-      if (!content)
+      const content = message.text || "";
+      const files = message.files;
+      if (!content && (!files || files.length === 0))
         return;
       const userId = message.user;
       if (!userId)
@@ -296938,18 +296953,31 @@ var init_slack_channel = __esm(() => {
           senderName = userInfo.user?.real_name || userInfo.user?.name;
         }
       } catch {}
+      let attachments;
+      if (files && files.length > 0) {
+        const downloaded = await this.downloadSlackFiles(files);
+        if (downloaded.length > 0) {
+          attachments = downloaded;
+        }
+      }
       const incomingMessage = {
         channelType: "slack",
         connectionId: this.connectionId,
         senderId: userId,
         senderName,
         content,
-        timestamp: new Date(parseFloat(message.ts) * 1000)
+        attachments,
+        timestamp: new Date(parseFloat(message.ts) * 1000),
+        metadata: files?.length ? {
+          files: files.map((f) => ({ name: f.name, type: f.mimetype, size: f.size }))
+        } : undefined
       };
       log2.messaging.info("Slack message received", {
         connectionId: this.connectionId,
         from: userId,
-        contentLength: content.length
+        contentLength: content.length,
+        fileCount: files?.length ?? 0,
+        attachmentCount: attachments?.length ?? 0
       });
       try {
         await this.events?.onMessage(incomingMessage);
@@ -296960,6 +296988,110 @@ var init_slack_channel = __esm(() => {
         });
       }
     }
+    async downloadSlackFiles(files) {
+      const results = [];
+      for (const file of files) {
+        try {
+          const attachment = await this.downloadSlackFile(file);
+          if (attachment) {
+            results.push(attachment);
+          }
+        } catch (err) {
+          log2.messaging.warn("Failed to download Slack file", {
+            connectionId: this.connectionId,
+            fileName: file.name,
+            error: String(err)
+          });
+        }
+      }
+      return results;
+    }
+    async downloadSlackFile(file) {
+      if (!file.url_private_download) {
+        log2.messaging.warn("Slack file has no download URL", {
+          fileName: file.name,
+          fileId: file.id
+        });
+        return null;
+      }
+      if (file.size > MAX_FILE_SIZE) {
+        log2.messaging.warn("Slack file too large, skipping", {
+          fileName: file.name,
+          size: file.size,
+          maxSize: MAX_FILE_SIZE
+        });
+        return null;
+      }
+      if (!SUPPORTED_MIME_TYPES.has(file.mimetype)) {
+        log2.messaging.warn("Unsupported Slack file type, skipping", {
+          fileName: file.name,
+          mimeType: file.mimetype
+        });
+        return null;
+      }
+      let response = await fetch(file.url_private_download, {
+        headers: {
+          Authorization: `Bearer ${this.botToken}`
+        },
+        redirect: "manual"
+      });
+      if (response.status >= 300 && response.status < 400) {
+        const location = response.headers.get("location");
+        if (location) {
+          response = await fetch(location);
+        }
+      }
+      if (!response.ok) {
+        log2.messaging.warn("Failed to download Slack file", {
+          fileName: file.name,
+          status: response.status
+        });
+        return null;
+      }
+      const contentType = response.headers.get("content-type")?.split(";")[0]?.trim();
+      if (contentType && contentType !== file.mimetype) {
+        log2.messaging.warn("Slack file content-type mismatch", {
+          fileName: file.name,
+          expected: file.mimetype,
+          actual: contentType
+        });
+      }
+      const isText = file.mimetype.startsWith("text/");
+      const type = file.mimetype.startsWith("image/") ? "image" : isText ? "text" : "document";
+      if (isText) {
+        const text3 = await response.text();
+        return {
+          mediaType: file.mimetype,
+          data: text3,
+          filename: file.name,
+          type
+        };
+      }
+      const buffer = Buffer.from(await response.arrayBuffer());
+      if (file.mimetype === "application/pdf" && buffer.length >= 4) {
+        const header = buffer.subarray(0, 5).toString("ascii");
+        if (!header.startsWith("%PDF-")) {
+          log2.messaging.warn("Downloaded file is not a valid PDF", {
+            fileName: file.name,
+            header: buffer.subarray(0, 16).toString("hex"),
+            size: buffer.length
+          });
+          return null;
+        }
+      }
+      log2.messaging.info("Downloaded Slack file", {
+        fileName: file.name,
+        mimeType: file.mimetype,
+        size: buffer.length,
+        type
+      });
+      return {
+        mediaType: file.mimetype,
+        data: buffer.toString("base64"),
+        filename: file.name,
+        type
+      };
+    }
     async handleSlashCommand(command, respond) {
       log2.messaging.info("Slack slash command received", {
         connectionId: this.connectionId,
@@ -297025,6 +297157,31 @@ var init_slack_channel = __esm(() => {
         if (!channelId) {
           throw new Error("Failed to open DM channel");
         }
+        if (metadata?.filePath) {
+          const filePath = metadata.filePath;
+          try {
+            const fileData = readFileSync7(filePath);
+            const filename = basename2(filePath);
+            await this.app.client.files.uploadV2({
+              channel_id: channelId,
+              file: fileData,
+              filename,
+              initial_comment: content || undefined
+            });
+            log2.messaging.info("Slack file uploaded", {
+              connectionId: this.connectionId,
+              to: recipientId,
+              filename
+            });
+            return true;
+          } catch (fileErr) {
+            log2.messaging.error("Failed to upload Slack file", {
+              connectionId: this.connectionId,
+              filePath,
+              error: String(fileErr)
+            });
+          }
+        }
         if (content.length <= 4000) {
           const messageOptions = {
             channel: channelId,
@@ -1136411,6 +1136568,7 @@ A message has arrived:
 **Channel**: ${context.channel}
 **From**: ${context.sender}${context.senderName ? ` (${context.senderName})` : ""}
 **Content**: ${context.content}
+${context.hasAttachments ? `**Attachments**: ${context.attachmentNames?.join(", ") || "file(s) attached"}` : ""}
 ${context.metadata?.subject ? `**Subject**: ${context.metadata.subject}` : ""}
 ${context.metadata?.threadId ? `**Thread ID**: ${context.metadata.threadId}` : ""}
 
@@ -1136441,7 +1136599,7 @@ ${formattingGuide}`;
 function getObserveOnlySystemPrompt(channelType, context) {
   return `## Observe-Only Mode
 
-You are OBSERVING a message (read-only mode):
+You are the user's observer \u2014 your core job is to prevent things from falling through the cracks. When you see something actionable, make it visible by creating a Fulcrum task. Memories are secondary \u2014 useful for tracking context that doesn't warrant a task.
 
 **Channel**: ${context.channel}
 **From**: ${context.sender}${context.senderName ? ` (${context.senderName})` : ""}
@@ -1136455,20 +1136613,35 @@ ${context.metadata?.isGroup ? `**Group Chat**: yes` : ""}
 
 ## Available Tools
 
-- \`memory_store\` - Store ephemeral observations with tags
-- \`memory_file_read\` - Read the master memory file
-- \`memory_file_update\` - Update the master memory file (for important persistent observations)
+### Task tools
+- \`list_tasks\` - Search existing tasks (use to check for duplicates before creating)
+- \`create_task\` - Create a new task with title, description, tags, and dueDate
+- \`update_task\` - Update an existing task's title or description
+- \`add_task_link\` - Add a URL link to a task
+- \`add_task_tag\` - Add a tag to an existing task
+- \`set_task_due_date\` - Set or update a task's due date
+
+### Memory tools
+- \`memory_store\` - Store observations with tags
+- \`memory_search\` - Search existing memories to avoid duplicates
+- \`memory_list\` - List existing memories by tag
+- \`memory_file_read\` - Read the master memory file (read-only in observer mode)
+
+### Notification tools
+- \`send_notification\` - Send a notification to the user (desktop, sound, Slack, etc.)
 
 ## Your Task
 
-Silently analyze this message and decide if it needs to be tracked:
+Silently analyze this message and take the appropriate action:
 
-1. **Actionable requests directed at the user** (deadlines, meetings, tasks) \u2192 Store a memory with tag \`actionable\`
-2. **Important information** (confirmations, updates about ongoing matters) \u2192 Store a memory with tag \`monitoring\`
-3. **Important persistent observations** (learning someone's name, recurring topics, key relationships) \u2192 Update the memory file with \`memory_file_update\`
+1. **Actionable requests directed at the user** (deadlines, meetings, tasks, to-dos, follow-ups) \u2192 Use \`list_tasks\` to check for duplicates, then \`create_task\` with a clear title, description, relevant tags, and dueDate if mentioned. Tag with \`from:${context.channel}\`. After creating a task, use \`send_notification\` to alert the user (e.g., title: "New task from ${context.channel}", message: the task title).
+2. **Updates about existing matters** (confirmations, status changes, new details on known topics) \u2192 Use \`list_tasks\` to find the related task, then \`update_task\` or \`add_task_link\` as appropriate.
+3. **Important persistent observations** (learning someone's name, recurring topics, key relationships) \u2192 \`memory_store\` with tag \`persistent\`
 4. **Casual messages, spam, or irrelevant content** \u2192 Do nothing
 
-Use \`memory_store\` for transient observations. Use \`memory_file_update\` only for broadly useful, long-term knowledge.
+When creating tasks, write the title as a clear action item (e.g., "Arrange cow rental for parade" not "Message about cow rental"). Include the sender and channel context in the description.
+
+**Always use \`memory_store\`** for non-task observations \u2014 never write to MEMORY.md directly. The hourly sweep reviews stored memories and promotes important patterns to the memory file.
 Include the source channel as the \`source\` field (e.g., "channel:${context.channel}").
 
 ## Security Warning
@@ -1136498,7 +1136671,7 @@ You are performing your hourly sweep.
 ## Your Task
 
 1. **Review actionable memories** - use \`memory_search\` to find memories tagged \`actionable\` or \`monitoring\` and check for:
-   - Items that have been resolved (delete the memory or remove the tag)
+   - Items that have been resolved \u2192 delete with \`memory_delete\`
    - Patterns or connections between tracked items
    - Items that should be linked to tasks
 
@@ -1136511,14 +1136684,24 @@ You are performing your hourly sweep.
    - Store memories with tag \`actionable\` for missed items
    - Take action if still relevant
 
-4. **Update your records** - delete resolved memories or update their tags
+4. **Clean up memories** - use \`memory_list\` and \`memory_delete\` to:
+   - Delete resolved or outdated memories
+   - Remove duplicates
+
+5. **Curate MEMORY.md** - read with \`memory_file_read\` and check if it needs updates:
+   - Remove genuinely stale, duplicate, or outdated entries
+   - Move ephemeral observations (one-time events, transient status) to \`memory_store\` with appropriate tags, then remove from the file
+   - **Promote recurring patterns**: search \`memory_store\` for memories tagged \`persistent\` \u2014 if a pattern appears consistently, add it to MEMORY.md and delete the individual memories
+   - Keep: user preferences, project conventions, recurring patterns, key relationships
+   - Rewrite the cleaned file with \`memory_file_update\` if changes are needed
+   - Do NOT remove content just to reduce size \u2014 only remove what is genuinely stale, duplicate, or ephemeral
 
 ## Output
 
 After completing your sweep, provide a brief summary of:
 - Memories reviewed and actions taken
 - Tasks updated or created
-- Any patterns noticed
+- MEMORY.md changes (stale items removed, ephemeral items migrated to memory_store, patterns promoted from memory_store)
 - Items requiring user attention`;
 }
 function getRitualSystemPrompt(type) {
@@ -1136529,6 +1136712,10 @@ function getRitualSystemPrompt(type) {
 
 You are performing your morning ritual.
 
+## Memory Check
+
+Before composing your briefing, read MEMORY.md with \`memory_file_read\` for context about ongoing matters, preferences, and recent patterns.
+
 ## Output Channels
 
 Use the \`list_messaging_channels\` tool to discover which messaging channels are available and connected.
@@ -1136540,6 +1136727,15 @@ Then use the \`message\` tool to send your briefing \u2014 just specify \`channe
 
 You are performing your evening ritual.
 
+## Memory Maintenance
+
+Before composing your summary, curate MEMORY.md if changes are needed:
+1. Read MEMORY.md with \`memory_file_read\`
+2. Remove genuinely stale, duplicate, or outdated content
+3. Move ephemeral items to \`memory_store\` with appropriate tags
+4. Search \`memory_store\` for memories tagged \`persistent\` \u2014 promote recurring patterns into MEMORY.md and delete the individual memories
+5. Rewrite the file with \`memory_file_update\` only if changes were made
+
 ## Output Channels
 
 Use the \`list_messaging_channels\` tool to discover which messaging channels are available and connected.
@@ -1136557,40 +1136753,35 @@ WhatsApp does NOT render full Markdown. Keep formatting simple:
     case "slack":
       return `## Slack Formatting & Block Kit
 
-Your response will be structured as JSON with two fields:
+Wrap your entire response in \`<slack-response>\` XML tags containing a JSON object with:
 
 - **body** (required): Plain text message shown in notifications and as fallback
 - **blocks** (optional): Array of Slack Block Kit blocks for rich formatting
+- **filePath** (optional): Absolute path to a file on disk to upload as an attachment
+
+Example:
+<slack-response>
+{"body": "Here are your open tasks", "blocks": [{"type": "section", "text": {"type": "mrkdwn", "text": "*Open Tasks:*\\n\u2022 Task 1\\n\u2022 Task 2"}}]}
+</slack-response>
+
+To send a file (image, document, etc.) you created:
+<slack-response>
+{"body": "Here's the generated image", "filePath": "/absolute/path/to/file.png"}
+</slack-response>
 
 ### Block Kit Blocks
 
 **Section Block** - Main content:
-\`\`\`json
-{ "type": "section", "text": { "type": "mrkdwn", "text": "*Bold* and _italic_" } }
-\`\`\`
+\`{"type": "section", "text": {"type": "mrkdwn", "text": "*Bold* and _italic_"}}\`
 
 **Section with Fields** - Multi-column layout:
-\`\`\`json
-{ "type": "section", "fields": [
-  { "type": "mrkdwn", "text": "*Status:*\\nIn Progress" },
-  { "type": "mrkdwn", "text": "*Due:*\\nToday" }
-] }
-\`\`\`
+\`{"type": "section", "fields": [{"type": "mrkdwn", "text": "*Status:*\\nIn Progress"}, {"type": "mrkdwn", "text": "*Due:*\\nToday"}]}\`
 
-**Header Block** - Large text headers:
-\`\`\`json
-{ "type": "header", "text": { "type": "plain_text", "text": "Task Summary", "emoji": true } }
-\`\`\`
+**Header Block**: \`{"type": "header", "text": {"type": "plain_text", "text": "Title", "emoji": true}}\`
 
-**Divider Block** - Horizontal rule:
-\`\`\`json
-{ "type": "divider" }
-\`\`\`
+**Divider Block**: \`{"type": "divider"}\`
 
-**Context Block** - Small muted text:
-\`\`\`json
-{ "type": "context", "elements": [{ "type": "mrkdwn", "text": "Last updated 5 min ago" }] }
-\`\`\`
+**Context Block**: \`{"type": "context", "elements": [{"type": "mrkdwn", "text": "Small muted text"}]}\`
 
 ### mrkdwn Syntax
 - *bold* with single asterisks
@@ -1136605,7 +1136796,9 @@ Your response will be structured as JSON with two fields:
 - **Lists/Status**: Use section blocks with bullet points or fields
 - **Structured Data**: Use fields for key-value pairs side by side
 - **Headers**: Use header blocks for major sections
-- **Simple Responses**: Just set body to your plain text reply, omit blocks`;
+- **Simple Responses**: Just set body to your plain text, omit blocks
+
+**IMPORTANT**: Always wrap your response in \`<slack-response>\` tags with valid JSON inside.`;
     case "discord":
       return `## Discord Formatting
 
@@ -1138553,7 +1138746,7 @@ function s_({ prompt: X, options: Q }) {
     let L6 = TI(import.meta.url), q6 = tz(L6, "..");
     B = tz(q6, "cli.js");
   }
-  process.env.CLAUDE_AGENT_SDK_VERSION = "0.2.34";
+  process.env.CLAUDE_AGENT_SDK_VERSION = "0.2.37";
   let { abortController: z = F6(), additionalDirectories: K = [], agent: V, agents: L, allowedTools: U = [], betas: F, canUseTool: q2, continue: N, cwd: w, debug: M, debugFile: R, disallowedTools: S = [], tools: C, env: K0, executable: U0 = M6() ? "bun" : "node", executableArgs: s = [], extraArgs: D0 = {}, fallbackModel: q0, enableFileCheckpointing: L1, forkSession: P1, hooks: o1, includePartialMessages: c, persistSession: Q9, maxThinkingTokens: r6, maxTurns: o6, maxBudgetUsd: t6, mcpServers: a6, model: B4, outputFormat: E0, permissionMode: S1 = "default", allowDangerouslySkipPermissions: s6 = false, permissionPromptToolName: az, plugins: sz, resume: ez, resumeSessionAt: XK, sessionId: QK, stderr: $K, strictMcpConfig: YK } = J, G7 = E0?.type === "json_schema" ? E0.schema : undefined, V6 = K0;
   if (!V6)
     V6 = { ...process.env };
@@ -1147055,8 +1147248,10 @@ You have access to Fulcrum's MCP tools. Use them proactively to help users.
 - Use \`search\` with \`memoryTags: ["actionable"]\` to review tracked items
 
 **Unified Search:**
-- \`search\` - Cross-entity FTS5 full-text search across tasks, projects, messages, events, memories, and conversations
-  - Filter by entity type: \`entities: ["tasks", "projects", "messages", "events", "memories", "conversations"]\`
+- \`search\` - Cross-entity FTS5 full-text search across tasks, projects, messages, events, memories, conversations, and gmail
+  - Filter by entity type: \`entities: ["tasks", "projects", "messages", "events", "memories", "conversations", "gmail"]\`
+  - **Gmail is opt-in** \u2014 not included in default searches to avoid latency/rate-limit impact. Must be explicitly requested via \`entities: ["gmail"]\`
+  - Gmail-specific filters: \`gmailFrom\`, \`gmailTo\`, \`gmailAfter\`, \`gmailBefore\`
   - Entity-specific filters: \`taskStatus\`, \`projectStatus\`, \`messageChannel\`, \`messageDirection\`, \`eventFrom\`, \`eventTo\`, \`memoryTags\`, \`conversationRole\`, \`conversationProvider\`, \`conversationProjectId\`
   - Conversations search indexes AI assistant chat messages (excludes system prompts) with session context
   - Results sorted by relevance score with BM25 ranking
@@ -1147065,8 +1147260,11 @@ You have access to Fulcrum's MCP tools. Use them proactively to help users.
 - \`memory_file_read\` - Read the master memory file (MEMORY.md)
 - \`memory_file_update\` - Update the file (whole or by section heading)
 
-**Ephemeral Memories:**
+**Memory Management:**
 - \`memory_store\` - Store individual knowledge snippets with optional tags
+- \`memory_search\` - Full-text search across memories (FTS5: AND, OR, NOT, "phrases", prefix*)
+- \`memory_list\` - List memories with optional tag filter and pagination
+- \`memory_delete\` - Delete a memory by ID (for cleanup of resolved/stale items)
 
 **Google Account & Gmail Tools:**
 - \`list_google_accounts\` - List all Google accounts with calendar/Gmail status
@@ -1147398,9 +1147596,9 @@ Fulcrum is your digital concierge - a personal command center where you track ev
 - list_projects, create_project
 - execute_command (run any CLI command)
 - send_notification
-- search (unified FTS5 search across tasks, projects, messages, events, memories, conversations)
+- search (unified FTS5 search across tasks, projects, messages, events, memories, conversations; gmail is opt-in via \`entities: ["gmail"]\`)
 - memory_file_read, memory_file_update (master memory file - always in prompt)
-- memory_store (ephemeral knowledge snippets with tags)
+- memory_store, memory_search, memory_list, memory_delete (persistent knowledge with tags)
 - message (send to WhatsApp/Discord/Telegram/Slack/Gmail - user-only, concierge mode)
 - memory_store with tag \`actionable\` (track things needing attention - concierge mode)
 - search with memoryTags filter (find tracked items by tag)
@@ -1147409,7 +1147607,7 @@ Fulcrum is your digital concierge - a personal command center where you track ev
 }
 
 // server/services/memory-file-service.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, existsSync as existsSync14 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, existsSync as existsSync14 } from "fs";
 import { join as join13 } from "path";
 function getMemoryFilePath() {
   return join13(getFulcrumDir(), MEMORY_FILENAME);
@@ -1147418,7 +1147616,7 @@ function readMemoryFile() {
   const filePath = getMemoryFilePath();
   if (!existsSync14(filePath))
     return "";
-  return readFileSync8(filePath, "utf-8");
+  return readFileSync9(filePath, "utf-8");
 }
 function writeMemoryFile(content) {
   const filePath = getMemoryFilePath();
@@ -1147597,7 +1147795,7 @@ function addMessage(sessionId, message) {
   return db2.select().from(chatMessages).where(eq(chatMessages.id, id)).get();
 }
 function getMessages(sessionId) {
-  return db2.select().from(chatMessages).where(eq(chatMessages.sessionId, sessionId)).orderBy(chatMessages.createdAt).all();
+  return db2.select().from(chatMessages).where(eq(chatMessages.sessionId, sessionId)).orderBy(chatMessages.createdAt, sql`rowid`).all();
 }
 function buildBaselinePrompt(condensed = false) {
   const settings = getSettings();
@@ -1147612,7 +1147810,12 @@ ${knowledge}`;
 
 ## Master Memory File
 
-This is your persistent memory. Update it with \`memory_file_update\` when you learn broadly useful information about the user, their preferences, projects, or recurring patterns.
+This is your persistent memory (MEMORY.md), injected into every conversation.
+
+**What belongs here:** user preferences, project conventions, recurring patterns, key relationships, important decisions.
+**What does NOT belong:** ephemeral observations, one-time events, transient status \u2014 use \`memory_store\` with appropriate tags instead.
+
+Update with \`memory_file_update\` only for broadly useful, long-term knowledge. The hourly sweep automatically curates this file.
 
 ${memoryFileContent}`;
   }
@@ -1147867,19 +1148070,22 @@ async function* streamMessage(sessionId, userMessage, modelIdOrOptions, editorCo
     yield { type: "error", data: { message: "Session not found" } };
     return;
   }
-  addMessage(sessionId, {
-    role: "user",
-    content: userMessage,
-    sessionId
-  });
+  if (!options.ephemeral) {
+    addMessage(sessionId, {
+      role: "user",
+      content: userMessage,
+      sessionId
+    });
+  }
   const settings = getSettings();
   const port = settings.server.port;
   const effectiveModelId = options.modelId ?? settings.assistant.model;
   let state = sessionState.get(sessionId);
   if (!state) {
-    state = {};
+    state = { claudeSessionId: options.ephemeral ? undefined : session3.claudeSessionId ?? undefined };
     sessionState.set(sessionId, state);
   }
+  const resumeSessionId = options.ephemeral ? undefined : state.claudeSessionId;
   const tempFiles = [];
   try {
     log2.assistant.debug("Starting assistant query", {
@@ -1147927,8 +1148133,15 @@ User message: ${userMessage}`;
             {
               const tempDir = await mkdtemp(join14(tmpdir3(), "fulcrum-doc-"));
               const tempPath = join14(tempDir, attachment.filename || "document.pdf");
-              await writeFile3(tempPath, Buffer.from(attachment.data, "base64"));
+              const docBuffer = Buffer.from(attachment.data, "base64");
+              await writeFile3(tempPath, docBuffer);
               tempFiles.push(tempPath);
+              log2.assistant.info("Wrote document attachment to temp file", {
+                sessionId,
+                path: tempPath,
+                size: docBuffer.length,
+                header: docBuffer.subarray(0, 8).toString("ascii")
+              });
               parts.push(`[Attached document: ${tempPath}]`);
             }
             break;
@@ -1147951,13 +1148164,14 @@ ${attachment.data}`);
       sessionId,
       requestedModelId: effectiveModelId,
       resolvedModel: MODEL_MAP[effectiveModelId],
-      resumeSessionId: state.claudeSessionId ?? null
+      resumeSessionId: resumeSessionId ?? null,
+      ephemeral: options.ephemeral ?? false
     });
     const result = s_({
       prompt: fullPrompt,
       options: {
         model: MODEL_MAP[effectiveModelId],
-        resume: state.claudeSessionId,
+        resume: resumeSessionId,
         includePartialMessages: true,
         pathToClaudeCodeExecutable: getClaudeCodePathForSdk(),
         mcpServers: {
@@ -1147971,6 +1148185,7 @@ ${attachment.data}`);
         permissionMode: "bypassPermissions",
         allowDangerouslySkipPermissions: true,
         settingSources: ["user"],
+        ...options.ephemeral && { persistSession: false, maxTurns: 3 },
         ...options.outputFormat && { outputFormat: options.outputFormat }
       }
     });
@@ -1147996,7 +1148211,10 @@ ${attachment.data}`);
         }
       } else if (message.type === "assistant") {
         const assistantMsg = message;
-        state.claudeSessionId = assistantMsg.session_id;
+        if (!options.ephemeral) {
+          state.claudeSessionId = assistantMsg.session_id;
+          db2.update(chatSessions).set({ claudeSessionId: assistantMsg.session_id }).where(eq(chatSessions.id, sessionId)).run();
+        }
         const textContent = assistantMsg.message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
         if (textContent) {
           if (textContent.length > currentText.length) {
@@ -1148030,7 +1148248,10 @@ ${attachment.data}`);
         const resultMsg = message;
         if (resultMsg.subtype?.startsWith("error_")) {
           const errors2 = resultMsg.errors || ["Unknown error"];
-          state.claudeSessionId = undefined;
+          if (!options.ephemeral) {
+            state.claudeSessionId = undefined;
+            db2.update(chatSessions).set({ claudeSessionId: null }).where(eq(chatSessions.id, sessionId)).run();
+          }
           yield { type: "error", data: { message: errors2.join(", ") } };
         }
         if (resultMsg.structured_output) {
@@ -1148043,7 +1148264,7 @@ ${attachment.data}`);
         });
       }
     }
-    if (currentText.trim()) {
+    if (!options.ephemeral && currentText.trim()) {
       addMessage(sessionId, {
         role: "assistant",
         content: currentText,
@@ -1148057,7 +1148278,10 @@ ${attachment.data}`);
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
     log2.assistant.error("Assistant stream error", { sessionId, error: errorMsg });
-    state.claudeSessionId = undefined;
+    if (!options.ephemeral) {
+      state.claudeSessionId = undefined;
+      db2.update(chatSessions).set({ claudeSessionId: null }).where(eq(chatSessions.id, sessionId)).run();
+    }
     yield { type: "error", data: { message: errorMsg } };
   } finally {
     for (const tempPath of tempFiles) {
@@ -1149955,8 +1150179,51 @@ ${contextualMessage}`;
         }
         const parsed = JSON.parse(jsonText);
         if (parsed.actions && Array.isArray(parsed.actions)) {
+          const settings2 = getSettings();
+          const fulcrumPort = settings2.server?.port ?? 7777;
           for (const action of parsed.actions) {
-            if (action.type === "store_memory" && action.content) {
+            if (action.type === "create_task" && action.title) {
+              try {
+                const resp = await fetch(`http://localhost:${fulcrumPort}/api/tasks`, {
+                  method: "POST",
+                  headers: { "Content-Type": "application/json" },
+                  body: JSON.stringify({
+                    title: action.title,
+                    description: action.description || null,
+                    status: "TO_DO",
+                    tags: action.tags,
+                    dueDate: action.dueDate || null
+                  })
+                });
+                if (!resp.ok) {
+                  log2.messaging.warn("Observer failed to create task via OpenCode", {
+                    sessionId,
+                    status: resp.status,
+                    title: action.title
+                  });
+                } else {
+                  log2.messaging.info("Observer created task via OpenCode", {
+                    sessionId,
+                    title: action.title
+                  });
+                  try {
+                    await fetch(`http://localhost:${fulcrumPort}/api/config/notifications/send`, {
+                      method: "POST",
+                      headers: { "Content-Type": "application/json" },
+                      body: JSON.stringify({
+                        title: `New task from ${options.channelType}`,
+                        message: action.title
+                      })
+                    });
+                  } catch {}
+                }
+              } catch (err) {
+                log2.messaging.warn("Observer task creation error via OpenCode", {
+                  sessionId,
+                  error: err instanceof Error ? err.message : String(err)
+                });
+              }
+            } else if (action.type === "store_memory" && action.content) {
               const source = action.source || `channel:${options.channelType}`;
               await storeMemory({
                 content: action.content,
@@ -1149988,38 +1150255,59 @@ ${contextualMessage}`;
     yield { type: "error", data: { message: errorMsg } };
   }
 }
-var OPENCODE_DEFAULT_PORT = 4096, opencodeClient = null, OBSERVER_SYSTEM_PROMPT = `You are an observer processing messages from external channels. Your ONLY job is to identify important information worth remembering.
+var OPENCODE_DEFAULT_PORT = 4096, opencodeClient = null, OBSERVER_SYSTEM_PROMPT = `You are the user's observer \u2014 your core job is to prevent things from falling through the cracks. When you see something actionable, create a task. Memories are secondary \u2014 useful for context that doesn't warrant a task.
 
 IMPORTANT: You have NO tools. Instead, respond with a JSON object describing what actions to take.
 
 Response format (respond with ONLY this JSON, no other text):
 {
   "actions": [
+    {
+      "type": "create_task",
+      "title": "Clear action item title",
+      "description": "Details including sender and context",
+      "tags": ["from:whatsapp", "errand"],
+      "dueDate": "2025-02-18"
+    },
     {
       "type": "store_memory",
       "content": "The fact or information to store",
-      "tags": ["tag1", "tag2"],
+      "tags": ["persistent"],
       "source": "channel:whatsapp"
     }
   ]
 }
 
-If the message contains nothing worth remembering (casual chat, greetings, spam, etc.), respond with:
+If the message contains nothing worth tracking (casual chat, greetings, spam, etc.), respond with:
 {"actions": []}
 
-Guidelines for what to store:
-- Important dates, deadlines, appointments
-- Decisions or agreements
-- Contact information
-- Project updates or status changes
-- Action items or requests
-- Key facts or data points
+## Action types
+
+### create_task (preferred for actionable items)
+Use for: deadlines, meetings, to-dos, follow-ups, requests directed at the user.
+Fields: title (required, imperative action item), description, tags (array), dueDate (YYYY-MM-DD if mentioned).
+Write titles as clear action items (e.g., "Arrange cow rental for parade" not "Message about cow rental").
+
+### store_memory (for non-task observations)
+Use for: learning someone's name, recurring patterns, key relationships, context updates.
+Fields: content (required), tags (array), source (e.g., "channel:whatsapp").
 
-Do NOT store:
+## Guidelines
+
+Create a task for:
+- Deadlines, appointments, meetings
+- Action items or requests directed at the user
+- Follow-ups or reminders
+
+Store a memory for:
+- Contact details, names, relationships
+- Project context or status updates
+- Patterns worth remembering
+
+Do nothing for:
 - Casual greetings or small talk
 - Spam or promotional content
-- Messages you don't understand
-- Trivially obvious information`;
+- Messages you don't understand`;
 var init_opencode_channel_service = __esm(() => {
   init_dist10();
   init_logger3();
@@ -1150102,6 +1150390,8 @@ async function handleIncomingMessage(msg) {
       sender: msg.senderId,
       senderName: msg.senderName,
       content,
+      hasAttachments: (msg.attachments?.length ?? 0) > 0,
+      attachmentNames: msg.attachments?.map((a) => a.filename),
       metadata: {
         subject: msg.metadata?.subject,
         threadId: msg.metadata?.threadId,
@@ -1150110,24 +1150400,46 @@ async function handleIncomingMessage(msg) {
     };
     const systemPrompt = getMessagingSystemPrompt(msg.channelType, context);
     const isSlack = msg.channelType === "slack";
-    const stream2 = _deps.streamMessage(session3.id, content, {
+    const stream2 = _deps.streamMessage(session3.id, content || "(file attached)", {
       systemPromptAdditions: systemPrompt,
-      ...isSlack && { outputFormat: { type: "json_schema", schema: SLACK_RESPONSE_SCHEMA } }
+      ...msg.attachments?.length && { attachments: msg.attachments }
     });
     let responseText = "";
-    let structuredOutput = null;
+    let hasError = false;
     for await (const event of stream2) {
       if (event.type === "error") {
         const errorMsg = event.data.message;
         log2.messaging.error("Assistant error handling message", { error: errorMsg });
+        hasError = true;
       } else if (event.type === "message:complete") {
-        responseText = event.data.content;
-      } else if (event.type === "structured_output") {
-        structuredOutput = event.data;
+        const text3 = event.data.content;
+        if (!text3.startsWith("API Error:") && !text3.startsWith("Error:")) {
+          responseText = text3;
+        } else {
+          log2.messaging.warn("Suppressed API error from assistant response", {
+            errorPreview: text3.slice(0, 200)
+          });
+          hasError = true;
+        }
       }
     }
-    if (isSlack && structuredOutput?.body?.trim()) {
-      await sendResponse(msg, structuredOutput.body, structuredOutput.blocks ? { blocks: structuredOutput.blocks } : undefined);
+    if (hasError && !responseText.trim()) {
+      responseText = "Sorry, I ran into an issue processing that. Could you try again or rephrase your message?";
+    }
+    if (isSlack && responseText.trim()) {
+      const parsed = parseSlackResponse(responseText);
+      if (parsed) {
+        const metadata = {};
+        if (parsed.blocks)
+          metadata.blocks = parsed.blocks;
+        if (parsed.filePath)
+          metadata.filePath = parsed.filePath;
+        await sendResponse(msg, parsed.body, Object.keys(metadata).length > 0 ? metadata : undefined);
+      } else {
+        await sendResponse(msg, responseText, {
+          blocks: [{ type: "section", text: { type: "mrkdwn", text: responseText } }]
+        });
+      }
     } else if (responseText.trim()) {
       await sendResponse(msg, responseText);
     }
@@ -1150253,6 +1150565,24 @@ Started: ${new Date(mapping.createdAt).toLocaleString()}
 Last active: ${new Date(mapping.lastMessageAt).toLocaleString()}`;
   await sendResponse(msg, statusText);
 }
+function parseSlackResponse(text3) {
+  const match3 = text3.match(/<slack-response>([\s\S]*?)<\/slack-response>/);
+  if (!match3)
+    return null;
+  try {
+    const parsed = JSON.parse(match3[1]);
+    if (typeof parsed.body === "string" && parsed.body.trim()) {
+      return {
+        body: parsed.body,
+        ...Array.isArray(parsed.blocks) && { blocks: parsed.blocks },
+        ...typeof parsed.filePath === "string" && parsed.filePath.trim() && { filePath: parsed.filePath }
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
 async function sendResponse(originalMsg, content, metadata) {
   if (originalMsg.channelType === "email") {
     log2.messaging.info("Skipping email response \u2014 sending disabled, use Gmail drafts", {
@@ -1150359,7 +1150689,8 @@ async function processObserveOnlyMessage(msg) {
     const stream2 = _deps.streamMessage(session3.id, msg.content, {
       systemPromptAdditions: systemPrompt,
       modelId: observerModelId,
-      securityTier: "observer"
+      securityTier: "observer",
+      ephemeral: true
     });
     for await (const event of stream2) {
       if (event.type === "error") {
@@ -1150380,7 +1150711,7 @@ async function processObserveOnlyMessage(msg) {
     recordObserverFailure();
   }
 }
-var _deps, SLACK_RESPONSE_SCHEMA, OBSERVER_CIRCUIT_BREAKER, COMMANDS;
+var _deps, OBSERVER_CIRCUIT_BREAKER, COMMANDS;
 var init_message_handler = __esm(() => {
   init_logger3();
   init_channel_manager();
@@ -1150392,21 +1150723,6 @@ var init_message_handler = __esm(() => {
     streamMessage: (...args) => streamMessage(...args),
     streamOpencodeObserverMessage: (...args) => streamOpencodeObserverMessage(...args)
   };
-  SLACK_RESPONSE_SCHEMA = {
-    type: "object",
-    properties: {
-      body: {
-        type: "string",
-        description: "Plain text message (shown in notifications and as fallback)"
-      },
-      blocks: {
-        type: "array",
-        description: "Slack Block Kit blocks for rich formatting",
-        items: { type: "object", additionalProperties: true }
-      }
-    },
-    required: ["body"]
-  };
   OBSERVER_CIRCUIT_BREAKER = {
     failureCount: 0,
     failureThreshold: 3,
@@ -1150687,7 +1151003,10 @@ async function sendMessageToChannel(channel, body, options) {
         return { success: false, error: "Slack channel not active" };
       }
       try {
-        const msgMetadata = options?.slackBlocks ? { blocks: options.slackBlocks } : undefined;
+        const msgMetadata = options?.slackBlocks || options?.filePath ? {
+          ...options.slackBlocks && { blocks: options.slackBlocks },
+          ...options.filePath && { filePath: options.filePath }
+        } : undefined;
         const success = await slackChannel.sendMessage(resolvedTo, body, msgMetadata);
         if (success) {
           log2.messaging.info("Sent Slack message", { to: resolvedTo, hasBlocks: !!options?.slackBlocks });
@@ -1188385,13 +1188704,13 @@ var require_core = __commonJS((exports) => {
     return metaOpts;
   }
   var noLogs = { log() {}, warn() {}, error() {} };
-  function getLogger(logger6) {
-    if (logger6 === false)
+  function getLogger(logger7) {
+    if (logger7 === false)
       return noLogs;
-    if (logger6 === undefined)
+    if (logger7 === undefined)
       return console;
-    if (logger6.log && logger6.warn && logger6.error)
-      return logger6;
+    if (logger7.log && logger7.warn && logger7.error)
+      return logger7;
     throw new Error("logger must implement log, warn and error methods");
   }
   var KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;
@@ -1194018,13 +1194337,13 @@ var require_core3 = __commonJS((exports) => {
     return metaOpts;
   }
   var noLogs = { log() {}, warn() {}, error() {} };
-  function getLogger(logger6) {
-    if (logger6 === false)
+  function getLogger(logger7) {
+    if (logger7 === false)
       return noLogs;
-    if (logger6 === undefined)
+    if (logger7 === undefined)
       return console;
-    if (logger6.log && logger6.warn && logger6.error)
-      return logger6;
+    if (logger7.log && logger7.warn && logger7.error)
+      return logger7;
     throw new Error("logger must implement log, warn and error methods");
   }
   var KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;
@@ -1200416,10 +1200735,10 @@ class CaldavAccountManager {
   }
   async startAll() {
     const accounts = db2.select().from(caldavAccounts).where(eq(caldavAccounts.enabled, true)).all();
-    logger6.info("Starting all CalDAV accounts", { count: accounts.length });
+    logger7.info("Starting all CalDAV accounts", { count: accounts.length });
     for (const account2 of accounts) {
       await this.startAccount(account2.id).catch((err) => {
-        logger6.error("Failed to start account", {
+        logger7.error("Failed to start account", {
           accountId: account2.id,
           name: account2.name,
           error: err instanceof Error ? err.message : String(err)
@@ -1200432,7 +1200751,7 @@ class CaldavAccountManager {
       this.stopAccount(accountId);
     }
     this.connections.clear();
-    logger6.info("All CalDAV accounts stopped");
+    logger7.info("All CalDAV accounts stopped");
   }
   async startAccount(accountId) {
     const account2 = db2.select().from(caldavAccounts).where(eq(caldavAccounts.id, accountId)).get();
@@ -1200440,7 +1200759,7 @@ class CaldavAccountManager {
       throw new Error(`Account not found: ${accountId}`);
     }
     if (!account2.enabled) {
-      logger6.info("Account is disabled, skipping", { accountId, name: account2.name });
+      logger7.info("Account is disabled, skipping", { accountId, name: account2.name });
       return;
     }
     this.stopAccount(accountId);
@@ -1200456,11 +1200775,11 @@ class CaldavAccountManager {
     try {
       conn.client = await this.connect(account2);
       this.scheduleSync(accountId, account2.syncIntervalMinutes ?? 15);
-      logger6.info("Started CalDAV account", { accountId, name: account2.name });
+      logger7.info("Started CalDAV account", { accountId, name: account2.name });
     } catch (err) {
       conn.lastSyncError = err instanceof Error ? err.message : String(err);
       this.updateAccountError(accountId, conn.lastSyncError);
-      logger6.error("Failed to connect account", { accountId, error: conn.lastSyncError });
+      logger7.error("Failed to connect account", { accountId, error: conn.lastSyncError });
       this.scheduleRetry(accountId);
     }
   }
@@ -1200502,7 +1200821,7 @@ class CaldavAccountManager {
     for (const [accountId, conn] of this.connections) {
       if (conn.client && !conn.isSyncing) {
         promises.push(this.syncAccount(accountId).catch((err) => {
-          logger6.error("Sync failed for account", {
+          logger7.error("Sync failed for account", {
             accountId,
             error: err instanceof Error ? err.message : String(err)
           });
@@ -1200562,7 +1200881,7 @@ class CaldavAccountManager {
       defaultAccountType: "caldav"
     });
     await client4.login();
-    logger6.info("Connected to CalDAV server (Basic)", { accountId: account2.id, serverUrl: account2.serverUrl });
+    logger7.info("Connected to CalDAV server (Basic)", { accountId: account2.id, serverUrl: account2.serverUrl });
     return client4;
   }
   async connectOAuth(account2) {
@@ -1200597,9 +1200916,9 @@ class CaldavAccountManager {
           credentials.expiration = newTokens.expiration;
           try {
             db2.update(caldavAccounts).set({ oauthTokens: newTokens, updatedAt: new Date().toISOString() }).where(eq(caldavAccounts.id, accountId)).run();
-            logger6.info("Persisted refreshed OAuth tokens", { accountId });
+            logger7.info("Persisted refreshed OAuth tokens", { accountId });
           } catch (err) {
-            logger6.error("Failed to persist refreshed OAuth tokens", {
+            logger7.error("Failed to persist refreshed OAuth tokens", {
               accountId,
               error: err instanceof Error ? err.message : String(err)
             });
@@ -1200610,7 +1200929,7 @@ class CaldavAccountManager {
       defaultAccountType: "caldav"
     });
     await client4.login();
-    logger6.info("Connected to CalDAV server (Google OAuth)", { accountId: account2.id, serverUrl: account2.serverUrl });
+    logger7.info("Connected to CalDAV server (Google OAuth)", { accountId: account2.id, serverUrl: account2.serverUrl });
     return client4;
   }
   scheduleSync(accountId, intervalMinutes) {
@@ -1200622,7 +1200941,7 @@ class CaldavAccountManager {
     }
     conn.syncInterval = setInterval(() => {
       this.syncAccount(accountId).catch((err) => {
-        logger6.error("Periodic sync failed", {
+        logger7.error("Periodic sync failed", {
           accountId,
           error: err instanceof Error ? err.message : String(err)
         });
@@ -1200635,7 +1200954,7 @@ class CaldavAccountManager {
       return;
     conn.retryCount++;
     const delay2 = Math.min(1000 * Math.pow(2, conn.retryCount), MAX_RETRY_DELAY);
-    logger6.info("Scheduling account retry", { accountId, retryCount: conn.retryCount, delayMs: delay2 });
+    logger7.info("Scheduling account retry", { accountId, retryCount: conn.retryCount, delayMs: delay2 });
     setTimeout(async () => {
       const account2 = db2.select().from(caldavAccounts).where(eq(caldavAccounts.id, accountId)).get();
       if (!account2 || !account2.enabled)
@@ -1200651,7 +1200970,7 @@ class CaldavAccountManager {
       } catch (err) {
         conn.lastSyncError = err instanceof Error ? err.message : String(err);
         this.updateAccountError(accountId, conn.lastSyncError);
-        logger6.error("Account retry failed", { accountId, error: conn.lastSyncError });
+        logger7.error("Account retry failed", { accountId, error: conn.lastSyncError });
         this.scheduleRetry(accountId);
       }
     }, delay2);
@@ -1200709,10 +1201028,10 @@ class CaldavAccountManager {
       if (!seenUrls.has(local.remoteUrl)) {
         db2.delete(caldavEvents2).where(eq(caldavEvents2.calendarId, local.id)).run();
         db2.delete(caldavCalendars).where(eq(caldavCalendars.id, local.id)).run();
-        logger6.info("Removed deleted calendar", { displayName: local.displayName, accountId });
+        logger7.info("Removed deleted calendar", { displayName: local.displayName, accountId });
       }
     }
-    logger6.info("Account sync complete", { accountId, calendars: remoteCalendars.length });
+    logger7.info("Account sync complete", { accountId, calendars: remoteCalendars.length });
   }
   async syncCalendarEvents(calendarId, remoteCal, client4) {
     const { caldavEvents: caldavEvents2 } = await Promise.resolve().then(() => (init_db2(), exports_db));
@@ -1200779,13 +1201098,13 @@ class CaldavAccountManager {
     }
   }
 }
-var logger6, GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token", MAX_RETRY_DELAY, accountManager;
+var logger7, GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token", MAX_RETRY_DELAY, accountManager;
 var init_caldav_account_manager = __esm(() => {
   init_tsdav_esm();
   init_drizzle_orm();
   init_db2();
   init_logger3();
-  logger6 = createLogger("CalDAV:AccountManager");
+  logger7 = createLogger("CalDAV:AccountManager");
   MAX_RETRY_DELAY = 5 * 60 * 1000;
   accountManager = new CaldavAccountManager;
 });
@@ -1200808,7 +1201127,7 @@ class GoogleCalendarManager {
     try {
       await this.syncAccount(accountId);
     } catch (err) {
-      logger7.error("Initial Google Calendar sync failed", {
+      logger8.error("Initial Google Calendar sync failed", {
         accountId,
         error: err instanceof Error ? err.message : String(err)
       });
@@ -1200816,13 +1201135,13 @@ class GoogleCalendarManager {
     const intervalMs = (account2.syncIntervalMinutes ?? 15) * 60 * 1000;
     conn.syncInterval = setInterval(() => {
       this.syncAccount(accountId).catch((err) => {
-        logger7.error("Periodic Google Calendar sync failed", {
+        logger8.error("Periodic Google Calendar sync failed", {
           accountId,
           error: err instanceof Error ? err.message : String(err)
         });
       });
     }, intervalMs);
-    logger7.info("Started Google Calendar account", { accountId, name: account2.name });
+    logger8.info("Started Google Calendar account", { accountId, name: account2.name });
   }
   stopAccount(accountId) {
     const conn = this.connections.get(accountId);
@@ -1200840,10 +1201159,10 @@ class GoogleCalendarManager {
   }
   async startAll() {
     const accounts = db2.select().from(googleAccounts).where(eq(googleAccounts.calendarEnabled, true)).all();
-    logger7.info("Starting Google Calendar accounts", { count: accounts.length });
+    logger8.info("Starting Google Calendar accounts", { count: accounts.length });
     for (const account2 of accounts) {
       await this.startAccount(account2.id).catch((err) => {
-        logger7.error("Failed to start Google Calendar account", {
+        logger8.error("Failed to start Google Calendar account", {
           accountId: account2.id,
           error: err instanceof Error ? err.message : String(err)
         });
@@ -1200905,7 +1201224,7 @@ class GoogleCalendarManager {
         if (!seenRemoteUrls.has(local.remoteUrl)) {
           db2.delete(caldavEvents).where(eq(caldavEvents.calendarId, local.id)).run();
           db2.delete(caldavCalendars).where(eq(caldavCalendars.id, local.id)).run();
-          logger7.info("Removed deleted Google calendar", {
+          logger8.info("Removed deleted Google calendar", {
             displayName: local.displayName,
             accountId
           });
@@ -1200919,7 +1201238,7 @@ class GoogleCalendarManager {
       if (conn) {
         conn.lastSyncError = null;
       }
-      logger7.info("Google Calendar sync complete", {
+      logger8.info("Google Calendar sync complete", {
         accountId,
         calendars: remoteCalendars.length
       });
@@ -1201136,14 +1201455,14 @@ class GoogleCalendarManager {
     return this.connections.get(accountId)?.lastSyncError ?? null;
   }
 }
-var import_googleapis3, logger7, googleCalendarManager;
+var import_googleapis3, logger8, googleCalendarManager;
 var init_google_calendar_manager = __esm(() => {
   init_drizzle_orm();
   init_db2();
   init_google_oauth();
   init_logger3();
   import_googleapis3 = __toESM(require_src12(), 1);
-  logger7 = createLogger("Google:Calendar");
+  logger8 = createLogger("Google:Calendar");
   googleCalendarManager = new GoogleCalendarManager;
 });
 
@@ -1201157,12 +1201476,12 @@ async function executeAllRules() {
   const rules = db2.select().from(caldavCopyRules).where(eq(caldavCopyRules.enabled, true)).all();
   if (rules.length === 0)
     return;
-  logger8.info("Executing copy rules", { count: rules.length });
+  logger9.info("Executing copy rules", { count: rules.length });
   for (const rule of rules) {
     try {
       await executeSingleRule(rule.id);
     } catch (err) {
-      logger8.error("Copy rule failed", {
+      logger9.error("Copy rule failed", {
         ruleId: rule.id,
         error: err instanceof Error ? err.message : String(err)
       });
@@ -1201176,7 +1201495,7 @@ async function executeSingleRule(ruleId) {
   const sourceCal = db2.select().from(caldavCalendars).where(eq(caldavCalendars.id, rule.sourceCalendarId)).get();
   const destCal = db2.select().from(caldavCalendars).where(eq(caldavCalendars.id, rule.destCalendarId)).get();
   if (!sourceCal || !destCal) {
-    logger8.warn("Copy rule references missing calendar", {
+    logger9.warn("Copy rule references missing calendar", {
       ruleId,
       sourceExists: !!sourceCal,
       destExists: !!destCal
@@ -1201186,7 +1201505,7 @@ async function executeSingleRule(ruleId) {
   const isGoogleDest = !!destCal.googleAccountId;
   const destClient = destCal.accountId ? accountManager.getClient(destCal.accountId) : null;
   if (!isGoogleDest && !destClient) {
-    logger8.warn("Destination account not connected", {
+    logger9.warn("Destination account not connected", {
       ruleId,
       destCalendarId: destCal.id,
       destAccountId: destCal.accountId
@@ -1201272,7 +1201591,7 @@ async function executeSingleRule(ruleId) {
         }).run();
         created++;
       } catch (err) {
-        logger8.error("Failed to copy event", {
+        logger9.error("Failed to copy event", {
           ruleId,
           sourceEventId: sourceEvent.id,
           error: err instanceof Error ? err.message : String(err)
@@ -1201336,7 +1201655,7 @@ async function executeSingleRule(ruleId) {
         db2.update(caldavCopiedEvents).set({ sourceEtag: sourceEvent.etag, updatedAt: now }).where(eq(caldavCopiedEvents.id, existingCopy.id)).run();
         updated++;
       } catch (err) {
-        logger8.error("Failed to update copied event", {
+        logger9.error("Failed to update copied event", {
           ruleId,
           sourceEventId: sourceEvent.id,
           destEventId: existingCopy.destEventId,
@@ -1201347,11 +1201666,11 @@ async function executeSingleRule(ruleId) {
   }
   db2.update(caldavCopyRules).set({ lastExecutedAt: now, updatedAt: now }).where(eq(caldavCopyRules.id, ruleId)).run();
   if (created > 0 || updated > 0) {
-    logger8.info("Copy rule executed", { ruleId, created, updated });
+    logger9.info("Copy rule executed", { ruleId, created, updated });
   }
   return { created, updated };
 }
-var logger8;
+var logger9;
 var init_copy_engine = __esm(() => {
   init_drizzle_orm();
   init_db2();
@@ -1201359,7 +1201678,7 @@ var init_copy_engine = __esm(() => {
   init_ical_helpers();
   init_caldav_account_manager();
   init_google_calendar_manager();
-  logger8 = createLogger("CalDAV:CopyEngine");
+  logger9 = createLogger("CalDAV:CopyEngine");
 });
 
 // node_modules/@hono/node-server/dist/index.mjs
@@ -1208351,6 +1208670,8 @@ async function updateTaskStatus(taskId, newStatus, newPosition) {
 // server/services/search-service.ts
 init_db2();
 init_drizzle_orm();
+init_schema();
+init_logger3();
 var ALL_ENTITIES = ["tasks", "projects", "messages", "events", "memories", "conversations"];
 async function search(options) {
   const entities = options.entities?.length ? options.entities : ALL_ENTITIES;
@@ -1208369,6 +1208690,8 @@ async function search(options) {
         return searchMemories2(options.query, { tags: options.memoryTags }, limit);
       case "conversations":
         return searchConversations(options.query, { role: options.conversationRole, provider: options.conversationProvider, projectId: options.conversationProjectId }, limit);
+      case "gmail":
+        return searchGmail(options.query, { from: options.gmailFrom, to: options.gmailTo, after: options.gmailAfter, before: options.gmailBefore }, limit);
     }
   });
   const resultSets = await Promise.all(searches);
@@ -1208572,6 +1208895,55 @@ async function searchConversations(query, filters, limit) {
     }
   }));
 }
+var logger6 = createLogger("SearchService");
+async function searchGmail(query, filters, limit) {
+  const accounts = db2.select().from(googleAccounts).where(eq(googleAccounts.gmailEnabled, true)).all();
+  if (!accounts.length)
+    return [];
+  const parts = [query];
+  if (filters.from)
+    parts.push(`from:${filters.from}`);
+  if (filters.to)
+    parts.push(`to:${filters.to}`);
+  if (filters.after)
+    parts.push(`after:${filters.after}`);
+  if (filters.before)
+    parts.push(`before:${filters.before}`);
+  const gmailQuery = parts.join(" ");
+  const { listMessages: listMessages2 } = await Promise.resolve().then(() => (init_gmail_service(), exports_gmail_service));
+  const results = await Promise.allSettled(accounts.map(async (account) => {
+    const messages2 = await listMessages2(account.id, {
+      query: gmailQuery,
+      maxResults: limit
+    });
+    return messages2.map((msg) => ({
+      entityType: "gmail",
+      id: msg.id,
+      title: msg.subject || "(no subject)",
+      snippet: msg.snippet || "",
+      score: 0.9,
+      metadata: {
+        threadId: msg.threadId,
+        from: msg.from,
+        to: msg.to,
+        date: msg.date,
+        labels: msg.labels,
+        accountId: account.id,
+        accountEmail: account.email,
+        gmailLink: `https://mail.google.com/mail/u/0/#inbox/${msg.id}`
+      }
+    }));
+  }));
+  const allResults = [];
+  for (const result of results) {
+    if (result.status === "fulfilled") {
+      allResults.push(...result.value);
+    } else {
+      logger6.warn("Gmail search failed for an account", { error: String(result.reason) });
+    }
+  }
+  return allResults.slice(0, limit);
+}
 function reindexTaskFTS(taskId) {
   db2.run(sql`
     UPDATE tasks SET updated_at = updated_at WHERE id = ${taskId}
@@ -1208643,7 +1209015,7 @@ var ALLOWED_MIME_TYPES = [
   "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
   "text/csv"
 ];
-var MAX_FILE_SIZE = 50 * 1024 * 1024;
+var MAX_FILE_SIZE2 = 50 * 1024 * 1024;
 function getTaskUploadsDir(taskId) {
   return path8.join(getFulcrumDir(), "uploads", "tasks", taskId);
 }
@@ -1209300,8 +1209672,8 @@ app2.post("/:id/attachments", async (c) => {
     if (!ALLOWED_MIME_TYPES.includes(file.type)) {
       return c.json({ error: `File type not allowed: ${file.type}` }, 400);
     }
-    if (file.size > MAX_FILE_SIZE) {
-      return c.json({ error: `File too large. Maximum size is ${MAX_FILE_SIZE / 1024 / 1024}MB` }, 400);
+    if (file.size > MAX_FILE_SIZE2) {
+      return c.json({ error: `File too large. Maximum size is ${MAX_FILE_SIZE2 / 1024 / 1024}MB` }, 400);
     }
     const uploadDir = getTaskUploadsDir(taskId);
     if (!fs11.existsSync(uploadDir)) {
@@ -1211891,7 +1212263,7 @@ init_drizzle_orm();
 init_nanoid();
 init_logger3();
 init_settings();
-import { existsSync as existsSync22, readFileSync as readFileSync12, writeFileSync as writeFileSync10, unlinkSync as unlinkSync7, mkdtempSync, rmSync as rmSync6 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync13, writeFileSync as writeFileSync10, unlinkSync as unlinkSync7, mkdtempSync, rmSync as rmSync6 } from "fs";
 import { join as join22 } from "path";
 import { tmpdir as tmpdir4 } from "os";
 import { execSync as execSync6 } from "child_process";
@@ -1211968,9 +1212340,9 @@ function fetchCopierYamlFromGit(gitUrl) {
     const yamlAltPath = join22(tempDir, "copier.yaml");
     let content = null;
     if (existsSync22(yamlPath)) {
-      content = readFileSync12(yamlPath, "utf-8");
+      content = readFileSync13(yamlPath, "utf-8");
     } else if (existsSync22(yamlAltPath)) {
-      content = readFileSync12(yamlAltPath, "utf-8");
+      content = readFileSync13(yamlAltPath, "utf-8");
     }
     if (!content) {
       rmSync6(tempDir, { recursive: true, force: true });
@@ -1211992,10 +1212364,10 @@ async function fetchCopierYaml(source) {
     const yamlPath = join22(templatePath, "copier.yml");
     const yamlAltPath = join22(templatePath, "copier.yaml");
     if (existsSync22(yamlPath)) {
-      return { content: readFileSync12(yamlPath, "utf-8"), templatePath };
+      return { content: readFileSync13(yamlPath, "utf-8"), templatePath };
     }
     if (existsSync22(yamlAltPath)) {
-      return { content: readFileSync12(yamlAltPath, "utf-8"), templatePath };
+      return { content: readFileSync13(yamlAltPath, "utf-8"), templatePath };
     }
     throw new Error("copier.yml not found in template directory");
   }
@@ -1212956,20 +1213328,20 @@ var VERSION4 = "7.0.6";
 var noop2 = () => {};
 var consoleWarn = console.warn.bind(console);
 var consoleError = console.error.bind(console);
-function createLogger2(logger6 = {}) {
-  if (typeof logger6.debug !== "function") {
-    logger6.debug = noop2;
+function createLogger2(logger7 = {}) {
+  if (typeof logger7.debug !== "function") {
+    logger7.debug = noop2;
   }
-  if (typeof logger6.info !== "function") {
-    logger6.info = noop2;
+  if (typeof logger7.info !== "function") {
+    logger7.info = noop2;
   }
-  if (typeof logger6.warn !== "function") {
-    logger6.warn = consoleWarn;
+  if (typeof logger7.warn !== "function") {
+    logger7.warn = consoleWarn;
   }
-  if (typeof logger6.error !== "function") {
-    logger6.error = consoleError;
+  if (typeof logger7.error !== "function") {
+    logger7.error = consoleError;
   }
-  return logger6;
+  return logger7;
 }
 var userAgentTrail = `octokit-core.js/${VERSION4} ${getUserAgent2()}`;
 
@@ -1215875,7 +1216247,7 @@ var github_default = app11;
 init_db2();
 init_pty_instance();
 init_dtach_service();
-import { readdirSync as readdirSync8, readFileSync as readFileSync13, readlinkSync as readlinkSync3, existsSync as existsSync23 } from "fs";
+import { readdirSync as readdirSync8, readFileSync as readFileSync14, readlinkSync as readlinkSync3, existsSync as existsSync23 } from "fs";
 import { execSync as execSync8 } from "child_process";
 import { homedir as homedir7 } from "os";
 import { join as join23 } from "path";
@@ -1216160,7 +1216532,7 @@ function findAllAgentProcesses(agentFilter) {
     for (const pidStr of procDirs) {
       const pid = parseInt(pidStr, 10);
       try {
-        const cmdline = readFileSync13(`/proc/${pid}/cmdline`, "utf-8");
+        const cmdline = readFileSync14(`/proc/${pid}/cmdline`, "utf-8");
         if (combinedPattern.test(cmdline)) {
           const agent = detectAgentType(cmdline);
           if (agent && (!agentFilter || agentFilter.includes(agent))) {
@@ -1216216,7 +1216588,7 @@ function getProcessCwd(pid) {
 }
 function getProcessMemoryMB(pid) {
   try {
-    const status = readFileSync13(`/proc/${pid}/status`, "utf-8");
+    const status = readFileSync14(`/proc/${pid}/status`, "utf-8");
     const match3 = status.match(/VmRSS:\s+(\d+)\s+kB/);
     return match3 ? parseInt(match3[1], 10) / 1024 : 0;
   } catch {
@@ -1216231,10 +1216603,10 @@ function getProcessMemoryMB(pid) {
 function getProcessStartTime(pid) {
   if (!isMacOS2) {
     try {
-      const stat2 = readFileSync13(`/proc/${pid}/stat`, "utf-8");
+      const stat2 = readFileSync14(`/proc/${pid}/stat`, "utf-8");
       const fields = stat2.split(" ");
       const starttime = parseInt(fields[21], 10);
-      const uptime = parseFloat(readFileSync13("/proc/uptime", "utf-8").split(" ")[0]);
+      const uptime = parseFloat(readFileSync14("/proc/uptime", "utf-8").split(" ")[0]);
       const clockTicks = 100;
       const bootTime = Math.floor(Date.now() / 1000) - uptime;
       return Math.floor(bootTime + starttime / clockTicks);
@@ -1216309,7 +1216681,7 @@ monitoringRoutes.get("/claude-instances", (c) => {
           for (const pidStr of procDirs) {
             const pid = parseInt(pidStr, 10);
             try {
-              const cmdline = readFileSync13(`/proc/${pid}/cmdline`, "utf-8");
+              const cmdline = readFileSync14(`/proc/${pid}/cmdline`, "utf-8");
               if (cmdline.includes(socketPath)) {
                 foundPids.push(pid);
               }
@@ -1216403,7 +1216775,7 @@ monitoringRoutes.post("/claude-instances/:pid/kill-pid", (c) => {
     return c.json({ error: "Invalid PID" }, 400);
   }
   try {
-    const cmdline = readFileSync13(`/proc/${pid}/cmdline`, "utf-8");
+    const cmdline = readFileSync14(`/proc/${pid}/cmdline`, "utf-8");
     const agent = detectAgentType(cmdline);
     if (!agent) {
       return c.json({ error: "Process is not a recognized AI agent" }, 400);
@@ -1216429,7 +1216801,7 @@ function getTotalMemory() {
     }
   }
   try {
-    const meminfo = readFileSync13("/proc/meminfo", "utf-8");
+    const meminfo = readFileSync14("/proc/meminfo", "utf-8");
     const match3 = meminfo.match(/MemTotal:\s+(\d+)/);
     return match3 ? parseInt(match3[1], 10) * 1024 : 0;
   } catch {
@@ -1216645,7 +1217017,7 @@ monitoringRoutes.get("/docker-stats", async (c) => {
 });
 function getProcessEnv(pid) {
   try {
-    const environ = readFileSync13(`/proc/${pid}/environ`, "utf-8");
+    const environ = readFileSync14(`/proc/${pid}/environ`, "utf-8");
     const env = {};
     for (const entry of environ.split("\x00")) {
       const idx = entry.indexOf("=");
@@ -1216660,7 +1217032,7 @@ function getProcessEnv(pid) {
 }
 function getParentPid(pid) {
   try {
-    const stat2 = readFileSync13(`/proc/${pid}/stat`, "utf-8");
+    const stat2 = readFileSync14(`/proc/${pid}/stat`, "utf-8");
     const match3 = stat2.match(/^\d+ \([^)]+\) \S+ (\d+)/);
     return match3 ? parseInt(match3[1], 10) : null;
   } catch {
@@ -1216675,7 +1217047,7 @@ function findFulcrumInstances() {
     for (const pidStr of procDirs) {
       const pid = parseInt(pidStr, 10);
       try {
-        const cmdline = readFileSync13(`/proc/${pid}/cmdline`, "utf-8").replace(/\0/g, " ");
+        const cmdline = readFileSync14(`/proc/${pid}/cmdline`, "utf-8").replace(/\0/g, " ");
         const env = getProcessEnv(pid);
         const parentPid = getParentPid(pid);
         const cmdParts = cmdline.trim().split(/\s+/);
@@ -1216791,7 +1217163,7 @@ async function getClaudeOAuthToken() {
   const primaryPath = join23(homedir7(), ".claude", ".credentials.json");
   try {
     if (existsSync23(primaryPath)) {
-      const content = readFileSync13(primaryPath, "utf-8");
+      const content = readFileSync14(primaryPath, "utf-8");
       const config = JSON.parse(content);
       if (config.claudeAiOauth && typeof config.claudeAiOauth === "object") {
         const token = config.claudeAiOauth.accessToken;
@@ -1218385,7 +1218757,7 @@ init_logger3();
 import { execSync as execSync10 } from "child_process";
 import { homedir as homedir10, platform as platform2 } from "os";
 import { join as join33 } from "path";
-import { existsSync as existsSync27, mkdirSync as mkdirSync10, writeFileSync as writeFileSync11, readFileSync as readFileSync15, unlinkSync as unlinkSync8 } from "fs";
+import { existsSync as existsSync27, mkdirSync as mkdirSync10, writeFileSync as writeFileSync11, readFileSync as readFileSync16, unlinkSync as unlinkSync8 } from "fs";
 var USER_UNIT_DIR = join33(homedir10(), ".config/systemd/user");
 var systemdAvailable = null;
 function isSystemdAvailable() {
@@ -1218613,11 +1218985,11 @@ function getTimer(name, scope) {
   let workingDirectory = null;
   if (scope === "user" && unitPath) {
     try {
-      timerContent = readFileSync15(unitPath, "utf-8");
+      timerContent = readFileSync16(unitPath, "utf-8");
     } catch {}
     const servicePath = unitPath.replace(".timer", ".service");
     try {
-      serviceContent = readFileSync15(servicePath, "utf-8");
+      serviceContent = readFileSync16(servicePath, "utf-8");
       const execMatch = serviceContent.match(/^ExecStart=(.+)$/m);
       if (execMatch) {
         command = execMatch[1];
@@ -1218822,8 +1219194,8 @@ function updateTimer(name, updates) {
   if (!existsSync27(timerPath)) {
     throw new Error(`Timer ${timerName} not found`);
   }
-  let timerContent = readFileSync15(timerPath, "utf-8");
-  let serviceContent = existsSync27(servicePath) ? readFileSync15(servicePath, "utf-8") : "";
+  let timerContent = readFileSync16(timerPath, "utf-8");
+  let serviceContent = existsSync27(servicePath) ? readFileSync16(servicePath, "utf-8") : "";
   if (updates.description !== undefined) {
     timerContent = timerContent.replace(/^Description=.*$/m, `Description=${updates.description}`);
     serviceContent = serviceContent.replace(/^Description=.*$/m, `Description=${updates.description}`);
@@ -1219797,7 +1220169,7 @@ var ALLOWED_MIME_TYPES2 = [
   "application/gzip",
   "application/x-tar"
 ];
-var MAX_FILE_SIZE2 = 10 * 1024 * 1024;
+var MAX_FILE_SIZE3 = 10 * 1024 * 1024;
 function sanitizeFilename2(filename) {
   return filename.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
@@ -1220784,8 +1221156,8 @@ app19.post("/:id/attachments", async (c) => {
     if (!ALLOWED_MIME_TYPES2.includes(file.type)) {
       return c.json({ error: `File type not allowed: ${file.type}` }, 400);
     }
-    if (file.size > MAX_FILE_SIZE2) {
-      return c.json({ error: `File too large. Maximum size is ${MAX_FILE_SIZE2 / 1024 / 1024}MB` }, 400);
+    if (file.size > MAX_FILE_SIZE3) {
+      return c.json({ error: `File too large. Maximum size is ${MAX_FILE_SIZE3 / 1024 / 1024}MB` }, 400);
     }
     const uploadDir = getProjectUploadsDir(projectId);
     if (!fs17.existsSync(uploadDir)) {
@@ -1251838,6 +1252210,27 @@ var toolRegistry = [
     keywords: ["memory", "store", "save", "remember", "knowledge", "persist", "fact"],
     defer_loading: false
   },
+  {
+    name: "memory_search",
+    description: "Search persistent memories using full-text search (FTS5)",
+    category: "memory",
+    keywords: ["memory", "search", "find", "query", "fts", "recall", "knowledge"],
+    defer_loading: false
+  },
+  {
+    name: "memory_list",
+    description: "List persistent memories with optional tag filter",
+    category: "memory",
+    keywords: ["memory", "list", "browse", "tags", "filter", "all"],
+    defer_loading: false
+  },
+  {
+    name: "memory_delete",
+    description: "Delete a persistent memory by ID",
+    category: "memory",
+    keywords: ["memory", "delete", "remove", "clean", "resolved", "outdated"],
+    defer_loading: false
+  },
   {
     name: "memory_file_read",
     description: "Read the master memory file (MEMORY.md)",
@@ -1251854,9 +1252247,9 @@ var toolRegistry = [
   },
   {
     name: "search",
-    description: "Search across all Fulcrum entities (tasks, projects, messages, events, memories) using full-text search",
+    description: "Search across all Fulcrum entities (tasks, projects, messages, events, memories, gmail) using full-text search",
     category: "core",
-    keywords: ["search", "find", "query", "fts", "full-text", "task", "project", "message", "event", "memory", "recall", "knowledge"],
+    keywords: ["search", "find", "query", "fts", "full-text", "task", "project", "message", "event", "memory", "recall", "knowledge", "gmail", "email", "google"],
     defer_loading: false
   },
   {
@@ -1251938,7 +1252331,7 @@ var registerCoreTools = (server2, _client) => {
 };
 
 // cli/src/mcp/tools/tasks.ts
-import { basename as basename3 } from "path";
+import { basename as basename4 } from "path";
 
 // shared/date-utils.ts
 function getTodayInTimezone(timezone) {
@@ -1251959,7 +1252352,7 @@ function getTodayInTimezone(timezone) {
 }
 
 // cli/src/mcp/tools/tasks.ts
-var registerTaskTools = (server2, client3) => {
+function registerListTasks(server2, client3) {
   server2.tool("list_tasks", "List all Fulcrum tasks with flexible filtering. Supports text search across title/tags/project, multi-tag filtering (OR logic), multi-status filtering, date range, and overdue detection.", {
     status: exports_external.optional(TaskStatusSchema2).describe("Filter by single task status (use statuses for multiple)"),
     statuses: exports_external.optional(exports_external.array(TaskStatusSchema2)).describe("Filter by multiple statuses (OR logic)"),
@@ -1252051,20 +1252444,8 @@ var registerTaskTools = (server2, client3) => {
       return handleToolError(err);
     }
   });
-  server2.tool("get_task", "Get details of a specific task by ID, including dependencies and attachments", {
-    id: exports_external.string().describe("Task ID (UUID)")
-  }, async ({ id }) => {
-    try {
-      const [task, dependencies, attachments] = await Promise.all([
-        client3.getTask(id),
-        client3.getTaskDependencies(id),
-        client3.listTaskAttachments(id)
-      ]);
-      return formatSuccess({ ...task, dependencies, attachments });
-    } catch (err) {
-      return handleToolError(err);
-    }
-  });
+}
+function registerCreateTask(server2, client3) {
   server2.tool("create_task", "Create a new task. For worktree tasks, provide repoPath to create a git worktree. For non-worktree tasks, omit repoPath. When tags are provided, returns all existing tags for reference.", {
     title: exports_external.string().describe("Task title"),
     repoPath: exports_external.optional(exports_external.string()).describe("Absolute path to the git repository (optional for non-worktree tasks)"),
@@ -1252089,7 +1252470,7 @@ var registerTaskTools = (server2, client3) => {
     dueDate
   }) => {
     try {
-      const repoName = repoPath ? basename3(repoPath) : null;
+      const repoName = repoPath ? basename4(repoPath) : null;
       const effectiveBaseBranch = baseBranch ?? "main";
       const task = await client3.createTask({
         title,
@@ -1252125,6 +1252506,8 @@ var registerTaskTools = (server2, client3) => {
       return handleToolError(err);
     }
   });
+}
+function registerUpdateTask(server2, client3) {
   server2.tool("update_task", "Update task metadata (title or description)", {
     id: exports_external.string().describe("Task ID"),
     title: exports_external.optional(exports_external.string()).describe("New title"),
@@ -1252142,6 +1252525,82 @@ var registerTaskTools = (server2, client3) => {
       return handleToolError(err);
     }
   });
+}
+function registerAddTaskLink(server2, client3) {
+  server2.tool("add_task_link", "Add a URL link to a task (for documentation, related PRs, design files, etc.)", {
+    taskId: exports_external.string().describe("Task ID"),
+    url: exports_external.string().url().describe("URL to add"),
+    label: exports_external.optional(exports_external.string()).describe("Display label (auto-detected if not provided)")
+  }, async ({ taskId, url: url2, label }) => {
+    try {
+      const link = await client3.addTaskLink(taskId, url2, label);
+      return formatSuccess(link);
+    } catch (err) {
+      return handleToolError(err);
+    }
+  });
+}
+function registerAddTaskTag(server2, client3) {
+  server2.tool("add_task_tag", "Add a tag to a task for categorization. Returns similar existing tags to help catch typos.", {
+    taskId: exports_external.string().describe("Task ID"),
+    tag: exports_external.string().describe("Tag to add")
+  }, async ({ taskId, tag }) => {
+    try {
+      const result = await client3.addTaskTag(taskId, tag);
+      const allTasks = await client3.listTasks();
+      const existingTags = new Set;
+      for (const t of allTasks) {
+        if (t.tags) {
+          for (const tg of t.tags) {
+            existingTags.add(tg);
+          }
+        }
+      }
+      const tagLower = tag.toLowerCase();
+      const similarTags = Array.from(existingTags).filter((tg) => tg !== tag && (tg.toLowerCase().includes(tagLower) || tagLower.includes(tg.toLowerCase())));
+      return formatSuccess({
+        ...result,
+        similarTags: similarTags.length > 0 ? similarTags : undefined
+      });
+    } catch (err) {
+      return handleToolError(err);
+    }
+  });
+}
+function registerSetTaskDueDate(server2, client3) {
+  server2.tool("set_task_due_date", "Set or clear the due date for a task", {
+    taskId: exports_external.string().describe("Task ID"),
+    dueDate: exports_external.nullable(exports_external.string()).describe("Due date in YYYY-MM-DD format, or null to clear")
+  }, async ({ taskId, dueDate }) => {
+    try {
+      const result = await client3.setTaskDueDate(taskId, dueDate);
+      return formatSuccess(result);
+    } catch (err) {
+      return handleToolError(err);
+    }
+  });
+}
+var registerTaskTools = (server2, client3) => {
+  registerListTasks(server2, client3);
+  registerCreateTask(server2, client3);
+  registerUpdateTask(server2, client3);
+  registerAddTaskLink(server2, client3);
+  registerAddTaskTag(server2, client3);
+  registerSetTaskDueDate(server2, client3);
+  server2.tool("get_task", "Get details of a specific task by ID, including dependencies and attachments", {
+    id: exports_external.string().describe("Task ID (UUID)")
+  }, async ({ id }) => {
+    try {
+      const [task, dependencies, attachments] = await Promise.all([
+        client3.getTask(id),
+        client3.getTaskDependencies(id),
+        client3.listTaskAttachments(id)
+      ]);
+      return formatSuccess({ ...task, dependencies, attachments });
+    } catch (err) {
+      return handleToolError(err);
+    }
+  });
   server2.tool("delete_task", "Delete a task and optionally its linked git worktree", {
     id: exports_external.string().describe("Task ID"),
     deleteWorktree: exports_external.optional(exports_external.boolean()).describe("Also delete the linked git worktree (default: false)")
@@ -1252166,18 +1252625,6 @@ var registerTaskTools = (server2, client3) => {
       return handleToolError(err);
     }
   });
-  server2.tool("add_task_link", "Add a URL link to a task (for documentation, related PRs, design files, etc.)", {
-    taskId: exports_external.string().describe("Task ID"),
-    url: exports_external.string().url().describe("URL to add"),
-    label: exports_external.optional(exports_external.string()).describe("Display label (auto-detected if not provided)")
-  }, async ({ taskId, url: url2, label }) => {
-    try {
-      const link = await client3.addTaskLink(taskId, url2, label);
-      return formatSuccess(link);
-    } catch (err) {
-      return handleToolError(err);
-    }
-  });
   server2.tool("remove_task_link", "Remove a URL link from a task", {
     taskId: exports_external.string().describe("Task ID"),
     linkId: exports_external.string().describe("Link ID to remove")
@@ -1252199,31 +1252646,6 @@ var registerTaskTools = (server2, client3) => {
       return handleToolError(err);
     }
   });
-  server2.tool("add_task_tag", "Add a tag to a task for categorization. Returns similar existing tags to help catch typos.", {
-    taskId: exports_external.string().describe("Task ID"),
-    tag: exports_external.string().describe("Tag to add")
-  }, async ({ taskId, tag }) => {
-    try {
-      const result = await client3.addTaskTag(taskId, tag);
-      const allTasks = await client3.listTasks();
-      const existingTags = new Set;
-      for (const t of allTasks) {
-        if (t.tags) {
-          for (const tg of t.tags) {
-            existingTags.add(tg);
-          }
-        }
-      }
-      const tagLower = tag.toLowerCase();
-      const similarTags = Array.from(existingTags).filter((tg) => tg !== tag && (tg.toLowerCase().includes(tagLower) || tagLower.includes(tg.toLowerCase())));
-      return formatSuccess({
-        ...result,
-        similarTags: similarTags.length > 0 ? similarTags : undefined
-      });
-    } catch (err) {
-      return handleToolError(err);
-    }
-  });
   server2.tool("remove_task_tag", "Remove a tag from a task", {
     taskId: exports_external.string().describe("Task ID"),
     tag: exports_external.string().describe("Tag to remove")
@@ -1252235,17 +1252657,6 @@ var registerTaskTools = (server2, client3) => {
       return handleToolError(err);
     }
   });
-  server2.tool("set_task_due_date", "Set or clear the due date for a task", {
-    taskId: exports_external.string().describe("Task ID"),
-    dueDate: exports_external.nullable(exports_external.string()).describe("Due date in YYYY-MM-DD format, or null to clear")
-  }, async ({ taskId, dueDate }) => {
-    try {
-      const result = await client3.setTaskDueDate(taskId, dueDate);
-      return formatSuccess(result);
-    } catch (err) {
-      return handleToolError(err);
-    }
-  });
   server2.tool("get_task_dependencies", "Get the dependencies and dependents of a task, and whether it is blocked", {
     taskId: exports_external.string().describe("Task ID")
   }, async ({ taskId }) => {
@@ -1252404,6 +1252815,14 @@ var registerTaskTools = (server2, client3) => {
     }
   });
 };
+var registerTaskObserverTools = (server2, client3) => {
+  registerListTasks(server2, client3);
+  registerCreateTask(server2, client3);
+  registerUpdateTask(server2, client3);
+  registerAddTaskLink(server2, client3);
+  registerAddTaskTag(server2, client3);
+  registerSetTaskDueDate(server2, client3);
+};
 
 // cli/src/mcp/tools/repositories.ts
 var registerRepositoryTools = (server2, client3) => {
@@ -1253293,8 +1253712,9 @@ var registerAssistantTools = (server2, client3) => {
     subject: exports_external.optional(exports_external.string()).describe("Email subject (for Gmail channel only)"),
     replyToMessageId: exports_external.optional(exports_external.string()).describe("Message ID to reply to (for threading)"),
     slack_blocks: exports_external.optional(exports_external.array(exports_external.record(exports_external.string(), exports_external.any()))).describe("Slack Block Kit blocks for rich formatting (Slack channel only). Array of block objects."),
+    filePath: exports_external.optional(exports_external.string()).describe("Absolute path to a local file to upload alongside the message (Slack only). Use for sending images, documents, etc."),
     googleAccountId: exports_external.optional(exports_external.string()).describe("Google account ID for Gmail channel. If omitted, auto-resolves when exactly one Gmail-enabled account exists.")
-  }, async ({ channel, body, subject, replyToMessageId, slack_blocks, googleAccountId }) => {
+  }, async ({ channel, body, subject, replyToMessageId, slack_blocks, filePath, googleAccountId }) => {
     try {
       if (channel === "gmail") {
         let accountId = googleAccountId;
@@ -1253317,7 +1253737,8 @@ var registerAssistantTools = (server2, client3) => {
         body,
         subject,
         replyToMessageId,
-        slackBlocks: slack_blocks
+        slackBlocks: slack_blocks,
+        filePath
       });
       return formatSuccess(result);
     } catch (err) {
@@ -1253588,7 +1254009,7 @@ var MEMORY_SOURCES = [
 ];
 
 // cli/src/mcp/tools/memory.ts
-var registerMemoryTools = (server2, client3) => {
+function registerMemoryStoreTool(server2, client3) {
   server2.tool("memory_store", "Store a piece of knowledge in persistent memory. Use this to remember facts, preferences, decisions, patterns, or any information that should persist across conversations.", {
     content: exports_external.string().describe("The memory content to store. Be specific and self-contained."),
     tags: exports_external.optional(exports_external.array(exports_external.string())).describe('Optional tags for categorization (e.g., ["preference", "architecture", "decision"])'),
@@ -1253601,10 +1254022,61 @@ var registerMemoryTools = (server2, client3) => {
       return handleToolError(err);
     }
   });
+}
+function registerMemorySearchTool(server2, client3) {
+  server2.tool("memory_search", 'Search persistent memories using full-text search (FTS5). Supports boolean operators (AND, OR, NOT), phrase matching ("quoted"), and prefix matching (term*).', {
+    query: exports_external.string().describe('Search query. Supports FTS5 syntax: AND, OR, NOT, "phrases", prefix*'),
+    tags: exports_external.optional(exports_external.array(exports_external.string())).describe('Filter by tags (e.g., ["actionable", "preference"])'),
+    limit: exports_external.optional(exports_external.number()).describe("Max results to return (default: 20)")
+  }, async ({ query, tags: tags2, limit: limit2 }) => {
+    try {
+      const result = await client3.searchMemories({ query, tags: tags2, limit: limit2 });
+      return formatSuccess(result);
+    } catch (err) {
+      return handleToolError(err);
+    }
+  });
+}
+function registerMemoryListTool(server2, client3) {
+  server2.tool("memory_list", "List all persistent memories, optionally filtered by tags. Returns memories sorted by creation date (newest first).", {
+    tags: exports_external.optional(exports_external.array(exports_external.string())).describe('Filter by tags (e.g., ["actionable"])'),
+    limit: exports_external.optional(exports_external.number()).describe("Max results to return (default: 50)"),
+    offset: exports_external.optional(exports_external.number()).describe("Offset for pagination")
+  }, async ({ tags: tags2, limit: limit2, offset }) => {
+    try {
+      const result = await client3.listMemories({ tags: tags2, limit: limit2, offset });
+      return formatSuccess(result);
+    } catch (err) {
+      return handleToolError(err);
+    }
+  });
+}
+function registerMemoryDeleteTool(server2, client3) {
+  server2.tool("memory_delete", "Delete a persistent memory by ID. Use this to clean up resolved or outdated memories.", {
+    id: exports_external.string().describe("The ID of the memory to delete")
+  }, async ({ id }) => {
+    try {
+      const result = await client3.deleteMemory(id);
+      return formatSuccess(result);
+    } catch (err) {
+      return handleToolError(err);
+    }
+  });
+}
+var registerMemoryTools = (server2, client3) => {
+  registerMemoryStoreTool(server2, client3);
+  registerMemorySearchTool(server2, client3);
+  registerMemoryListTool(server2, client3);
+  registerMemoryDeleteTool(server2, client3);
+};
+var registerMemoryObserverTools = (server2, client3) => {
+  registerMemoryStoreTool(server2, client3);
+  registerMemorySearchTool(server2, client3);
+  registerMemoryListTool(server2, client3);
 };
 
 // cli/src/mcp/tools/memory-file.ts
-var registerMemoryFileTools = (server2, client3) => {
+var registerMemoryFileReadTool = (server2, client3) => {
   server2.tool("memory_file_read", "Read the master memory file (MEMORY.md). This file contains persistent knowledge, user preferences, and instructions that are included in every conversation.", {}, async () => {
     try {
       const result = await client3.readMemoryFile();
@@ -1253613,6 +1254085,9 @@ var registerMemoryFileTools = (server2, client3) => {
       return handleToolError(err);
     }
   });
+};
+var registerMemoryFileTools = (server2, client3) => {
+  registerMemoryFileReadTool(server2, client3);
   server2.tool("memory_file_update", "Update the master memory file. Provide full content to replace the entire file, or specify a section heading to update just that section. The memory file is included in every conversation, so keep it organized and concise.", {
     content: exports_external.string().describe("The content to write. If section is specified, this replaces only that section body."),
     section: exports_external.optional(exports_external.string()).describe('Optional markdown heading (e.g., "## Preferences") to update a specific section. If omitted, replaces the entire file.')
@@ -1253645,9 +1254120,9 @@ var registerMessagingTools = (server2, client3) => {
 };
 
 // cli/src/mcp/tools/search.ts
-var EntityTypeSchema = exports_external.enum(["tasks", "projects", "messages", "events", "memories", "conversations"]);
+var EntityTypeSchema = exports_external.enum(["tasks", "projects", "messages", "events", "memories", "conversations", "gmail"]);
 var registerSearchTools = (server2, client3) => {
-  server2.tool("search", 'Search across all Fulcrum entities (tasks, projects, messages, calendar events, memories, conversations) using full-text search. Supports boolean operators (AND, OR, NOT), phrase matching ("quoted phrases"), and prefix matching (term*). Returns results ranked by relevance.', {
+  server2.tool("search", 'Search across all Fulcrum entities (tasks, projects, messages, calendar events, memories, conversations) using full-text search. Supports boolean operators (AND, OR, NOT), phrase matching ("quoted phrases"), and prefix matching (term*). Returns results ranked by relevance. Gmail search is opt-in: include "gmail" in entities to search Gmail via API (not included in default searches).', {
     query: exports_external.string().describe('FTS5 search query. Supports: AND, OR, NOT operators, "quoted phrases", prefix* matching. Example: "kubernetes deployment" OR k8s'),
     entities: exports_external.optional(exports_external.array(EntityTypeSchema)).describe("Entity types to search. Defaults to all: tasks, projects, messages, events, memories, conversations"),
     limit: exports_external.optional(exports_external.number()).describe("Maximum results per entity type (default: 10)"),
@@ -1253660,8 +1254135,12 @@ var registerSearchTools = (server2, client3) => {
     memoryTags: exports_external.optional(exports_external.array(exports_external.string())).describe("Filter memories by tags"),
     conversationRole: exports_external.optional(exports_external.string()).describe('Filter conversations by role (e.g., "user", "assistant")'),
     conversationProvider: exports_external.optional(exports_external.string()).describe('Filter conversations by provider (e.g., "claude", "opencode")'),
-    conversationProjectId: exports_external.optional(exports_external.string()).describe("Filter conversations by project ID")
-  }, async ({ query, entities, limit: limit2, taskStatus, projectStatus, messageChannel, messageDirection, eventFrom, eventTo, memoryTags, conversationRole, conversationProvider, conversationProjectId }) => {
+    conversationProjectId: exports_external.optional(exports_external.string()).describe("Filter conversations by project ID"),
+    gmailFrom: exports_external.optional(exports_external.string()).describe('Filter Gmail results by sender (e.g., "user@example.com")'),
+    gmailTo: exports_external.optional(exports_external.string()).describe('Filter Gmail results by recipient (e.g., "user@example.com")'),
+    gmailAfter: exports_external.optional(exports_external.string()).describe("Filter Gmail results after this date (YYYY/MM/DD format)"),
+    gmailBefore: exports_external.optional(exports_external.string()).describe("Filter Gmail results before this date (YYYY/MM/DD format)")
+  }, async ({ query, entities, limit: limit2, taskStatus, projectStatus, messageChannel, messageDirection, eventFrom, eventTo, memoryTags, conversationRole, conversationProvider, conversationProjectId, gmailFrom, gmailTo, gmailAfter, gmailBefore }) => {
     try {
       const results = await client3.search({
         query,
@@ -1253676,7 +1254155,11 @@ var registerSearchTools = (server2, client3) => {
         memoryTags,
         conversationRole,
         conversationProvider,
-        conversationProjectId
+        conversationProjectId,
+        gmailFrom,
+        gmailTo,
+        gmailAfter,
+        gmailBefore
       });
       return formatSuccess(results);
     } catch (err) {
@@ -1253707,7 +1254190,7 @@ function registerTools(server2, client3) {
   registerSearchTools(server2, client3);
 }
 // cli/src/utils/server.ts
-import { existsSync as existsSync31, readFileSync as readFileSync17, writeFileSync as writeFileSync13, mkdirSync as mkdirSync12, cpSync } from "fs";
+import { existsSync as existsSync31, readFileSync as readFileSync18, writeFileSync as writeFileSync13, mkdirSync as mkdirSync12, cpSync } from "fs";
 import { join as join37 } from "path";
 import { homedir as homedir13 } from "os";
 var DEFAULT_PORT = 7777;
@@ -1253731,7 +1254214,7 @@ function expandPath2(p3) {
 function readSettingsFile(path14) {
   try {
     if (existsSync31(path14)) {
-      const content = readFileSync17(path14, "utf-8");
+      const content = readFileSync18(path14, "utf-8");
       return JSON.parse(content);
     }
   } catch {}
@@ -1253771,8 +1254254,8 @@ function discoverServerUrl(urlOverride, portOverride) {
 }
 
 // cli/src/client.ts
-import { readFileSync as readFileSync18 } from "fs";
-import { basename as basename4 } from "path";
+import { readFileSync as readFileSync19 } from "fs";
+import { basename as basename5 } from "path";
 
 class FulcrumClient {
   baseUrl;
@@ -1254034,8 +1254517,8 @@ class FulcrumClient {
     return this.fetch(`/api/tasks/${taskId}/attachments`);
   }
   async uploadTaskAttachment(taskId, filePath) {
-    const fileContent = readFileSync18(filePath);
-    const filename = basename4(filePath);
+    const fileContent = readFileSync19(filePath);
+    const filename = basename5(filePath);
     const formData = new FormData;
     const blob3 = new Blob([fileContent]);
     formData.append("file", blob3, filename);
@@ -1254121,8 +1254604,8 @@ class FulcrumClient {
     return this.fetch(`/api/projects/${projectId}/attachments`);
   }
   async uploadProjectAttachment(projectId, filePath) {
-    const fileContent = readFileSync18(filePath);
-    const filename = basename4(filePath);
+    const fileContent = readFileSync19(filePath);
+    const filename = basename5(filePath);
     const formData = new FormData;
     const blob3 = new Blob([fileContent]);
     formData.append("file", blob3, filename);
@@ -1254516,6 +1254999,14 @@ class FulcrumClient {
       params.set("conversationProvider", input.conversationProvider);
     if (input.conversationProjectId)
       params.set("conversationProjectId", input.conversationProjectId);
+    if (input.gmailFrom)
+      params.set("gmailFrom", input.gmailFrom);
+    if (input.gmailTo)
+      params.set("gmailTo", input.gmailTo);
+    if (input.gmailAfter)
+      params.set("gmailAfter", input.gmailAfter);
+    if (input.gmailBefore)
+      params.set("gmailBefore", input.gmailBefore);
     return this.fetch(`/api/search?${params.toString()}`);
   }
 }
@@ -1254531,7 +1255022,7 @@ mcpRoutes.all("/", async (c) => {
   });
   const server2 = new McpServer({
     name: "fulcrum",
-    version: "3.2.1"
+    version: "3.4.0"
   });
   const client3 = new FulcrumClient(`http://localhost:${port}`);
   registerTools(server2, client3);
@@ -1254554,8 +1255045,10 @@ mcpObserverRoutes.all("/", async (c) => {
     version: "2.12.0"
   });
   const client3 = new FulcrumClient(`http://localhost:${port}`);
-  registerMemoryTools(server2, client3);
-  registerMemoryFileTools(server2, client3);
+  registerMemoryObserverTools(server2, client3);
+  registerMemoryFileReadTool(server2, client3);
+  registerTaskObserverTools(server2, client3);
+  registerNotificationTools(server2, client3);
   await server2.connect(transport);
   return transport.handleRequest(c.req.raw);
 });
@@ -1255616,7 +1256109,8 @@ app23.post("/send", async (c) => {
     const result = await sendMessageToChannel(body.channel, body.body, {
       subject: body.subject,
       replyToMessageId: body.replyToMessageId,
-      slackBlocks: body.slackBlocks
+      slackBlocks: body.slackBlocks,
+      filePath: body.filePath
     });
     if (result.success) {
       log2.messaging.info("Message sent via API", {
@@ -1255855,7 +1256349,7 @@ init_logger3();
 init_ical_helpers();
 init_caldav_account_manager();
 init_google_calendar_manager();
-var logger9 = createLogger("CalDAV");
+var logger10 = createLogger("CalDAV");
 function migrateFromSettings() {
   const settings = getSettings();
   const caldavSettings = settings.caldav;
@@ -1255871,7 +1256365,7 @@ function migrateFromSettings() {
       return;
     return;
   }
-  logger9.info("Migrating CalDAV credentials from settings.json to database", {
+  logger10.info("Migrating CalDAV credentials from settings.json to database", {
     authType: caldavSettings.authType,
     orphanedCalendars: orphanedCalendars.length
   });
@@ -1255896,28 +1256390,28 @@ function migrateFromSettings() {
   for (const cal of orphanedCalendars) {
     db2.update(caldavCalendars).set({ accountId, updatedAt: now }).where(eq(caldavCalendars.id, cal.id)).run();
   }
-  logger9.info("Migration complete", { accountId, migratedCalendars: orphanedCalendars.length });
+  logger10.info("Migration complete", { accountId, migratedCalendars: orphanedCalendars.length });
 }
 async function startCaldavSync() {
   const settings = getSettings();
   if (!settings.caldav?.enabled) {
-    logger9.info("CalDAV disabled, skipping sync start");
+    logger10.info("CalDAV disabled, skipping sync start");
     return;
   }
   migrateFromSettings();
   await accountManager.startAll();
   await accountManager.syncAll().catch((err) => {
-    logger9.error("Initial sync failed", { error: err instanceof Error ? err.message : String(err) });
+    logger10.error("Initial sync failed", { error: err instanceof Error ? err.message : String(err) });
   });
   await executeCopyRules().catch((err) => {
-    logger9.error("Copy rules execution failed after sync", {
+    logger10.error("Copy rules execution failed after sync", {
       error: err instanceof Error ? err.message : String(err)
     });
   });
 }
 function stopCaldavSync() {
   accountManager.stopAll();
-  logger9.info("CalDAV sync stopped");
+  logger10.info("CalDAV sync stopped");
 }
 function getCaldavStatus() {
   const accounts = accountManager.getStatus();
@@ -1255960,7 +1256454,7 @@ async function createAccount2(input) {
     updatedAt: now
   };
   db2.insert(caldavAccounts).values(account2).run();
-  logger9.info("Created CalDAV account", { id, name: input.name });
+  logger10.info("Created CalDAV account", { id, name: input.name });
   return account2;
 }
 async function updateAccount(id, updates) {
@@ -1255988,7 +1256482,7 @@ async function deleteAccount(id) {
   }
   db2.delete(caldavCalendars).where(eq(caldavCalendars.accountId, id)).run();
   db2.delete(caldavAccounts).where(eq(caldavAccounts.id, id)).run();
-  logger9.info("Deleted CalDAV account", { id });
+  logger10.info("Deleted CalDAV account", { id });
 }
 async function enableAccount(id) {
   db2.update(caldavAccounts).set({ enabled: true, updatedAt: new Date().toISOString() }).where(eq(caldavAccounts.id, id)).run();
@@ -1256024,7 +1256518,7 @@ async function testAccountConnection(config3) {
 async function syncAccount(id) {
   await accountManager.syncAccount(id);
   await executeCopyRules().catch((err) => {
-    logger9.error("Copy rules failed after account sync", {
+    logger10.error("Copy rules failed after account sync", {
       error: err instanceof Error ? err.message : String(err)
     });
   });
@@ -1256130,7 +1256624,7 @@ function listCalendars(accountId) {
 async function syncCalendars2() {
   await accountManager.syncAll();
   await executeCopyRules().catch((err) => {
-    logger9.error("Copy rules failed after sync", {
+    logger10.error("Copy rules failed after sync", {
       error: err instanceof Error ? err.message : String(err)
     });
   });
@@ -1256221,7 +1256715,7 @@ async function createEvent(input) {
     updatedAt: now
   };
   db2.insert(caldavEvents).values(event).run();
-  logger9.info("Created CalDAV event", { id, summary: input.summary });
+  logger10.info("Created CalDAV event", { id, summary: input.summary });
   return event;
 }
 async function updateEvent(id, updates) {
@@ -1256271,7 +1256765,7 @@ async function updateEvent(id, updates) {
     rawIcal: updatedIcal,
     updatedAt: now
   }).where(eq(caldavEvents.id, id)).run();
-  logger9.info("Updated CalDAV event", { id, summary: updates.summary ?? event.summary });
+  logger10.info("Updated CalDAV event", { id, summary: updates.summary ?? event.summary });
   return db2.select().from(caldavEvents).where(eq(caldavEvents.id, id)).get();
 }
 async function deleteEvent(id) {
@@ -1256295,7 +1256789,7 @@ async function deleteEvent(id) {
     }
   });
   db2.delete(caldavEvents).where(eq(caldavEvents.id, id)).run();
-  logger9.info("Deleted CalDAV event", { id, summary: event.summary });
+  logger10.info("Deleted CalDAV event", { id, summary: event.summary });
 }
 function listCopyRules() {
   return db2.select().from(caldavCopyRules).all();
@@ -1256314,7 +1256808,7 @@ function createCopyRule(input) {
     updatedAt: now
   };
   db2.insert(caldavCopyRules).values(rule).run();
-  logger9.info("Created copy rule", { id, source: input.sourceCalendarId, dest: input.destCalendarId });
+  logger10.info("Created copy rule", { id, source: input.sourceCalendarId, dest: input.destCalendarId });
   return rule;
 }
 function updateCopyRule(id, updates) {
@@ -1256327,7 +1256821,7 @@ function updateCopyRule(id, updates) {
 function deleteCopyRule(id) {
   db2.delete(caldavCopiedEvents).where(eq(caldavCopiedEvents.ruleId, id)).run();
   db2.delete(caldavCopyRules).where(eq(caldavCopyRules.id, id)).run();
-  logger9.info("Deleted copy rule", { id });
+  logger10.info("Deleted copy rule", { id });
 }
 async function executeCopyRule(ruleId) {
   const { executeSingleRule: executeSingleRule2 } = await Promise.resolve().then(() => (init_copy_engine(), exports_copy_engine));
@@ -1256770,13 +1257264,13 @@ init_db2();
 init_settings();
 init_google_oauth();
 init_logger3();
-var logger10 = createLogger("GoogleOAuth:Routes");
+var logger11 = createLogger("GoogleOAuth:Routes");
 var app25 = new Hono2;
 app25.get("/authorize", (c) => {
   const accountName = c.req.query("accountName");
   const accountId = c.req.query("accountId");
   const clientOrigin = c.req.query("origin");
-  logger10.info("OAuth authorize request", {
+  logger11.info("OAuth authorize request", {
     accountName,
     accountId,
     clientOrigin,
@@ -1256800,7 +1257294,7 @@ app25.get("/authorize", (c) => {
       accountName: accountName || "Google Account",
       redirectUri
     });
-    logger10.info("OAuth authorize: generating auth URL", {
+    logger11.info("OAuth authorize: generating auth URL", {
       baseUrl,
       redirectUri,
       stateJson: state,
@@ -1256809,18 +1257303,18 @@ app25.get("/authorize", (c) => {
     const authUrl = generateAuthUrl(client4, redirectUri, state);
     try {
       const parsed = new URL(authUrl);
-      logger10.info("OAuth authorize: generated auth URL", {
+      logger11.info("OAuth authorize: generated auth URL", {
         authUrl,
         redirect_uri_in_url: parsed.searchParams.get("redirect_uri"),
         client_id_in_url: parsed.searchParams.get("client_id"),
         scope_in_url: parsed.searchParams.get("scope")
       });
     } catch {
-      logger10.info("OAuth authorize: generated auth URL (unparseable)", { authUrl });
+      logger11.info("OAuth authorize: generated auth URL (unparseable)", { authUrl });
     }
     return c.json({ authUrl });
   } catch (err) {
-    logger10.error("OAuth authorize failed", {
+    logger11.error("OAuth authorize failed", {
       error: err instanceof Error ? err.message : String(err)
     });
     return c.json({ error: err instanceof Error ? err.message : "Failed to generate auth URL" }, 400);
@@ -1256831,7 +1257325,7 @@ app25.get("/callback", async (c) => {
   const error46 = c.req.query("error");
   const stateParam = c.req.query("state");
   const fullUrl = c.req.url;
-  logger10.info("OAuth callback received", {
+  logger11.info("OAuth callback received", {
     hasCode: !!code,
     codePrefix: code?.slice(0, 20) + "...",
     error: error46,
@@ -1256842,11 +1257336,11 @@ app25.get("/callback", async (c) => {
     refererHeader: c.req.header("referer")
   });
   if (error46) {
-    logger10.warn("OAuth callback: Google returned error", { error: error46 });
+    logger11.warn("OAuth callback: Google returned error", { error: error46 });
     return c.html(`<html><body><h2>Authorization Failed</h2><p>${error46}</p><script>setTimeout(()=>window.close(),3000)</script></body></html>`);
   }
   if (!code) {
-    logger10.warn("OAuth callback: missing authorization code");
+    logger11.warn("OAuth callback: missing authorization code");
     return c.html("<html><body><h2>Missing authorization code</h2><script>setTimeout(()=>window.close(),3000)</script></body></html>", 400);
   }
   let state = {
@@ -1256858,9 +1257352,9 @@ app25.get("/callback", async (c) => {
       state = JSON.parse(stateParam);
     }
   } catch {
-    logger10.warn("OAuth callback: failed to parse state param", { stateParam });
+    logger11.warn("OAuth callback: failed to parse state param", { stateParam });
   }
-  logger10.info("OAuth callback: parsed state", {
+  logger11.info("OAuth callback: parsed state", {
     accountId: state.accountId,
     accountName: state.accountName,
     redirectUri: state.redirectUri
@@ -1256871,7 +1257365,7 @@ app25.get("/callback", async (c) => {
       throw new Error("Missing redirect URI in state \u2014 cannot match token exchange");
     }
     const client4 = createOAuth2Client();
-    logger10.info("OAuth callback: exchanging code for tokens", {
+    logger11.info("OAuth callback: exchanging code for tokens", {
       redirectUri,
       clientId: client4._clientId,
       codePrefix: code.slice(0, 20) + "..."
@@ -1256893,7 +1257387,7 @@ app25.get("/callback", async (c) => {
         email: email4 ?? undefined,
         updatedAt: now
       }).where(eq(googleAccounts.id, state.accountId)).run();
-      logger10.info("Re-authorized Google account", {
+      logger11.info("Re-authorized Google account", {
         accountId: state.accountId,
         email: email4
       });
@@ -1256913,7 +1257407,7 @@ app25.get("/callback", async (c) => {
         createdAt: now,
         updatedAt: now
       }).run();
-      logger10.info("Created Google account", {
+      logger11.info("Created Google account", {
         accountId,
         name: state.accountName,
         email: email4
@@ -1256921,7 +1257415,7 @@ app25.get("/callback", async (c) => {
     }
     return c.html("<html><body><h2>Authorization Successful</h2><p>You can close this window.</p><script>setTimeout(()=>window.close(),2000)</script></body></html>");
   } catch (err) {
-    logger10.error("OAuth callback failed", {
+    logger11.error("OAuth callback failed", {
       error: err instanceof Error ? err.message : String(err)
     });
     return c.html(`<html><body><h2>Authorization Failed</h2><p>${err instanceof Error ? err.message : String(err)}</p><script>setTimeout(()=>window.close(),5000)</script></body></html>`, 500);
@@ -1256936,7 +1257430,7 @@ init_google_calendar_manager();
 init_logger3();
 init_settings();
 init_channel_manager();
-var logger11 = createLogger("Google:CalendarService");
+var logger12 = createLogger("Google:CalendarService");
 function listGoogleAccounts() {
   return db2.select().from(googleAccounts).all();
 }
@@ -1256956,19 +1257450,19 @@ async function deleteGoogleAccount(id) {
   }
   db2.delete(caldavCalendars).where(eq(caldavCalendars.googleAccountId, id)).run();
   db2.delete(googleAccounts).where(eq(googleAccounts.id, id)).run();
-  logger11.info("Deleted Google account", { accountId: id });
+  logger12.info("Deleted Google account", { accountId: id });
 }
 async function enableGoogleCalendar(id) {
   const now = new Date().toISOString();
   db2.update(googleAccounts).set({ calendarEnabled: true, updatedAt: now }).where(eq(googleAccounts.id, id)).run();
   await googleCalendarManager.startAccount(id);
-  logger11.info("Enabled Google Calendar for account", { accountId: id });
+  logger12.info("Enabled Google Calendar for account", { accountId: id });
 }
 async function disableGoogleCalendar(id) {
   const now = new Date().toISOString();
   db2.update(googleAccounts).set({ calendarEnabled: false, updatedAt: now }).where(eq(googleAccounts.id, id)).run();
   googleCalendarManager.stopAccount(id);
-  logger11.info("Disabled Google Calendar for account", { accountId: id });
+  logger12.info("Disabled Google Calendar for account", { accountId: id });
 }
 async function enableGmail(id) {
   const now = new Date().toISOString();
@@ -1256978,7 +1257472,7 @@ async function enableGmail(id) {
   updateSettingByPath("channels.email.googleAccountId", id);
   await stopEmailChannel();
   await startEmailChannel();
-  logger11.info("Enabled Gmail for account", { accountId: id });
+  logger12.info("Enabled Gmail for account", { accountId: id });
 }
 async function disableGmail(id) {
   const now = new Date().toISOString();
@@ -1256986,7 +1257480,7 @@ async function disableGmail(id) {
   await stopEmailChannel();
   updateSettingByPath("channels.email.enabled", false);
   updateSettingByPath("channels.email.googleAccountId", null);
-  logger11.info("Disabled Gmail for account", { accountId: id });
+  logger12.info("Disabled Gmail for account", { accountId: id });
 }
 async function syncGoogleCalendar(id) {
   await googleCalendarManager.syncAccount(id);
@@ -1257240,6 +1257734,10 @@ app28.get("/", async (c) => {
   const conversationRole = c.req.query("conversationRole") || undefined;
   const conversationProvider = c.req.query("conversationProvider") || undefined;
   const conversationProjectId = c.req.query("conversationProjectId") || undefined;
+  const gmailFrom = c.req.query("gmailFrom") || undefined;
+  const gmailTo = c.req.query("gmailTo") || undefined;
+  const gmailAfter = c.req.query("gmailAfter") || undefined;
+  const gmailBefore = c.req.query("gmailBefore") || undefined;
   try {
     const results = await search({
       query: query.trim(),
@@ -1257254,7 +1257752,11 @@ app28.get("/", async (c) => {
       memoryTags,
       conversationRole,
       conversationProvider,
-      conversationProjectId
+      conversationProjectId,
+      gmailFrom,
+      gmailTo,
+      gmailAfter,
+      gmailBefore
     });
     return c.json(results);
   } catch (err) {
@@ -1257480,6 +1257982,7 @@ init_logger3();
 init_settings();
 init_assistant_service();
 init_session_mapper();
+init_memory_file_service();
 var HOURLY_INTERVAL = 60 * 60 * 1000;
 var hourlyIntervalId = null;
 var morningTimeoutId = null;
@@ -1257519,10 +1258022,14 @@ async function runHourlySweep() {
     const lastSweep = getLastSweepRun("hourly");
     const actionableMemoryCount = countActionableMemories();
     const openTaskCount = countOpenTasks();
+    const memoryFileContent = readMemoryFile();
+    const memoryFileLineCount = memoryFileContent.trim() ? memoryFileContent.split(`
+`).length : 0;
     log2.assistant.info("Running hourly sweep", {
       runId: run2.id,
       actionableMemories: actionableMemoryCount,
-      openTasks: openTaskCount
+      openTasks: openTaskCount,
+      memoryFileLines: memoryFileLineCount
     });
     const { session: session3 } = getOrCreateSession(SWEEP_SESSION_PREFIX, "sweep-agent", "Assistant Sweep");
     const prompt = `Perform your hourly sweep. Last sweep: ${lastSweep?.completedAt ?? "never"}`;