@knowsuchagency/fulcrum 3.3.0 → 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 };
@@ -1147067,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
@@ -1147402,7 +1147598,7 @@ Fulcrum is your digital concierge - a personal command center where you track ev
 - send_notification
 - 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)
@@ -1147411,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);
@@ -1147420,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();
@@ -1147614,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}`;
   }
@@ -1147869,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", {
@@ -1147929,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;
@@ -1147953,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: {
@@ -1147973,6 +1148185,7 @@ ${attachment.data}`);
         permissionMode: "bypassPermissions",
         allowDangerouslySkipPermissions: true,
         settingSources: ["user"],
+        ...options.ephemeral && { persistSession: false, maxTurns: 3 },
         ...options.outputFormat && { outputFormat: options.outputFormat }
       }
     });
@@ -1147998,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) {
@@ -1148032,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) {
@@ -1148045,7 +1148264,7 @@ ${attachment.data}`);
         });
       }
     }
-    if (currentText.trim()) {
+    if (!options.ephemeral && currentText.trim()) {
       addMessage(sessionId, {
         role: "assistant",
         content: currentText,
@@ -1148059,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) {
@@ -1149957,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,
@@ -1149990,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();
@@ -1150104,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,
@@ -1150112,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);
     }
@@ -1150255,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", {
@@ -1150361,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") {
@@ -1150382,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();
@@ -1150394,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,
@@ -1150689,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 });
@@ -1208698,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);
 }
@@ -1209355,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)) {
@@ -1211946,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";
@@ -1212023,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 });
@@ -1212047,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");
   }
@@ -1215930,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";
@@ -1216215,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))) {
@@ -1216271,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 {
@@ -1216286,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);
@@ -1216364,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);
               }
@@ -1216458,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);
@@ -1216484,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 {
@@ -1216700,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("=");
@@ -1216715,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 {
@@ -1216730,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+/);
@@ -1216846,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;
@@ -1218440,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() {
@@ -1218668,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];
@@ -1218877,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}`);
@@ -1219852,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, "_");
 }
@@ -1220839,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)) {
@@ -1251893,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)",
@@ -1251993,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) {
@@ -1252014,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)"),
@@ -1252106,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)"),
@@ -1252144,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,
@@ -1252180,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"),
@@ -1252197,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)")
@@ -1252221,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")
@@ -1252254,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")
@@ -1252290,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 }) => {
@@ -1252459,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) => {
@@ -1253348,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;
@@ -1253372,7 +1253737,8 @@ var registerAssistantTools = (server2, client3) => {
         body,
         subject,
         replyToMessageId,
-        slackBlocks: slack_blocks
+        slackBlocks: slack_blocks,
+        filePath
       });
       return formatSuccess(result);
     } catch (err) {
@@ -1253643,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"])'),
@@ -1253656,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();
@@ -1253668,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.')
@@ -1253770,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;
@@ -1253794,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 {}
@@ -1253834,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;
@@ -1254097,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);
@@ -1254184,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);
@@ -1254602,7 +1255022,7 @@ mcpRoutes.all("/", async (c) => {
   });
   const server2 = new McpServer({
     name: "fulcrum",
-    version: "3.3.0"
+    version: "3.4.0"
   });
   const client3 = new FulcrumClient(`http://localhost:${port}`);
   registerTools(server2, client3);
@@ -1254625,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);
 });
@@ -1255687,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", {
@@ -1257559,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;
@@ -1257598,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"}`;